Vector256 Classe

Definição

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

public ref class Vector256 abstract sealed
public static class Vector256
type Vector256 = class
Public Module Vector256
Herança
Vector256

Propriedades

Name Description
E

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

Epsilon

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

IsHardwareAccelerated

Obtém um valor que indica se as operações vetoriais de 256 bits estão sujeitas a aceleração por hardware através do suporte intrínseco do JIT.

NaN

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

NegativeInfinity

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

NegativeOne

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

NegativeZero

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

Pi

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

PositiveInfinity

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

Tau

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

Métodos

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

Calcula o valor absoluto de cada elemento num vetor.

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

Soma dois vetores para calcular a sua soma.

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

Soma dois vetores para calcular a sua soma saturada elemento a elemento.

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

Determina se todos os elementos de um vetor são iguais a um dado valor.

AllWhereAllBitsSet<T>(Vector256<T>)

Determina se todos os elementos de um vetor têm todos os seus bits definidos.

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

Calcula o e bit a bit de um dado vetor e o complemento de uns de outro vetor.

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

Determina se quaisquer elementos de um vetor são iguais a um dado valor.

AnyWhereAllBitsSet<T>(Vector256<T>)

Determina se algum elemento de um vetor tem todos os seus bits definidos.

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

Reinterpreta um Vector256<T> de tipo TFrom como um novo Vector256<T> de tipo TTo.

AsByte<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo Byte.

AsDouble<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo Double.

Asin(Vector256<Double>)

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

Asin(Vector256<Single>)

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

AsInt16<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo Int16.

AsInt32<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo Int32.

AsInt64<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo Int64.

AsNInt<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256<T>.

AsNUInt<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256<T>.

AsSByte<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo SByte.

AsSingle<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo Single.

AsUInt16<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo UInt16.

AsUInt32<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo UInt32.

AsUInt64<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector256 do tipo UInt64.

AsVector<T>(Vector256<T>)

Reinterpreta a Vector256<T> como um novo Vector<T>.

AsVector256<T>(Vector<T>)

Reinterpreta a Vector<T> como um novo Vector256<T>.

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

Calcula o bit a bit-e de dois vetores.

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

Calcula o bit-or-ou de dois vetores.

Ceiling(Vector256<Double>)

Calcula o teto máximo de cada elemento num vetor.

Ceiling(Vector256<Single>)

Calcula o teto máximo de cada elemento num vetor.

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

Restringe um vetor entre um valor mínimo e um valor máximo.

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

Restringe um vetor entre um valor mínimo e um valor máximo usando comportamentos específicos da plataforma para NaN e NegativeZero.

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

Seleciona condicionalmente um valor entre dois vetores numa base bit a bit.

ConvertToDouble(Vector256<Int64>)

Converte a Vector256<T> em um Vector256<T>arquivo .

ConvertToDouble(Vector256<UInt64>)

Converte a Vector256<T> em um Vector256<T>arquivo .

ConvertToInt32(Vector256<Single>)

Converte a Vector256<T> em um Vector256<T>arquivo .

ConvertToInt32Native(Vector256<Single>)

Converte um Vector256<Single> para um Vector256<Int32> comportamento específico da plataforma em overflow.

ConvertToInt64(Vector256<Double>)

Converte a Vector256<T> em um Vector256<T>arquivo .

ConvertToInt64Native(Vector256<Double>)

Converte um Vector256<Double> para um Vector256<Int64> comportamento específico da plataforma em overflow.

ConvertToSingle(Vector256<Int32>)

Converte a Vector256<T> em um Vector256<T>arquivo .

ConvertToSingle(Vector256<UInt32>)

Converte a Vector256<T> em um Vector256<T>arquivo .

ConvertToUInt32(Vector256<Single>)

Converte a Vector256<T> em um Vector256<T>arquivo .

ConvertToUInt32Native(Vector256<Single>)

Converte um Vector256<Single> para um Vector256<UInt32> comportamento específico da plataforma em overflow.

ConvertToUInt64(Vector256<Double>)

Converte a Vector256<T> em um Vector256<T>arquivo .

ConvertToUInt64Native(Vector256<Double>)

Converte um Vector256<Double> para um Vector256<UInt64> comportamento específico da plataforma em overflow.

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

Copia o sinal por elemento de um vetor para o signo por elemento de outro vetor.

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

Cópias a Vector256<T> para um determinado intervalo.

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

Copia a Vector256<T> para um dado array começando no índice especificado.

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

Cópias a Vector256<T> para um determinado array.

Cos(Vector256<Double>)

Calcula o cosseno de cada elemento num vetor.

