Vector256 Classe

Définition

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

public ref class Vector256 abstract sealed
public static class Vector256
type Vector256 = class
Public Module Vector256
Héritage
Vector256

Propriétés

Nom Description
E

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

Epsilon

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

IsHardwareAccelerated

Obtient une valeur qui indique si les opérations vectorielles 256 bits sont soumises à l’accélération matérielle par le biais de la prise en charge intrinsèque JIT.

NaN

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

NegativeInfinity

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

NegativeOne

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

NegativeZero

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

Pi

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

PositiveInfinity

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

Tau

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

Méthodes

Nom Description
Abs<T>(Vector256<T>)

Calcule la valeur absolue de chaque élément dans un vecteur.

Add<T>(Vector256<T>, Vector256<T>)

Ajoute deux vecteurs pour calculer leur somme.

AddSaturate<T>(Vector256<T>, Vector256<T>)

Ajoute deux vecteurs pour calculer leur somme saturée d’éléments.

All<T>(Vector256<T>, T)

Détermine si tous les éléments d’un vecteur sont égaux à une valeur donnée.

AllWhereAllBitsSet<T>(Vector256<T>)

Détermine si tous les éléments d’un vecteur ont tous leurs bits définis.

AndNot<T>(Vector256<T>, Vector256<T>)

Calcule le bit et d’un vecteur donné et le complément d’un autre vecteur.

Any<T>(Vector256<T>, T)

Détermine si des éléments d’un vecteur sont égaux à une valeur donnée.

AnyWhereAllBitsSet<T>(Vector256<T>)

Détermine si tous les éléments d’un vecteur ont tous leurs bits définis.

As<T,U>(Vector256<T>)

Réinterpret un Vector256<T> type TFrom en tant que nouveau Vector256<T> de type TTo.

AsByte<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type Byte.

AsDouble<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type Double.

Asin(Vector256<Double>)

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

Asin(Vector256<Single>)

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

AsInt16<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type Int16.

AsInt32<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type Int32.

AsInt64<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type Int64.

AsNInt<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256<T>.

AsNUInt<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256<T>.

AsSByte<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type SByte.

AsSingle<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type Single.

AsUInt16<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type UInt16.

AsUInt32<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type UInt32.

AsUInt64<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector256 type UInt64.

AsVector<T>(Vector256<T>)

Réinterpret un Vector256<T> nouveau Vector<T>.

AsVector256<T>(Vector<T>)

Réinterpret un Vector<T> nouveau Vector256<T>.

BitwiseAnd<T>(Vector256<T>, Vector256<T>)

Calcule le bit et deux vecteurs.

BitwiseOr<T>(Vector256<T>, Vector256<T>)

Calcule le bit ou deux vecteurs.

Ceiling(Vector256<Double>)

Calcule le plafond de chaque élément dans un vecteur.

Ceiling(Vector256<Single>)

Calcule le plafond de chaque élément dans un vecteur.

Clamp<T>(Vector256<T>, Vector256<T>, Vector256<T>)

Limite un vecteur entre une valeur minimale et une valeur maximale.

ClampNative<T>(Vector256<T>, Vector256<T>, Vector256<T>)

Limite un vecteur entre une valeur minimale et une valeur maximale à l’aide d’un comportement spécifique à la plateforme pour NaN et NegativeZero.

ConditionalSelect<T>(Vector256<T>, Vector256<T>, Vector256<T>)

Sélectionne de manière conditionnelle une valeur à partir de deux vecteurs au niveau du bit.

ConvertToDouble(Vector256<Int64>)

Convertit une Vector256<T> en une Vector256<T>.

ConvertToDouble(Vector256<UInt64>)

Convertit une Vector256<T> en une Vector256<T>.

ConvertToInt32(Vector256<Single>)

Convertit une Vector256<T> en une Vector256<T>.

ConvertToInt32Native(Vector256<Single>)

Convertit un Vector256<Single> comportement spécifique à une Vector256<Int32> plateforme en cas de dépassement de capacité.

ConvertToInt64(Vector256<Double>)

Convertit une Vector256<T> en une Vector256<T>.

ConvertToInt64Native(Vector256<Double>)

Convertit un Vector256<Double> comportement spécifique à une Vector256<Int64> plateforme en cas de dépassement de capacité.

ConvertToSingle(Vector256<Int32>)

Convertit une Vector256<T> en une Vector256<T>.

