Język

Vector256 Klasa

Definicja

Przestrzeń nazw:
System.Runtime.Intrinsics
Zestaw:
System.Runtime.Intrinsics.dll
Źródło:
Vector256.cs
Źródło:
Vector256.cs
Źródło:
Vector256.cs
Źródło:
Vector256.cs
Źródło:
Vector256.cs

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.

public ref class Vector256 abstract sealed
public static class Vector256
type Vector256 = class
Public Module Vector256
Dziedziczenie
Object
Vector256

Właściwości

Nazwa Opis
E

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
Epsilon

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
IsHardwareAccelerated

Pobiera wartość wskazującą, czy operacje wektorów 256-bitowych podlegają przyspieszeniu sprzętowemu dzięki obsłudze wewnętrznej JIT.
NaN

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
NegativeInfinity

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
NegativeOne

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
NegativeZero

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
Pi

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
PositiveInfinity

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
SignSequence

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
Tau

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.

Metody

Nazwa Opis
Abs<T>(Vector256<T>)

Oblicza wartość bezwzględną każdego elementu w wektorze.
Add<T>(Vector256<T>, Vector256<T>)

Dodaje dwa wektory, aby obliczyć ich sumę.
AddSaturate<T>(Vector256<T>, Vector256<T>)

Dodaje dwa wektory do obliczenia ich sumy nasyconych mądry element.
All<T>(Vector256<T>, T)

Określa, czy wszystkie elementy wektora są równe danej wartości.
AllWhereAllBitsSet<T>(Vector256<T>)

Określa, czy wszystkie elementy wektora mają wszystkie ustawione bity.
AndNot<T>(Vector256<T>, Vector256<T>)

Oblicza bitowe i danego wektora oraz te uzupełniają inny wektor.
Any<T>(Vector256<T>, T)

Określa, czy jakiekolwiek elementy wektora są równe danej wartości.
AnyWhereAllBitsSet<T>(Vector256<T>)

Określa, czy jakiekolwiek elementy wektora mają ustawione wszystkie bity.
As<T,U>(Vector256<T>)