Cos(Vector256<Single>)

Calcula o cosseno de cada elemento num vetor.

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

Determina o número de elementos num vetor que são iguais a um dado valor.

CountWhereAllBitsSet<T>(Vector256<T>)

Determina o número de elementos num vetor que têm todos os seus bits definidos.

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)

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(Byte)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

Create(Double, Double, Double, Double)

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(Double)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

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

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(Int16)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

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

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(Int32)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

Create(Int64, Int64, Int64, Int64)

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(Int64)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

Create(IntPtr)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

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)

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(SByte)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

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

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(Single)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

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

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(UInt16)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

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

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(UInt32)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

Create(UInt64, UInt64, UInt64, UInt64)

Cria uma nova Vector256<T> instância com cada elemento inicializado ao valor especificado correspondente.

Create(UInt64)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

Create(UIntPtr)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

Create<T>(ReadOnlySpan<T>)

Cria um novo Vector256<T> a partir de um determinado intervalo apenas de leitura.

Create<T>(T)

Cria uma nova Vector256<T> instância com todos os elementos inicializados ao valor especificado.

Create<T>(T[], Int32)

Cria um novo Vector256<T> a partir de um determinado array.

Create<T>(T[])

Cria um novo Vector256<T> a partir de um determinado array.

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

Cria uma nova Vector256<T> instância a partir de duas Vector128<T> instâncias.

Create<T>(Vector128<T>)

Cria uma nova Vector256<T> instância com os 128 bits inferior e superior inicializados para um valor especificado.

Create<T>(Vector64<T>)

Cria uma nova Vector256<T> instância com todas as partes de 64 bits inicializadas a um valor especificado.

CreateScalar(Byte)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(Double)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(Int16)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(Int32)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(Int64)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(IntPtr)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(SByte)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(Single)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(UInt16)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(UInt32)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(UInt64)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar(UIntPtr)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalar<T>(T)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos inicializados a zero.

CreateScalarUnsafe(Byte)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(Double)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(Int16)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(Int32)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(Int64)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(IntPtr)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(SByte)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(Single)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(UInt16)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(UInt32)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(UInt64)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe(UIntPtr)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateScalarUnsafe<T>(T)

Cria uma nova Vector256<T> instância com o primeiro elemento inicializado ao valor especificado e os restantes elementos não inicializados.

CreateSequence<T>(T, T)

Cria uma nova Vector256<T> instância onde os elementos começam num valor especificado e que estão espaçados de acordo com outro valor especificado.

DegreesToRadians(Vector256<Double>)

Converte um dado vetor de graus para radianos.

DegreesToRadians(Vector256<Single>)

Converte um dado vetor de graus para radianos.

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

Divide um vetor por um escalar para calcular o quociente por elemento.

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

Divide dois vetores para calcular o seu quociente.

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

Calcula o produto escalar de dois vetores.

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

Compara dois vetores para determinar se são iguais por elemento.

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

Compara dois vetores para determinar se todos os elementos são iguais.

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

Compara dois vetores para determinar se algum elemento é igual.

Exp(Vector256<Double>)

Calcula a exponencial de cada elemento num vetor.

Exp(Vector256<Single>)

Calcula a exponencial de cada elemento num vetor.

ExtractMostSignificantBits<T>(Vector256<T>)

Extrai o bit mais significativo de cada elemento num vetor.

Floor(Vector256<Double>)

Calcula o piso de cada elemento num vetor.

Floor(Vector256<Single>)

Calcula o piso de cada elemento num vetor.

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

Calcula (left * right) + addend, arredondado como uma operação ternária.

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

Calcula (left * right) + addend, arredondado como uma operação ternária.

get_E<T>()

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

get_Epsilon<T>()

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

get_NaN<T>()

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

get_NegativeInfinity<T>()

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

get_NegativeOne<T>()

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

get_NegativeZero<T>()

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

get_Pi<T>()

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

get_PositiveInfinity<T>()

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

get_Tau<T>()

Fornece um conjunto de métodos estáticos para criar, manipular e operar de outras formas em vetores de 256 bits.

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

Obtém o elemento no índice especificado.

GetLower<T>(Vector256<T>)

Obtém o valor dos 128 bits inferiores como um novo Vector128<T>.

GetUpper<T>(Vector256<T>)

Obtém o valor dos 128 bits superiores como um novo Vector128<T>.

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

Compara dois vetores para determinar qual é maior por elemento.

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

Compara dois vetores para determinar se todos os elementos são maiores.

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

Compara dois vetores para determinar se algum elemento é maior.

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

Compara dois vetores para determinar qual é maior ou igual por elemento.

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