ConvertToSingle(Vector256<UInt32>)

Convertit une Vector256<T> en une Vector256<T>.

ConvertToUInt32(Vector256<Single>)

Convertit une Vector256<T> en une Vector256<T>.

ConvertToUInt32Native(Vector256<Single>)

Convertit un Vector256<Single> comportement spécifique à une Vector256<UInt32> plateforme en cas de dépassement de capacité.

ConvertToUInt64(Vector256<Double>)

Convertit une Vector256<T> en une Vector256<T>.

ConvertToUInt64Native(Vector256<Double>)

Convertit un Vector256<Double> comportement spécifique à une Vector256<UInt64> plateforme en cas de dépassement de capacité.

CopySign<T>(Vector256<T>, Vector256<T>)

Copie le signe par élément d’un vecteur au signe par élément d’un autre vecteur.

CopyTo<T>(Vector256<T>, Span<T>)

Copie une Vector256<T> étendue donnée.

CopyTo<T>(Vector256<T>, T[], Int32)

Copie un Vector256<T> tableau donné à partir de l’index spécifié.

CopyTo<T>(Vector256<T>, T[])

Copie un Vector256<T> tableau donné.

Cos(Vector256<Double>)

Calcule le cosinus de chaque élément dans un vecteur.

Cos(Vector256<Single>)

Calcule le cosinus de chaque élément dans un vecteur.

Count<T>(Vector256<T>, T)

Détermine le nombre d’éléments d’un vecteur égal à une valeur donnée.

CountWhereAllBitsSet<T>(Vector256<T>)

Détermine le nombre d’éléments d’un vecteur qui ont tous leurs bits définis.

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)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(Byte)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(Double, Double, Double, Double)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(Double)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(Int16)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(Int32)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(Int64, Int64, Int64, Int64)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(Int64)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(IntPtr)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

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)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(SByte)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(Single, Single, Single, Single, Single, Single, Single, Single)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(Single)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(UInt16)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(UInt32)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(UInt64, UInt64, UInt64, UInt64)

Crée une Vector256<T> instance avec chaque élément initialisé à la valeur spécifiée correspondante.