Ponownie interpretuje Vector256<T> typ TFrom jako nowy Vector256<T> typ TTo.
AsByte<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ Byte.
AsDouble<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ Double.
Asin(Vector256<Double>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
Asin(Vector256<Single>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
AsInt16<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ Int16.
AsInt32<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ Int32.
AsInt64<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ Int64.
AsNInt<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256<T>.
AsNUInt<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256<T>.
AsSByte<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ SByte.
AsSingle<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ Single.
AsUInt16<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ UInt16.
AsUInt32<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ UInt32.
AsUInt64<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector256 typ UInt64.
AsVector<T>(Vector256<T>)

Ponownie interpretuje element Vector256<T> jako nowy Vector<T>.
AsVector256<T>(Vector<T>)

Ponownie interpretuje element Vector<T> jako nowy Vector256<T>.
BitwiseAnd<T>(Vector256<T>, Vector256<T>)

Oblicza bitowe i dwa wektory.
BitwiseOr<T>(Vector256<T>, Vector256<T>)

Oblicza bitowe lub dwa wektory.
Ceiling(Vector256<Double>)

Oblicza pułap każdego elementu w wektorze.
Ceiling(Vector256<Single>)

Oblicza pułap każdego elementu w wektorze.
Clamp<T>(Vector256<T>, Vector256<T>, Vector256<T>)

Ogranicza wektor między wartością minimalną a maksymalną.
ClampNative<T>(Vector256<T>, Vector256<T>, Vector256<T>)

Ogranicza wektor między wartością minimalną a maksymalną przy użyciu zachowania specyficznego dla platformy dla NaN i NegativeZero.
ConcatLowerLower<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
ConcatLowerUpper<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
ConcatUpperLower<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
ConcatUpperUpper<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
ConditionalSelect<T>(Vector256<T>, Vector256<T>, Vector256<T>)

Warunkowo wybiera wartość z dwóch wektorów na zasadzie bitowej.
ConvertToDouble(Vector256<Int64>)

Konwertuje element na Vector256<T> .Vector256<T>
ConvertToDouble(Vector256<UInt64>)

Konwertuje element na Vector256<T> .Vector256<T>
ConvertToInt32(Vector256<Single>)

Konwertuje element na Vector256<T> .Vector256<T>
ConvertToInt32Native(Vector256<Single>)

Konwertuje Vector256<Single> element na przy użyciu specyficznego Vector256<Int32> dla platformy zachowanie w przypadku przepełnienia.
ConvertToInt64(Vector256<Double>)

Konwertuje element na Vector256<T> .Vector256<T>
ConvertToInt64Native(Vector256<Double>)

Konwertuje Vector256<Double> element na przy użyciu specyficznego Vector256<Int64> dla platformy zachowanie w przypadku przepełnienia.
ConvertToSingle(Vector256<Int32>)

Konwertuje element na Vector256<T> .Vector256<T>
ConvertToSingle(Vector256<UInt32>)

Konwertuje element na Vector256<T> .Vector256<T>
ConvertToUInt32(Vector256<Single>)

Konwertuje element na Vector256<T> .Vector256<T>
ConvertToUInt32Native(Vector256<Single>)

Konwertuje Vector256<Single> element na przy użyciu specyficznego Vector256<UInt32> dla platformy zachowanie w przypadku przepełnienia.
ConvertToUInt64(Vector256<Double>)

Konwertuje element na Vector256<T> .Vector256<T>
ConvertToUInt64Native(Vector256<Double>)

Konwertuje Vector256<Double> element na przy użyciu specyficznego Vector256<UInt64> dla platformy zachowanie w przypadku przepełnienia.
CopySign<T>(Vector256<T>, Vector256<T>)

Kopiuje znak każdego elementu wektora do znaku poszczególnych elementów innego wektora.
CopyTo<T>(Vector256<T>, Span<T>)

Kopiuje element Vector256<T> do danego zakresu.
CopyTo<T>(Vector256<T>, T[], Int32)

Kopiuje Vector256<T> element do danej tablicy rozpoczynającej się od określonego indeksu.
CopyTo<T>(Vector256<T>, T[])

Kopiuje element Vector256<T> do danej tablicy.
Cos(Vector256<Double>)

Oblicza cosinus każdego elementu w wektorze.
Cos(Vector256<Single>)

Oblicza cosinus każdego elementu w wektorze.
Count<T>(Vector256<T>, T)

Określa liczbę elementów w wektorze, które są równe danej wartości.
CountWhereAllBitsSet<T>(Vector256<T>)

Określa liczbę elementów w wektorze, które mają wszystkie zestawy bitów.
Create(Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(Byte)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(Double, Double, Double, Double)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(Double)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(Int16)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(Int32)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(Int64, Int64, Int64, Int64)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(Int64)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(IntPtr)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(SByte)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(Single, Single, Single, Single, Single, Single, Single, Single)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(Single)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(UInt16)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(UInt32)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(UInt64, UInt64, UInt64, UInt64)

Tworzy nowe Vector256<T> wystąpienie z każdym elementem zainicjowanym do odpowiedniej określonej wartości.
Create(UInt64)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(UIntPtr)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create(Vector128<Byte>, Vector128<Byte>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<Double>, Vector128<Double>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<Int16>, Vector128<Int16>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<Int32>, Vector128<Int32>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<Int64>, Vector128<Int64>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<IntPtr>, Vector128<IntPtr>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<SByte>, Vector128<SByte>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<Single>, Vector128<Single>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<UInt16>, Vector128<UInt16>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<UInt32>, Vector128<UInt32>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<UInt64>, Vector128<UInt64>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create(Vector128<UIntPtr>, Vector128<UIntPtr>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create<T>(ReadOnlySpan<T>)

Tworzy nowy Vector256<T> element na podstawie danego zakresu odczytu.
Create<T>(T)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi elementami zainicjowanymi do określonej wartości.
Create<T>(T[], Int32)

Tworzy nową Vector256<T> z danej tablicy.
Create<T>(T[])

Tworzy nową Vector256<T> z danej tablicy.
Create<T>(Vector128<T>, Vector128<T>)

Tworzy nowe Vector256<T> wystąpienie na podstawie dwóch Vector128<T> wystąpień.
Create<T>(Vector128<T>)

Tworzy nowe Vector256<T> wystąpienie z dolną i górną 128-bitową zainicjowaną określoną wartością.
Create<T>(Vector64<T>)

Tworzy nowe Vector256<T> wystąpienie ze wszystkimi 64-bitowymi częściami zainicjowanymi do określonej wartości.
CreateAlternatingSequence<T>(T, T)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
CreateGeometricSequence<T>(T, T)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
CreateHarmonicSequence<T>(T, T)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
CreateScalar(Byte)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(Double)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(Int16)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(Int32)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(Int64)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(IntPtr)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(SByte)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(Single)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(UInt16)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(UInt32)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(UInt64)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar(UIntPtr)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalar<T>(T)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości i pozostałymi elementami zainicjowanymi na zero.
CreateScalarUnsafe(Byte)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(Double)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(Int16)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(Int32)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(Int64)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(IntPtr)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(SByte)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(Single)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(UInt16)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(UInt32)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(UInt64)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe(UIntPtr)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateScalarUnsafe<T>(T)

Tworzy nowe Vector256<T> wystąpienie z pierwszym elementem zainicjowanym do określonej wartości, a pozostałe elementy pozostawione niezainicjowane.
CreateSequence<T>(T, T)

Tworzy nowe Vector256<T> wystąpienie, w którym elementy zaczynają się od określonej wartości i które są rozdzielone spacjami zgodnie z inną określoną wartością.
DegreesToRadians(Vector256<Double>)

Konwertuje dany wektor z stopni na radiany.
DegreesToRadians(Vector256<Single>)

Konwertuje dany wektor z stopni na radiany.
Divide<T>(Vector256<T>, T)

Dzieli wektor przez skalarny, aby obliczyć iloraz dla poszczególnych elementów.
Divide<T>(Vector256<T>, Vector256<T>)

Dzieli dwa wektory, aby obliczyć ich iloraz.
Dot<T>(Vector256<T>, Vector256<T>)

Oblicza iloczyn kropkowy dwóch wektorów.
Equals<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy są one równe dla poszczególnych elementów.
EqualsAll<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy wszystkie elementy są równe.
EqualsAny<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy jakiekolwiek elementy są równe.
Exp(Vector256<Double>)

Oblicza wykładnik każdego elementu w wektorze.
Exp(Vector256<Single>)

Oblicza wykładnik każdego elementu w wektorze.
ExtractMostSignificantBits<T>(Vector256<T>)

Wyodrębnia najbardziej znaczący bit z każdego elementu w wektorze.
Floor(Vector256<Double>)

Oblicza podłogę każdego elementu w wektorze.
Floor(Vector256<Single>)

Oblicza podłogę każdego elementu w wektorze.
FusedMultiplyAdd(Vector256<Double>, Vector256<Double>, Vector256<Double>)

Obliczenia (left * right) i addend, zaokrąglone jako jedna operacjaternary.
FusedMultiplyAdd(Vector256<Single>, Vector256<Single>, Vector256<Single>)

Obliczenia (left * right) i addend, zaokrąglone jako jedna operacjaternary.
get_E<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
get_Epsilon<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
get_NaN<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
get_NegativeInfinity<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
get_NegativeOne<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
get_NegativeZero<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
get_Pi<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
get_PositiveInfinity<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
get_SignSequence<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
get_Tau<T>()

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
GetElement<T>(Vector256<T>, Int32)

Pobiera element w określonym indeksie.
GetLower<T>(Vector256<T>)

Pobiera wartość niższych 128 bitów jako nową Vector128<T>wartość .
GetUpper<T>(Vector256<T>)

Pobiera wartość górnej 128 bitów jako nową Vector128<T>wartość .
GreaterThan<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, co jest większe dla poszczególnych elementów.
GreaterThanAll<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy wszystkie elementy są większe.
GreaterThanAny<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy jakiekolwiek elementy są większe.
GreaterThanOrEqual<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, które wartości są większe lub równe dla poszczególnych elementów.
GreaterThanOrEqualAll<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy wszystkie elementy są większe lub równe.
GreaterThanOrEqualAny<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy jakiekolwiek elementy są większe lub równe.
Hypot(Vector256<Double>, Vector256<Double>)

Oblicza niedocięcie, biorąc pod uwagę dwa wektory reprezentujące długości krótszych boków w trójkątach kątowych po prawej stronie.
Hypot(Vector256<Single>, Vector256<Single>)

Oblicza niedocięcie, biorąc pod uwagę dwa wektory reprezentujące długości krótszych boków w trójkątach kątowych po prawej stronie.
IndexOf<T>(Vector256<T>, T)

Określa indeks pierwszego elementu w wektorze, który jest równy danej wartości.
IndexOfWhereAllBitsSet<T>(Vector256<T>)

Określa indeks pierwszego elementu w wektorze, który ma wszystkie bity ustawione.
IsEvenInteger<T>(Vector256<T>)

Określa, które elementy w wektorze są nawet wartościami całkowitymi.
IsFinite<T>(Vector256<T>)

Określa, które elementy w wektorze są skończone.
IsInfinity<T>(Vector256<T>)

Określa, które elementy w wektorze są nieskończone.
IsInteger<T>(Vector256<T>)

Określa, które elementy w wektorze są wartościami całkowitymi.
IsNaN<T>(Vector256<T>)

Określa, które elementy w wektorze to NaN.
IsNegative<T>(Vector256<T>)

Określa, które elementy w wektorze reprezentują ujemne liczby rzeczywiste.
IsNegativeInfinity<T>(Vector256<T>)

Określa, które elementy w wektorze są ujemną nieskończonością.
IsNormal<T>(Vector256<T>)

Określa, które elementy w wektorze są normalne.
IsOddInteger<T>(Vector256<T>)

Określa, które elementy w wektorze są dziwne wartości całkowite.
IsPositive<T>(Vector256<T>)

Określa, które elementy w wektorze reprezentują dodatnie liczby rzeczywiste.
IsPositiveInfinity<T>(Vector256<T>)

Określa, które elementy w wektorze są dodatnią nieskończonością.
IsSubnormal<T>(Vector256<T>)

Określa, które elementy w wektorze są podnormalne.
IsZero<T>(Vector256<T>)

Określa, które elementy w wektorze mają wartość zero.
LastIndexOf<T>(Vector256<T>, T)

Określa indeks ostatniego elementu w wektorze, który jest równy danej wartości.
LastIndexOfWhereAllBitsSet<T>(Vector256<T>)

Określa indeks ostatniego elementu w wektorze, który ma ustawione wszystkie bity.
Lerp(Vector256<Double>, Vector256<Double>, Vector256<Double>)

Wykonuje interpolację liniową między dwoma wektorami na podstawie danej wagi.
Lerp(Vector256<Single>, Vector256<Single>, Vector256<Single>)

Wykonuje interpolację liniową między dwoma wektorami na podstawie danej wagi.
LessThan<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, które są mniejsze dla poszczególnych elementów.
LessThanAll<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy wszystkie elementy są mniejsze.
LessThanAny<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy jakiekolwiek elementy są mniejsze.
LessThanOrEqual<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, które z nich są mniejsze lub równe dla poszczególnych elementów.
LessThanOrEqualAll<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy wszystkie elementy są mniejsze lub równe.
LessThanOrEqualAny<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, aby określić, czy jakiekolwiek elementy są mniejsze lub równe.
Load<T>(T*)

Ładuje wektor z danego źródła.
LoadAligned<T>(T*)

Ładuje wektor z danego wyrównanego źródła.
LoadAlignedNonTemporal<T>(T*)

Ładuje wektor z danego wyrównanego źródła.
LoadUnsafe<T>(T, UIntPtr)

Ładuje wektor z danego przesunięcia źródła i elementu.
LoadUnsafe<T>(T)

Ładuje wektor z danego źródła.
Log(Vector256<Double>)

Oblicza dziennik każdego elementu w wektorze.
Log(Vector256<Single>)

Oblicza dziennik każdego elementu w wektorze.
Log2(Vector256<Double>)

Oblicza dziennik2 każdego elementu w wektorze.
Log2(Vector256<Single>)

Oblicza dziennik2 każdego elementu w wektorze.
Max<T>(Vector256<T>, Vector256<T>)

Oblicza maksymalnie dwa wektory na podstawie poszczególnych elementów.
MaxMagnitude<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory do obliczeń, które mają większą wielkość dla poszczególnych elementów.
MaxMagnitudeNumber<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, na podstawie poszczególnych elementów, do obliczeń, które mają większą wielkość i zwracają drugą wartość, jeśli dane wejściowe to NaN.
MaxNative<T>(Vector256<T>, Vector256<T>)

Porównaj dwa wektory, aby określić, które elementy są większe dla poszczególnych elementów przy użyciu konkretnego zachowania platformy dla NaN i NegativeZero.
MaxNumber<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, na podstawie poszczególnych elementów, do obliczenia, które jest większe i zwraca inną wartość, jeśli element ma NaNwartość .
Min<T>(Vector256<T>, Vector256<T>)

Oblicza co najmniej dwa wektory na podstawie poszczególnych elementów.
MinMagnitude<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory do obliczeń, które mają mniejszą wielkość na podstawie poszczególnych elementów.
MinMagnitudeNumber<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, na podstawie poszczególnych elementów, do obliczeń, które mają mniejszą wielkość i zwracają drugą wartość, jeśli dane wejściowe to NaN.
MinNative<T>(Vector256<T>, Vector256<T>)

Porównaj dwa wektory, aby określić, które z nich jest mniejsze dla poszczególnych elementów przy użyciu konkretnego zachowania platformy dla NaN i NegativeZero.
MinNumber<T>(Vector256<T>, Vector256<T>)

Porównuje dwa wektory, na podstawie poszczególnych elementów, do obliczenia, które jest mniejsze i zwraca drugą wartość, jeśli element ma wartość NaN.
Multiply<T>(T, Vector256<T>)

Mnoży wektor przez skalarny, aby obliczyć swój produkt.
Multiply<T>(Vector256<T>, T)

Mnoży wektor przez skalarny, aby obliczyć swój produkt.
Multiply<T>(Vector256<T>, Vector256<T>)

Mnoży dwa wektory, aby obliczyć ich produkt mądry elementami.
MultiplyAddEstimate(Vector256<Double>, Vector256<Double>, Vector256<Double>)

Oblicza oszacowanie (left * right) i . addend
MultiplyAddEstimate(Vector256<Single>, Vector256<Single>, Vector256<Single>)

Oblicza oszacowanie (left * right) i . addend
Narrow(Vector256<Double>, Vector256<Double>)

Zawęża dwa Vector256<T> wystąpienia do jednego Vector256<T>.
Narrow(Vector256<Int16>, Vector256<Int16>)

Zawęża dwa Vector256<T> wystąpienia do jednego Vector256<T>.
Narrow(Vector256<Int32>, Vector256<Int32>)

Zawęża dwa Vector256<T> wystąpienia do jednego Vector256<T>.
Narrow(Vector256<Int64>, Vector256<Int64>)

Zawęża dwa Vector256<T> wystąpienia do jednego Vector256<T>.
Narrow(Vector256<UInt16>, Vector256<UInt16>)

Zawęża dwa Vector256<T> wystąpienia do jednego Vector256<T>.
Narrow(Vector256<UInt32>, Vector256<UInt32>)

Zawęża dwa Vector256<T> wystąpienia do jednego Vector256<T>.
Narrow(Vector256<UInt64>, Vector256<UInt64>)

Zawęża dwa Vector256<T> wystąpienia do jednego Vector256<T>.
NarrowWithSaturation(Vector256<Double>, Vector256<Double>)

Zawęża dwa wektory wystąpień do jednego wektora DoubleSingle przy użyciu konwersji saturacji.
NarrowWithSaturation(Vector256<Int16>, Vector256<Int16>)

Zawęża dwa wektory wystąpień do jednego wektora Int16SByte przy użyciu konwersji saturacji.
NarrowWithSaturation(Vector256<Int32>, Vector256<Int32>)

Zawęża dwa wektory wystąpień do jednego wektora Int32Int16 przy użyciu konwersji saturacji.
NarrowWithSaturation(Vector256<Int64>, Vector256<Int64>)

Zawęża dwa wektory wystąpień do jednego wektora Int64Int32 przy użyciu konwersji saturacji.
NarrowWithSaturation(Vector256<UInt16>, Vector256<UInt16>)

Zawęża dwa wektory wystąpień do jednego wektora UInt16Byte przy użyciu konwersji saturacji.
NarrowWithSaturation(Vector256<UInt32>, Vector256<UInt32>)

Zawęża dwa wektory wystąpień do jednego wektora UInt32UInt16 przy użyciu konwersji saturacji.
NarrowWithSaturation(Vector256<UInt64>, Vector256<UInt64>)

Zawęża dwa wektory wystąpień do jednego wektora UInt64UInt32 przy użyciu konwersji saturacji.
Negate<T>(Vector256<T>)

Neguje wektor.
None<T>(Vector256<T>, T)

Określa, czy żadne elementy wektora nie są równe danej wartości.
NoneWhereAllBitsSet<T>(Vector256<T>)

Określa, czy nie ustawiono żadnych elementów wektora.
OnesComplement<T>(Vector256<T>)

Oblicza uzupełnienie jedynek wektora.
RadiansToDegrees(Vector256<Double>)

Konwertuje dany wektor z radianów na stopnie.
RadiansToDegrees(Vector256<Single>)

Konwertuje dany wektor z radianów na stopnie.
Reverse<T>(Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
Round(Vector256<Double>, MidpointRounding)

Zaokrągla każdy element w wektorze do najbliższej liczby całkowitej przy użyciu określonego trybu zaokrąglania.
Round(Vector256<Double>)

Zaokrągla każdy element w wektorze do najbliższej liczby całkowitej przy użyciu domyślnego trybu zaokrąglania (ToEven).
Round(Vector256<Single>, MidpointRounding)

Zaokrągla każdy element w wektorze do najbliższej liczby całkowitej przy użyciu określonego trybu zaokrąglania.
Round(Vector256<Single>)

Zaokrągla każdy element w wektorze do najbliższej liczby całkowitej przy użyciu domyślnego trybu zaokrąglania (ToEven).
ShiftLeft(Vector256<Byte>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftLeft(Vector256<Int16>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftLeft(Vector256<Int32>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftLeft(Vector256<Int64>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftLeft(Vector256<IntPtr>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftLeft(Vector256<SByte>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftLeft(Vector256<UInt16>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftLeft(Vector256<UInt32>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftLeft(Vector256<UInt64>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftLeft(Vector256<UIntPtr>, Int32)

Przesuwa każdy element wektora w lewo o określoną ilość.
ShiftRightArithmetic(Vector256<Int16>, Int32)

Przesuwa (podpisany) każdy element wektora w prawo o określoną ilość.
ShiftRightArithmetic(Vector256<Int32>, Int32)

Przesuwa (podpisany) każdy element wektora w prawo o określoną ilość.
ShiftRightArithmetic(Vector256<Int64>, Int32)

Przesuwa (podpisany) każdy element wektora w prawo o określoną ilość.
ShiftRightArithmetic(Vector256<IntPtr>, Int32)

Przesuwa (podpisany) każdy element wektora w prawo o określoną ilość.
ShiftRightArithmetic(Vector256<SByte>, Int32)

Przesuwa (podpisany) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<Byte>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<Int16>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<Int32>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<Int64>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<IntPtr>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<SByte>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<UInt16>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<UInt32>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<UInt64>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
ShiftRightLogical(Vector256<UIntPtr>, Int32)

Przesuwa (bez znaku) każdy element wektora w prawo o określoną ilość.
Shuffle(Vector256<Byte>, Vector256<Byte>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<Double>, Vector256<Int64>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<Int16>, Vector256<Int16>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<Int32>, Vector256<Int32>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<Int64>, Vector256<Int64>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<IntPtr>, Vector256<IntPtr>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
Shuffle(Vector256<SByte>, Vector256<SByte>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<Single>, Vector256<Int32>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<UInt16>, Vector256<UInt16>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<UInt32>, Vector256<UInt32>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<UInt64>, Vector256<UInt64>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
Shuffle(Vector256<UIntPtr>, Vector256<UIntPtr>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
ShuffleNative(Vector256<Byte>, Vector256<Byte>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.

Zachowanie jest zależne od platformy dla indeksów poza zakresem.
ShuffleNative(Vector256<Double>, Vector256<Int64>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
ShuffleNative(Vector256<Int16>, Vector256<Int16>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
ShuffleNative(Vector256<Int32>, Vector256<Int32>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
ShuffleNative(Vector256<Int64>, Vector256<Int64>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
ShuffleNative(Vector256<IntPtr>, Vector256<IntPtr>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
ShuffleNative(Vector256<SByte>, Vector256<SByte>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.

Zachowanie jest zależne od platformy dla indeksów poza zakresem.
ShuffleNative(Vector256<Single>, Vector256<Int32>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
ShuffleNative(Vector256<UInt16>, Vector256<UInt16>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
ShuffleNative(Vector256<UInt32>, Vector256<UInt32>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
ShuffleNative(Vector256<UInt64>, Vector256<UInt64>)

Tworzy nowy wektor, wybierając wartości z wektora wejściowego przy użyciu zestawu indeksów.
ShuffleNative(Vector256<UIntPtr>, Vector256<UIntPtr>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
Sin(Vector256<Double>)

Oblicza sinus każdego elementu w wektorze.
Sin(Vector256<Single>)

Oblicza sinus każdego elementu w wektorze.
SinCos(Vector256<Double>)

Oblicza sinus i cosinus każdego elementu w wektorze.
SinCos(Vector256<Single>)

Oblicza sinus i cosinus każdego elementu w wektorze.
Sqrt<T>(Vector256<T>)

Oblicza pierwiastek kwadratowy wektora na podstawie poszczególnych elementów.
Store<T>(Vector256<T>, T*)

Przechowuje wektor w danym miejscu docelowym.
StoreAligned<T>(Vector256<T>, T*)

Przechowuje wektor w danym wyrównanym miejscu docelowym.
StoreAlignedNonTemporal<T>(Vector256<T>, T*)

Przechowuje wektor w danym wyrównanym miejscu docelowym.
StoreUnsafe<T>(Vector256<T>, T, UIntPtr)

Przechowuje wektor w danym miejscu docelowym.
StoreUnsafe<T>(Vector256<T>, T)

Przechowuje wektor w danym miejscu docelowym.
Subtract<T>(Vector256<T>, Vector256<T>)

Odejmuje dwa wektory, aby obliczyć ich różnicę.
SubtractSaturate<T>(Vector256<T>, Vector256<T>)

Odejmuje dwa wektory, aby obliczyć różnicę nasyconą przez element.
Sum<T>(Vector256<T>)

Oblicza sumę wszystkich elementów w wektorze.
ToScalar<T>(Vector256<T>)

Konwertuje dany wektor na skalarny zawierający wartość pierwszego elementu.
ToVector512<T>(Vector256<T>)

Konwertuje dany wektor na nowy Vector512<T> z dolnymi 256-bitami ustawionymi na wartość danego wektora i górne 256-bitowe zainicjowane na zero.
ToVector512Unsafe<T>(Vector256<T>)

Konwertuje dany wektor na nowy Vector512<T> z dolnymi 256-bitami ustawionymi na wartość danego wektora i górne 256-bitowe pozostawione niezainicjowane.
Truncate(Vector256<Double>)

Obcina każdy element w wektorze.
Truncate(Vector256<Single>)

Obcina każdy element w wektorze.
TryCopyTo<T>(Vector256<T>, Span<T>)

Próbuje skopiować element Vector<T> do danego zakresu.
Unzip<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
UnzipEven<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
UnzipOdd<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
Widen(Vector256<Byte>)

Rozszerza element Vector256<T> na dwa Vector256<T>.
Widen(Vector256<Int16>)

Rozszerza element Vector256<T> na dwa Vector256<T>.
Widen(Vector256<Int32>)

Rozszerza element Vector256<T> na dwa Vector256<T>.
Widen(Vector256<SByte>)

Rozszerza element Vector256<T> na dwa Vector256<T>.
Widen(Vector256<Single>)

Rozszerza element Vector256<T> na dwa Vector256<T>.
Widen(Vector256<UInt16>)

Rozszerza element Vector256<T> na dwa Vector256<T>.
Widen(Vector256<UInt32>)

Rozszerza element Vector256<T> na dwa Vector256<T>.
WidenLower(Vector256<Byte>)

Rozszerza dolną połowę Vector256<T> na Vector256<T>.
WidenLower(Vector256<Int16>)

Rozszerza dolną połowę Vector256<T> na Vector256<T>.
WidenLower(Vector256<Int32>)

Rozszerza dolną połowę Vector256<T> na Vector256<T>.
WidenLower(Vector256<SByte>)

Rozszerza dolną połowę Vector256<T> na Vector256<T>.
WidenLower(Vector256<Single>)

Rozszerza dolną połowę Vector256<T> na Vector256<T>.
WidenLower(Vector256<UInt16>)

Rozszerza dolną połowę Vector256<T> na Vector256<T>.
WidenLower(Vector256<UInt32>)

Rozszerza dolną połowę Vector256<T> na Vector256<T>.
WidenUpper(Vector256<Byte>)

Rozszerza górną połowę Vector256<T> na .Vector256<T>
WidenUpper(Vector256<Int16>)

Rozszerza górną połowę Vector256<T> na .Vector256<T>
WidenUpper(Vector256<Int32>)

Rozszerza górną połowę Vector256<T> na .Vector256<T>
WidenUpper(Vector256<SByte>)

Rozszerza górną połowę Vector256<T> na .Vector256<T>
WidenUpper(Vector256<Single>)

Rozszerza górną połowę Vector256<T> na .Vector256<T>
WidenUpper(Vector256<UInt16>)

Rozszerza górną połowę Vector256<T> na .Vector256<T>
WidenUpper(Vector256<UInt32>)

Rozszerza górną połowę Vector256<T> na .Vector256<T>
WithElement<T>(Vector256<T>, Int32, T)

Tworzy nowy Vector256<T> element z określonym indeksem ustawionym na określoną wartość, a pozostałe elementy ustawione na tę samą wartość co w danym wektorze.
WithLower<T>(Vector256<T>, Vector128<T>)

Tworzy nowy Vector256<T> z dolnymi 128 bitami ustawionymi na określoną wartość, a górne 128 bitów ustawione na tę samą wartość co w danym wektorze.
WithUpper<T>(Vector256<T>, Vector128<T>)

Tworzy nowy Vector256<T> element z górnymi 128 bitami ustawionymi na określoną wartość, a dolne 128 bitów ustawione na tę samą wartość co w danym wektorze.
Xor<T>(Vector256<T>, Vector256<T>)

Oblicza wyłączność lub dwa wektory.
Zip<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
ZipLower<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.
ZipUpper<T>(Vector256<T>, Vector256<T>)

Udostępnia kolekcję metod statycznych do tworzenia, manipulowania i w inny sposób działania na wektorach 256-bitowych.

Dotyczy