Compara dois vetores para determinar se todos os elementos são maiores ou iguais.

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

Compara dois vetores para determinar se algum elemento é maior ou igual.

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

Calcula a hipotenusa dados dois vetores que representam os comprimentos dos lados mais curtos num triângulo reto.

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

Calcula a hipotenusa dados dois vetores que representam os comprimentos dos lados mais curtos num triângulo reto.

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

Determina o índice do primeiro elemento de um vetor que é igual a um dado valor.

IndexOfWhereAllBitsSet<T>(Vector256<T>)

Determina o índice do primeiro elemento num vetor que tem todos os bits definidos.

IsEvenInteger<T>(Vector256<T>)

Determina quais os elementos num vetor que são valores inteiros pares.

IsFinite<T>(Vector256<T>)

Determina quais os elementos num vetor que são finitos.

IsInfinity<T>(Vector256<T>)

Determina quais os elementos num vetor que são infinitos.

IsInteger<T>(Vector256<T>)

Determina quais os elementos num vetor que são valores integrais.

IsNaN<T>(Vector256<T>)

Determina quais os elementos de um vetor que são NaN.

IsNegative<T>(Vector256<T>)

Determina quais os elementos num vetor que representam números reais negativos.

IsNegativeInfinity<T>(Vector256<T>)

Determina quais os elementos num vetor que são menos infinito.

IsNormal<T>(Vector256<T>)

Determina quais os elementos num vetor que são normais.

IsOddInteger<T>(Vector256<T>)

Determina quais os elementos num vetor que são valores inteiros ímpares.

IsPositive<T>(Vector256<T>)

Determina quais os elementos num vetor que representam números reais positivos.

IsPositiveInfinity<T>(Vector256<T>)

Determina quais os elementos num vetor que são infinito positivo.

IsSubnormal<T>(Vector256<T>)

Determina quais os elementos de um vetor que são subnormais.

IsZero<T>(Vector256<T>)

Determina quais os elementos num vetor que são zero.

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

Determina o índice do último elemento num vetor que é igual a um dado valor.

LastIndexOfWhereAllBitsSet<T>(Vector256<T>)

Determina o índice do último elemento num vetor que tem todos os bits definidos.

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

Realiza uma interpolação linear entre dois vetores com base na ponderação dada.

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

Realiza uma interpolação linear entre dois vetores com base na ponderação dada.

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

Compara dois vetores para determinar qual é menor por elemento.

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

Compara dois vetores para determinar se todos os elementos são menores.

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

Compara dois vetores para determinar se algum elemento é menor.

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

Compara dois vetores para determinar qual é menor ou igual por elemento.

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

Compara dois vetores para determinar se todos os elementos são menores ou iguais.

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

Compara dois vetores para determinar se algum elemento é menor ou igual.

Load<T>(T*)

Carrega um vetor a partir da fonte dada.

LoadAligned<T>(T*)

Carrega um vetor a partir da fonte alinhada dada.

LoadAlignedNonTemporal<T>(T*)

Carrega um vetor a partir da fonte alinhada dada.

LoadUnsafe<T>(T, UIntPtr)

Carrega um vetor a partir do deslocamento de fonte e elemento dado.

LoadUnsafe<T>(T)

Carrega um vetor a partir da fonte dada.

Log(Vector256<Double>)

Calcula o logarítmic de cada elemento num vetor.

Log(Vector256<Single>)

Calcula o logarítmic de cada elemento num vetor.

Log2(Vector256<Double>)

Calcula o log2 de cada elemento num vetor.

Log2(Vector256<Single>)

Calcula o log2 de cada elemento num vetor.

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

Calcula o máximo de dois vetores por elemento.

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

Compara dois vetores para calcular qual tem maior magnitude por elemento.

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

Compara dois vetores, por elemento, para calcular qual tem maior magnitude e devolve o outro valor se uma entrada for NaN.

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

Compare dois vetores para determinar qual é maior por elemento usando comportamento específico da plataforma para NaN e NegativeZero.

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

Compara dois vetores, numa base por elemento, para calcular qual é maior e devolve o outro valor se um elemento for NaN.

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

Calcula o mínimo de dois vetores por elemento.

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

Compara dois vetores para calcular que têm a magnitude menor por elemento.

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

Compara dois vetores, numa base por elemento, para calcular qual tem a magnitude menor e devolve o outro valor se uma entrada for NaN.

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

Compare dois vetores para determinar qual é menor numa base por elemento usando comportamentos específicos da plataforma para NaN e NegativeZero.

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