Create(UInt64)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(UIntPtr)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create(Vector128<Byte>, Vector128<Byte>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<Double>, Vector128<Double>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<Int16>, Vector128<Int16>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<Int32>, Vector128<Int32>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<Int64>, Vector128<Int64>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<IntPtr>, Vector128<IntPtr>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<SByte>, Vector128<SByte>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<Single>, Vector128<Single>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<UInt16>, Vector128<UInt16>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<UInt32>, Vector128<UInt32>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<UInt64>, Vector128<UInt64>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create(Vector128<UIntPtr>, Vector128<UIntPtr>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create<T>(ReadOnlySpan<T>)

Crée une nouvelle Vector256<T> étendue en lecture seule.

Create<T>(T)

Crée une Vector256<T> instance avec tous les éléments initialisés à la valeur spécifiée.

Create<T>(T[], Int32)

Crée un nouveau Vector256<T> à partir d’un tableau donné.

Create<T>(T[])

Crée un nouveau Vector256<T> à partir d’un tableau donné.

Create<T>(Vector128<T>, Vector128<T>)

Crée une Vector256<T> instance à partir de deux Vector128<T> instances.

Create<T>(Vector128<T>)

Crée une Vector256<T> instance avec les 128 bits inférieurs et supérieurs initialisés à une valeur spécifiée.

Create<T>(Vector64<T>)

Crée une Vector256<T> instance avec toutes les parties 64 bits initialisées à une valeur spécifiée.

CreateScalar(Byte)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(Double)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(Int16)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(Int32)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(Int64)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(IntPtr)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(SByte)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(Single)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(UInt16)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(UInt32)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(UInt64)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar(UIntPtr)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalar<T>(T)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants initialisés à zéro.

CreateScalarUnsafe(Byte)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(Double)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(Int16)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(Int32)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(Int64)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(IntPtr)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(SByte)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(Single)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(UInt16)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(UInt32)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(UInt64)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe(UIntPtr)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateScalarUnsafe<T>(T)

Crée une Vector256<T> instance avec le premier élément initialisé à la valeur spécifiée et les éléments restants laissés non initialisés.

CreateSequence<T>(T, T)

Crée une Vector256<T> instance où les éléments commencent à une valeur spécifiée et qui sont espacés en fonction d’une autre valeur spécifiée.

DegreesToRadians(Vector256<Double>)

Convertit un vecteur donné de degrés en radians.

DegreesToRadians(Vector256<Single>)

Convertit un vecteur donné de degrés en radians.

Divide<T>(Vector256<T>, T)

Divise un vecteur par un scalaire pour calculer le quotient par élément.

Divide<T>(Vector256<T>, Vector256<T>)

Divise deux vecteurs pour calculer leur quotient.

Dot<T>(Vector256<T>, Vector256<T>)

Calcule le produit par points de deux vecteurs.

Equals<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer s’ils sont égaux par élément.

EqualsAll<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si tous les éléments sont égaux.

EqualsAny<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si des éléments sont égaux.

Exp(Vector256<Double>)

Calcule l’exponentielle de chaque élément dans un vecteur.

Exp(Vector256<Single>)

Calcule l’exponentielle de chaque élément dans un vecteur.

ExtractMostSignificantBits<T>(Vector256<T>)

Extrait le bit le plus significatif de chaque élément d’un vecteur.

Floor(Vector256<Double>)

Calcule le plancher de chaque élément dans un vecteur.

Floor(Vector256<Single>)

Calcule le plancher de chaque élément dans un vecteur.

FusedMultiplyAdd(Vector256<Double>, Vector256<Double>, Vector256<Double>)

Calcule (left * right) + addend, arrondi en une seule opération ternaire.

FusedMultiplyAdd(Vector256<Single>, Vector256<Single>, Vector256<Single>)

Calcule (left * right) + addend, arrondi en une seule opération ternaire.

get_E<T>()

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

get_Epsilon<T>()

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

get_NaN<T>()

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

get_NegativeInfinity<T>()

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

get_NegativeOne<T>()

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

get_NegativeZero<T>()

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

get_Pi<T>()

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

get_PositiveInfinity<T>()

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

get_Tau<T>()

Fournit une collection de méthodes statiques pour la création, la manipulation et le fonctionnement sur des vecteurs 256 bits.

GetElement<T>(Vector256<T>, Int32)

Obtient l’élément à l’index spécifié.

GetLower<T>(Vector256<T>)

Obtient la valeur des 128 bits inférieurs sous la forme d’un nouveau Vector128<T>.

GetUpper<T>(Vector256<T>)

Obtient la valeur des 128 bits supérieurs sous la forme d’un nouveau Vector128<T>.

GreaterThan<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer ce qui est plus grand par élément.

GreaterThanAll<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si tous les éléments sont supérieurs.

GreaterThanAny<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si des éléments sont supérieurs.

GreaterThanOrEqual<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer qui est supérieur ou égal à chaque élément.

GreaterThanOrEqualAll<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si tous les éléments sont supérieurs ou égaux.

GreaterThanOrEqualAny<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si des éléments sont supérieurs ou égaux.

Hypot(Vector256<Double>, Vector256<Double>)

Calcule l’hypotenuse donnée à deux vecteurs représentant les longueurs des côtés plus courts dans un triangle à angle droit.

Hypot(Vector256<Single>, Vector256<Single>)

Calcule l’hypotenuse donnée à deux vecteurs représentant les longueurs des côtés plus courts dans un triangle à angle droit.

IndexOf<T>(Vector256<T>, T)

Détermine l’index du premier élément d’un vecteur égal à une valeur donnée.

IndexOfWhereAllBitsSet<T>(Vector256<T>)

Détermine l’index du premier élément d’un vecteur qui a tous les bits définis.

IsEvenInteger<T>(Vector256<T>)

Détermine les éléments d’un vecteur qui sont même des valeurs intégrales.

IsFinite<T>(Vector256<T>)

Détermine les éléments d’un vecteur finis.

IsInfinity<T>(Vector256<T>)

Détermine les éléments d’un vecteur qui sont infinis.

IsInteger<T>(Vector256<T>)

Détermine les éléments d’un vecteur qui sont des valeurs intégrales.

IsNaN<T>(Vector256<T>)

Détermine quels éléments d’un vecteur sont NaN.

IsNegative<T>(Vector256<T>)

Détermine les éléments d’un vecteur qui représentent des nombres réels négatifs.

IsNegativeInfinity<T>(Vector256<T>)

Détermine les éléments d’un vecteur qui sont l’infini négatif.

IsNormal<T>(Vector256<T>)

Détermine les éléments d’un vecteur normaux.

IsOddInteger<T>(Vector256<T>)

Détermine les éléments d’un vecteur qui sont des valeurs intégrales impaires.

IsPositive<T>(Vector256<T>)

Détermine les éléments d’un vecteur qui représentent des nombres réels positifs.

IsPositiveInfinity<T>(Vector256<T>)

Détermine les éléments d’un vecteur qui sont l’infini positif.

IsSubnormal<T>(Vector256<T>)

Détermine les éléments d’un vecteur qui sont subnormals.

IsZero<T>(Vector256<T>)

Détermine quels éléments d’un vecteur sont zéro.

LastIndexOf<T>(Vector256<T>, T)

Détermine l’index du dernier élément d’un vecteur égal à une valeur donnée.

LastIndexOfWhereAllBitsSet<T>(Vector256<T>)

Détermine l’index du dernier élément d’un vecteur qui a tous les bits définis.

Lerp(Vector256<Double>, Vector256<Double>, Vector256<Double>)

Effectue une interpolation linéaire entre deux vecteurs en fonction de la pondération donnée.

Lerp(Vector256<Single>, Vector256<Single>, Vector256<Single>)

Effectue une interpolation linéaire entre deux vecteurs en fonction de la pondération donnée.

LessThan<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer ce qui est inférieur à chaque élément.

LessThanAll<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si tous les éléments sont inférieurs.

LessThanAny<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si des éléments sont inférieurs.

LessThanOrEqual<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer qui est inférieur ou égal à chaque élément.

LessThanOrEqualAll<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si tous les éléments sont inférieurs ou égaux.

LessThanOrEqualAny<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs pour déterminer si des éléments sont inférieurs ou égaux.

Load<T>(T*)

Charge un vecteur à partir de la source donnée.

LoadAligned<T>(T*)

Charge un vecteur à partir de la source alignée donnée.

LoadAlignedNonTemporal<T>(T*)

Charge un vecteur à partir de la source alignée donnée.

LoadUnsafe<T>(T, UIntPtr)

Charge un vecteur à partir de la source et du décalage d’élément donnés.

LoadUnsafe<T>(T)

Charge un vecteur à partir de la source donnée.

Log(Vector256<Double>)

Calcule le journal de chaque élément dans un vecteur.

Log(Vector256<Single>)

Calcule le journal de chaque élément dans un vecteur.

Log2(Vector256<Double>)

Calcule le journal2 de chaque élément dans un vecteur.

Log2(Vector256<Single>)

Calcule le journal2 de chaque élément dans un vecteur.

Max<T>(Vector256<T>, Vector256<T>)

Calcule le maximum de deux vecteurs par élément.

MaxMagnitude<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs au calcul qui a la plus grande magnitude par élément.

MaxMagnitudeNumber<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs, sur une base par élément, au calcul qui a la plus grande magnitude et retourne l’autre valeur si une entrée est NaN.

MaxNative<T>(Vector256<T>, Vector256<T>)

Comparez deux vecteurs pour déterminer qui est plus grand par élément à l’aide d’un comportement spécifique à la plateforme pour NaN et NegativeZero.

MaxNumber<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs, sur une base par élément, pour calculer ce qui est supérieur et renvoyer l’autre valeur si un élément est NaN.

Min<T>(Vector256<T>, Vector256<T>)

Calcule le minimum de deux vecteurs par élément.

MinMagnitude<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs au calcul qui a la moindre magnitude par élément.

MinMagnitudeNumber<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs, sur une base par élément, à calculer qui a la moindre magnitude et retourne l’autre valeur si une entrée est NaN.

MinNative<T>(Vector256<T>, Vector256<T>)

Comparez deux vecteurs pour déterminer qui est moindre par élément à l’aide d’un comportement spécifique à la plateforme pour NaN et NegativeZero.

MinNumber<T>(Vector256<T>, Vector256<T>)

Compare deux vecteurs, sur une base par élément, pour calculer ce qui est inférieur et renvoyer l’autre valeur si un élément est NaN.

Multiply<T>(T, Vector256<T>)

Multiplie un vecteur par un scalaire pour calculer son produit.

Multiply<T>(Vector256<T>, T)

Multiplie un vecteur par un scalaire pour calculer son produit.

Multiply<T>(Vector256<T>, Vector256<T>)

Multiplie deux vecteurs pour calculer leur produit à l’échelle de l’élément.

MultiplyAddEstimate(Vector256<Double>, Vector256<Double>, Vector256<Double>)

Calcule une estimation de (left * right) + addend.

MultiplyAddEstimate(Vector256<Single>, Vector256<Single>, Vector256<Single>)

Calcule une estimation de (left * right) + addend.

Narrow(Vector256<Double>, Vector256<Double>)

Réduit deux Vector256<T> instances en une Vector256<T>seule.

Narrow(Vector256<Int16>, Vector256<Int16>)

Réduit deux Vector256<T> instances en une Vector256<T>seule.

Narrow(Vector256<Int32>, Vector256<Int32>)

Réduit deux Vector256<T> instances en une Vector256<T>seule.

Narrow(Vector256<Int64>, Vector256<Int64>)

Réduit deux Vector256<T> instances en une Vector256<T>seule.

Narrow(Vector256<UInt16>, Vector256<UInt16>)

Réduit deux Vector256<T> instances en une Vector256<T>seule.

Narrow(Vector256<UInt32>, Vector256<UInt32>)

Réduit deux Vector256<T> instances en une Vector256<T>seule.

Narrow(Vector256<UInt64>, Vector256<UInt64>)

Réduit deux Vector256<T> instances en une Vector256<T>seule.

NarrowWithSaturation(Vector256<Double>, Vector256<Double>)

Réduit deux vecteurs d’instances Double en un vecteur d’utilisation d’une Single conversion saturante.

NarrowWithSaturation(Vector256<Int16>, Vector256<Int16>)

Réduit deux vecteurs d’instances Int16 en un vecteur d’utilisation d’une SByte conversion saturante.

NarrowWithSaturation(Vector256<Int32>, Vector256<Int32>)

Réduit deux vecteurs d’instances Int32 en un vecteur d’utilisation d’une Int16 conversion saturante.

NarrowWithSaturation(Vector256<Int64>, Vector256<Int64>)

Réduit deux vecteurs d’instances Int64 en un vecteur d’utilisation d’une Int32 conversion saturante.

NarrowWithSaturation(Vector256<UInt16>, Vector256<UInt16>)

Réduit deux vecteurs d’instances UInt16 en un vecteur d’utilisation d’une Byte conversion saturante.

NarrowWithSaturation(Vector256<UInt32>, Vector256<UInt32>)

Réduit deux vecteurs d’instances UInt32 en un vecteur d’utilisation d’une UInt16 conversion saturante.

NarrowWithSaturation(Vector256<UInt64>, Vector256<UInt64>)

Réduit deux vecteurs d’instances UInt64 en un vecteur d’utilisation d’une UInt32 conversion saturante.

Negate<T>(Vector256<T>)

Annule un vecteur.

None<T>(Vector256<T>, T)

Détermine si aucun élément d’un vecteur n’est égal à une valeur donnée.

NoneWhereAllBitsSet<T>(Vector256<T>)

Détermine si aucun élément d’un vecteur n’a tous ses bits définis.

OnesComplement<T>(Vector256<T>)

Calcule le complément un vecteur.

RadiansToDegrees(Vector256<Double>)

Convertit un vecteur donné de radians en degrés.

RadiansToDegrees(Vector256<Single>)

Convertit un vecteur donné de radians en degrés.

Round(Vector256<Double>, MidpointRounding)

Arrondit chaque élément d’un vecteur à l’entier le plus proche à l’aide du mode d’arrondi spécifié.

Round(Vector256<Double>)

Arrondit chaque élément d’un vecteur à l’entier le plus proche à l’aide du mode d’arrondi par défaut (ToEven).

Round(Vector256<Single>, MidpointRounding)

Arrondit chaque élément d’un vecteur à l’entier le plus proche à l’aide du mode d’arrondi spécifié.

Round(Vector256<Single>)

Arrondit chaque élément d’un vecteur à l’entier le plus proche à l’aide du mode d’arrondi par défaut (ToEven).

ShiftLeft(Vector256<Byte>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftLeft(Vector256<Int16>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftLeft(Vector256<Int32>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftLeft(Vector256<Int64>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftLeft(Vector256<IntPtr>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftLeft(Vector256<SByte>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftLeft(Vector256<UInt16>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftLeft(Vector256<UInt32>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftLeft(Vector256<UInt64>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftLeft(Vector256<UIntPtr>, Int32)

Déplace chaque élément d’un vecteur à gauche par la quantité spécifiée.

ShiftRightArithmetic(Vector256<Int16>, Int32)

Shifts (signé) chaque élément d’un vecteur à droite par la quantité spécifiée.

ShiftRightArithmetic(Vector256<Int32>, Int32)

Shifts (signé) chaque élément d’un vecteur à droite par la quantité spécifiée.

ShiftRightArithmetic(Vector256<Int64>, Int32)

Shifts (signé) chaque élément d’un vecteur à droite par la quantité spécifiée.

ShiftRightArithmetic(Vector256<IntPtr>, Int32)

Shifts (signé) chaque élément d’un vecteur à droite par la quantité spécifiée.

ShiftRightArithmetic(Vector256<SByte>, Int32)

Shifts (signé) chaque élément d’un vecteur à droite par la quantité spécifiée.

ShiftRightLogical(Vector256<Byte>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

ShiftRightLogical(Vector256<Int16>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

ShiftRightLogical(Vector256<Int32>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

ShiftRightLogical(Vector256<Int64>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

ShiftRightLogical(Vector256<IntPtr>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

ShiftRightLogical(Vector256<SByte>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

ShiftRightLogical(Vector256<UInt16>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

ShiftRightLogical(Vector256<UInt32>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

ShiftRightLogical(Vector256<UInt64>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

ShiftRightLogical(Vector256<UIntPtr>, Int32)

Shifts (unsigned) chaque élément d’un vecteur droit par la quantité spécifiée.

Shuffle(Vector256<Byte>, Vector256<Byte>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Shuffle(Vector256<Double>, Vector256<Int64>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Shuffle(Vector256<Int16>, Vector256<Int16>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Shuffle(Vector256<Int32>, Vector256<Int32>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Shuffle(Vector256<Int64>, Vector256<Int64>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Shuffle(Vector256<SByte>, Vector256<SByte>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Shuffle(Vector256<Single>, Vector256<Int32>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Shuffle(Vector256<UInt16>, Vector256<UInt16>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Shuffle(Vector256<UInt32>, Vector256<UInt32>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Shuffle(Vector256<UInt64>, Vector256<UInt64>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

ShuffleNative(Vector256<Byte>, Vector256<Byte>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Le comportement dépend de la plateforme pour les index hors plage.

ShuffleNative(Vector256<Double>, Vector256<Int64>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

ShuffleNative(Vector256<Int16>, Vector256<Int16>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

ShuffleNative(Vector256<Int32>, Vector256<Int32>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

ShuffleNative(Vector256<Int64>, Vector256<Int64>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

ShuffleNative(Vector256<SByte>, Vector256<SByte>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Le comportement dépend de la plateforme pour les index hors plage.

ShuffleNative(Vector256<Single>, Vector256<Int32>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

ShuffleNative(Vector256<UInt16>, Vector256<UInt16>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

ShuffleNative(Vector256<UInt32>, Vector256<UInt32>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

ShuffleNative(Vector256<UInt64>, Vector256<UInt64>)

Crée un vecteur en sélectionnant des valeurs à partir d’un vecteur d’entrée à l’aide d’un ensemble d’index.

Sin(Vector256<Double>)

Calcule le sinus de chaque élément dans un vecteur.

Sin(Vector256<Single>)

Calcule le sinus de chaque élément dans un vecteur.

SinCos(Vector256<Double>)

Calcule le sinus et le cosinus de chaque élément dans un vecteur.

SinCos(Vector256<Single>)

Calcule le sinus et le cosinus de chaque élément dans un vecteur.

Sqrt<T>(Vector256<T>)

Calcule la racine carrée d’un vecteur par élément.

Store<T>(Vector256<T>, T*)

Stocke un vecteur à la destination donnée.

StoreAligned<T>(Vector256<T>, T*)

Stocke un vecteur à la destination alignée donnée.

StoreAlignedNonTemporal<T>(Vector256<T>, T*)

Stocke un vecteur à la destination alignée donnée.

StoreUnsafe<T>(Vector256<T>, T, UIntPtr)

Stocke un vecteur à la destination donnée.

StoreUnsafe<T>(Vector256<T>, T)

Stocke un vecteur à la destination donnée.

Subtract<T>(Vector256<T>, Vector256<T>)

Soustrait deux vecteurs pour calculer leur différence.

SubtractSaturate<T>(Vector256<T>, Vector256<T>)

Soustrait deux vecteurs pour calculer leur différence saturée d’éléments.

Sum<T>(Vector256<T>)

Calcule la somme de tous les éléments d’un vecteur.

ToScalar<T>(Vector256<T>)

Convertit le vecteur donné en scalaire contenant la valeur du premier élément.

ToVector512<T>(Vector256<T>)

Convertit le vecteur donné en nouveau Vector512<T> avec les 256 bits inférieurs définis en valeur du vecteur donné et les 256 bits supérieurs initialisés à zéro.

ToVector512Unsafe<T>(Vector256<T>)

Convertit le vecteur donné en nouveau Vector512<T> avec les 256 bits inférieurs définis en valeur du vecteur donné et les 256 bits supérieurs non initialisés.

Truncate(Vector256<Double>)

Tronque chaque élément dans un vecteur.

Truncate(Vector256<Single>)

Tronque chaque élément dans un vecteur.

TryCopyTo<T>(Vector256<T>, Span<T>)

Tente de copier une Vector<T> étendue donnée.

Widen(Vector256<Byte>)

S’élargit en Vector256<T> deux Vector256<T>.

Widen(Vector256<Int16>)

S’élargit en Vector256<T> deux Vector256<T>.

Widen(Vector256<Int32>)

S’élargit en Vector256<T> deux Vector256<T>.

Widen(Vector256<SByte>)

S’élargit en Vector256<T> deux Vector256<T>.

Widen(Vector256<Single>)

S’élargit en Vector256<T> deux Vector256<T>.

Widen(Vector256<UInt16>)

S’élargit en Vector256<T> deux Vector256<T>.

Widen(Vector256<UInt32>)

S’élargit en Vector256<T> deux Vector256<T>.

WidenLower(Vector256<Byte>)

Élargit la moitié inférieure d’un Vector256<T> dans un Vector256<T>.

WidenLower(Vector256<Int16>)

Élargit la moitié inférieure d’un Vector256<T> dans un Vector256<T>.

WidenLower(Vector256<Int32>)

Élargit la moitié inférieure d’un Vector256<T> dans un Vector256<T>.

WidenLower(Vector256<SByte>)

Élargit la moitié inférieure d’un Vector256<T> dans un Vector256<T>.

WidenLower(Vector256<Single>)

Élargit la moitié inférieure d’un Vector256<T> dans un Vector256<T>.

WidenLower(Vector256<UInt16>)

Élargit la moitié inférieure d’un Vector256<T> dans un Vector256<T>.

WidenLower(Vector256<UInt32>)

Élargit la moitié inférieure d’un Vector256<T> dans un Vector256<T>.

WidenUpper(Vector256<Byte>)

Élargit la moitié supérieure d’un Vector256<T> dans un Vector256<T>.

WidenUpper(Vector256<Int16>)

Élargit la moitié supérieure d’un Vector256<T> dans un Vector256<T>.

WidenUpper(Vector256<Int32>)

Élargit la moitié supérieure d’un Vector256<T> dans un Vector256<T>.

WidenUpper(Vector256<SByte>)

Élargit la moitié supérieure d’un Vector256<T> dans un Vector256<T>.

WidenUpper(Vector256<Single>)

Élargit la moitié supérieure d’un Vector256<T> dans un Vector256<T>.

WidenUpper(Vector256<UInt16>)

Élargit la moitié supérieure d’un Vector256<T> dans un Vector256<T>.

WidenUpper(Vector256<UInt32>)

Élargit la moitié supérieure d’un Vector256<T> dans un Vector256<T>.

WithElement<T>(Vector256<T>, Int32, T)

Crée un Vector256<T> élément avec l’élément au niveau de l’index spécifié défini sur la valeur spécifiée et les éléments restants définis sur la même valeur que dans le vecteur donné.

WithLower<T>(Vector256<T>, Vector128<T>)

Crée un nouveau Vector256<T> avec les 128 bits inférieurs définis sur la valeur spécifiée et les 128 bits supérieurs définis sur la même valeur que dans le vecteur donné.

WithUpper<T>(Vector256<T>, Vector128<T>)

Crée un nouveau Vector256<T> avec les 128 bits supérieurs définis sur la valeur spécifiée et les 128 bits inférieurs définis sur la même valeur que dans le vecteur donné.

Xor<T>(Vector256<T>, Vector256<T>)

Calcule les vecteurs exclusifs ou de deux vecteurs.

S’applique à