Compara dois vetores, numa base por elemento, para calcular qual é menor e devolve o outro valor se um elemento for NaN.

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

Multiplica um vetor por um escalar para calcular o seu produto.

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

Multiplica um vetor por um escalar para calcular o seu produto.

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

Multiplica dois vetores para calcular o seu produto elemento a elemento.

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

Calcula uma estimativa de (left * right) + . addend

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

Calcula uma estimativa de (left * right) + . addend

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

Reduz duas Vector256<T> instâncias a uma Vector256<T>só.

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

Reduz duas Vector256<T> instâncias a uma Vector256<T>só.

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

Reduz duas Vector256<T> instâncias a uma Vector256<T>só.

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

Reduz duas Vector256<T> instâncias a uma Vector256<T>só.

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

Reduz duas Vector256<T> instâncias a uma Vector256<T>só.

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

Reduz duas Vector256<T> instâncias a uma Vector256<T>só.

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

Reduz duas Vector256<T> instâncias a uma Vector256<T>só.

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

Reduz dois vetores de Double instâncias a um único vetor de Single usando uma conversão saturante.

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

Reduz dois vetores de Int16 instâncias a um único vetor de SByte usando uma conversão saturante.

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

Reduz dois vetores de Int32 instâncias a um único vetor de Int16 usando uma conversão saturante.

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

Reduz dois vetores de Int64 instâncias a um único vetor de Int32 usando uma conversão saturante.

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

Reduz dois vetores de UInt16 instâncias a um único vetor de Byte usando uma conversão saturante.

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

Reduz dois vetores de UInt32 instâncias a um único vetor de UInt16 usando uma conversão saturante.

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

Reduz dois vetores de UInt64 instâncias a um único vetor de UInt32 usando uma conversão saturante.

Negate<T>(Vector256<T>)

Anula um vetor.

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

Determina se nenhum elemento de um vetor é igual a um dado valor.

NoneWhereAllBitsSet<T>(Vector256<T>)

Determina se nenhum elemento de um vetor tem todos os seus bits definidos.

OnesComplement<T>(Vector256<T>)

Calcula o complemento de um vetor.

RadiansToDegrees(Vector256<Double>)

Converte um dado vetor de radianos em graus.

RadiansToDegrees(Vector256<Single>)

Converte um dado vetor de radianos em graus.

Round(Vector256<Double>, MidpointRounding)

Arredonda cada elemento de um vetor para o inteiro mais próximo usando o modo de arredondamento especificado.

Round(Vector256<Double>)

Arredonda cada elemento de um vetor para o inteiro mais próximo usando o modo de arredondamento padrão (ToEven).

Round(Vector256<Single>, MidpointRounding)

Arredonda cada elemento de um vetor para o inteiro mais próximo usando o modo de arredondamento especificado.

Round(Vector256<Single>)

Arredonda cada elemento de um vetor para o inteiro mais próximo usando o modo de arredondamento padrão (ToEven).

ShiftLeft(Vector256<Byte>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftLeft(Vector256<Int16>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftLeft(Vector256<Int32>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftLeft(Vector256<Int64>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftLeft(Vector256<IntPtr>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftLeft(Vector256<SByte>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftLeft(Vector256<UInt16>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftLeft(Vector256<UInt32>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftLeft(Vector256<UInt64>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftLeft(Vector256<UIntPtr>, Int32)

Desloca cada elemento de um vetor deixado pela quantidade especificada.

ShiftRightArithmetic(Vector256<Int16>, Int32)

Desloca (assinado) cada elemento de um vetor pela quantidade especificada.

ShiftRightArithmetic(Vector256<Int32>, Int32)

Desloca (assinado) cada elemento de um vetor pela quantidade especificada.

ShiftRightArithmetic(Vector256<Int64>, Int32)

Desloca (assinado) cada elemento de um vetor pela quantidade especificada.

ShiftRightArithmetic(Vector256<IntPtr>, Int32)

Desloca (assinado) cada elemento de um vetor pela quantidade especificada.

ShiftRightArithmetic(Vector256<SByte>, Int32)

Desloca (assinado) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<Byte>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<Int16>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<Int32>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<Int64>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<IntPtr>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<SByte>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<UInt16>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<UInt32>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<UInt64>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

ShiftRightLogical(Vector256<UIntPtr>, Int32)

Desloca (sem sinal) cada elemento de um vetor pela quantidade especificada.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

O comportamento depende da plataforma para índices fora de alcance.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

O comportamento depende da plataforma para índices fora de alcance.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

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

Cria um novo vetor selecionando valores de um vetor de entrada usando um conjunto de índices.

Sin(Vector256<Double>)

Calcula o seno de cada elemento num vetor.

Sin(Vector256<Single>)

Calcula o seno de cada elemento num vetor.

SinCos(Vector256<Double>)

Calcula o seno e o cosseno de cada elemento num vetor.

SinCos(Vector256<Single>)

Calcula o seno e o cosseno de cada elemento num vetor.

Sqrt<T>(Vector256<T>)

Calcula a raiz quadrada de um vetor por elemento.

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

Armazena um vetor no destino indicado.

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

Armazena um vetor no destino alinhado indicado.

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

Armazena um vetor no destino alinhado indicado.

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

Armazena um vetor no destino indicado.

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

Armazena um vetor no destino indicado.

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

Subtrai dois vetores para calcular a sua diferença.

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

Subtrai dois vetores para calcular a sua diferença saturada elemento a elemento.

Sum<T>(Vector256<T>)

Calcula a soma de todos os elementos num vetor.

ToScalar<T>(Vector256<T>)

Converte o vetor dado num escalar contendo o valor do primeiro elemento.

ToVector512<T>(Vector256<T>)

Converte o vetor dado para um novo Vector512<T> , com os 256 bits inferiores definidos para o valor do vetor dado e os 256 bits superiores inicializados a zero.

ToVector512Unsafe<T>(Vector256<T>)

Converte o vetor dado para um novo Vector512<T> , com os 256 bits inferiores definidos para o valor do vetor dado e os 256 bits superiores não inicializados.

Truncate(Vector256<Double>)

Trunca cada elemento num vetor.

Truncate(Vector256<Single>)

Trunca cada elemento num vetor.

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

Tenta copiar a Vector<T> para um determinado intervalo.

Widen(Vector256<Byte>)

Alarga a Vector256<T> em dois Vector256<T>.

Widen(Vector256<Int16>)

Alarga a Vector256<T> em dois Vector256<T>.

Widen(Vector256<Int32>)

Alarga a Vector256<T> em dois Vector256<T>.

Widen(Vector256<SByte>)

Alarga a Vector256<T> em dois Vector256<T>.

Widen(Vector256<Single>)

Alarga a Vector256<T> em dois Vector256<T>.

Widen(Vector256<UInt16>)

Alarga a Vector256<T> em dois Vector256<T>.

Widen(Vector256<UInt32>)

Alarga a Vector256<T> em dois Vector256<T>.

WidenLower(Vector256<Byte>)

Alarga a metade inferior de um Vector256<T> para um Vector256<T>.

WidenLower(Vector256<Int16>)

Alarga a metade inferior de um Vector256<T> para um Vector256<T>.

WidenLower(Vector256<Int32>)

Alarga a metade inferior de um Vector256<T> para um Vector256<T>.

WidenLower(Vector256<SByte>)

Alarga a metade inferior de um Vector256<T> para um Vector256<T>.

WidenLower(Vector256<Single>)

Alarga a metade inferior de um Vector256<T> para um Vector256<T>.

WidenLower(Vector256<UInt16>)

Alarga a metade inferior de um Vector256<T> para um Vector256<T>.

WidenLower(Vector256<UInt32>)

Alarga a metade inferior de um Vector256<T> para um Vector256<T>.

WidenUpper(Vector256<Byte>)

Alarga a metade superior de um Vector256<T> para um Vector256<T>.

WidenUpper(Vector256<Int16>)

Alarga a metade superior de um Vector256<T> para um Vector256<T>.

WidenUpper(Vector256<Int32>)

Alarga a metade superior de um Vector256<T> para um Vector256<T>.

WidenUpper(Vector256<SByte>)

Alarga a metade superior de um Vector256<T> para um Vector256<T>.

WidenUpper(Vector256<Single>)

Alarga a metade superior de um Vector256<T> para um Vector256<T>.

WidenUpper(Vector256<UInt16>)

Alarga a metade superior de um Vector256<T> para um Vector256<T>.

WidenUpper(Vector256<UInt32>)

Alarga a metade superior de um Vector256<T> para um Vector256<T>.

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

Cria um novo Vector256<T> com o elemento no índice especificado definido para o valor especificado e os restantes elementos definidos para o mesmo valor que no vetor dado.

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

Cria um novo Vector256<T> com os 128 bits inferiores definidos para o valor especificado e os 128 bits superiores definidos para o mesmo valor do vetor dado.

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

Cria um novo Vector256<T> com os 128 bits superiores definidos para o valor especificado e os 128 bits inferiores definidos para o mesmo valor do vetor dado.

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

Calcula o ou exclusivo de dois vetores.

Aplica-se a