Compartir a través de

Vector Clase

  • Referencia

Definición

Espacio de nombres:
System.Numerics
Ensamblado:
System.Numerics.Vectors.dll
Ensamblados:
netstandard.dll, System.Numerics.Vectors.dll
Ensamblado:
netstandard.dll
Paquete:
System.Numerics.Vectors v4.5.0
Source:
Vector.cs
Source:
Vector.cs
Source:
Vector.cs

Proporciona una colección de métodos estáticos para crear, manipular y operar en vectores genéricos.

public ref class Vector abstract sealed
public static class Vector
type Vector = class
Public Class Vector
Public Module Vector
Herencia
Object
Vector

Propiedades

IsHardwareAccelerated

Obtiene un valor que indica si las operaciones vectoriales están sujetas a aceleración de hardware a través de compatibilidad intrínseca jiT.

Métodos

Abs<T>(Vector<T>)

Devuelve un nuevo vector cuyos elementos son los valores absolutos de los elementos del vector especificado.
Add<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector cuyos valores son la suma de cada par de elementos de dos vectores determinados.
AndNot<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector realizando una operación And Not bit a bit en cada par de elementos correspondientes en dos vectores.
As<TFrom,TTo>(Vector<TFrom>)

Reinterpreta un Vector<T> como un nuevo Vector<T>.
AsPlane(Vector4)

Reinterpreta un Vector4 como un nuevo Plane.
AsQuaternion(Vector4)

Reinterpreta un Vector4 como un nuevo Quaternion.
AsVector2(Vector4)

Reinterpreta un Vector4 como un nuevo Vector2.
AsVector3(Vector4)

Reinterpreta un Vector4 como un nuevo Vector3.
AsVector4(Plane)

Reinterpreta un Plane como un nuevo Vector4.
AsVector4(Quaternion)

Reinterpreta un Quaternion como un nuevo Vector4.
AsVector4(Vector2)

Reinterpreta un Vector2 a un nuevo Vector4 con los nuevos elementos de cero.
AsVector4(Vector3)

Convierte un Vector3 en un nuevo Vector4 con los nuevos elementos en cero.
AsVector4Unsafe(Vector2)

Reinterpreta un Vector2 a una nueva Vector4 con los nuevos elementos sin definir.
AsVector4Unsafe(Vector3)

Convierte un Vector3 en un nuevo Vector4 con los nuevos elementos sin definir.
AsVectorByte<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de bytes sin signo.
AsVectorDouble<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de punto flotante de precisión doble.
AsVectorInt16<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de enteros de 16 bits.
AsVectorInt32<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de enteros.
AsVectorInt64<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de enteros largos.
AsVectorNInt<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de enteros de tamaño nativo.
AsVectorNUInt<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de enteros de tamaño nativo sin signo.
AsVectorSByte<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de bytes firmados.
AsVectorSingle<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de punto flotante de precisión sencilla.
AsVectorUInt16<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de enteros de 16 bits sin signo.
AsVectorUInt32<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de enteros sin signo.
AsVectorUInt64<T>(Vector<T>)

Reinterpreta los bits de un vector especificado en los de un vector de enteros largos sin signo.
BitwiseAnd<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector realizando una operación And bit a bit en cada par de elementos de dos vectores.
BitwiseOr<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector realizando una operación Or bit a bit en cada par de elementos de dos vectores.
Ceiling(Vector<Double>)

Devuelve un nuevo vector cuyos elementos son los valores enteros más pequeños que son mayores o iguales que los elementos del vector especificado.
Ceiling(Vector<Single>)

Devuelve un nuevo vector cuyos elementos son los valores enteros más pequeños que son mayores o iguales que los elementos del vector especificado.
ConditionalSelect(Vector<Int32>, Vector<Single>, Vector<Single>)

Crea un nuevo vector de precisión única con elementos seleccionados entre dos vectores de origen de precisión única especificados basados en un vector de máscara integral.
ConditionalSelect(Vector<Int64>, Vector<Double>, Vector<Double>)

Crea un nuevo vector de precisión doble con elementos seleccionados entre dos vectores de origen de precisión doble especificados basados en un vector de máscara integral.
ConditionalSelect<T>(Vector<T>, Vector<T>, Vector<T>)

Crea un nuevo vector de un tipo especificado con elementos seleccionados entre dos vectores de origen especificados del mismo tipo en función de un vector de máscara integral.
ConvertToDouble(Vector<Int64>)

Convierte un Vector<Int64> en un Vector<Double>.
ConvertToDouble(Vector<UInt64>)

Convierte un Vector<UInt64> en un Vector<Double>.
ConvertToInt32(Vector<Single>)

Convierte un Vector<Single> en un Vector<Int32>.
ConvertToInt32Native(Vector<Single>)

Convierte un Vector<T> en un Vector<T> mediante el comportamiento específico de la plataforma en el desbordamiento.
ConvertToInt64(Vector<Double>)

Convierte un Vector<Double> en un Vector<Int64>.
ConvertToInt64Native(Vector<Double>)

Convierte un System.Numerics.Vector{System.Double} en un System.Numerics.Vector{System.Int64} mediante el comportamiento específico de la plataforma en el desbordamiento.
ConvertToSingle(Vector<Int32>)

Convierte un Vector<Int32> en un Vector<Single>.
ConvertToSingle(Vector<UInt32>)

Convierte un Vector<UInt32> en un Vector<Single>.
ConvertToUInt32(Vector<Single>)

Convierte un Vector<Single> en un Vector<UInt32>.
ConvertToUInt32Native(Vector<Single>)

Convierte un System.Numerics.Vector{System.Single} en un System.Numerics.Vector{System.UInt32} mediante el comportamiento específico de la plataforma en el desbordamiento.
ConvertToUInt64(Vector<Double>)

Convierte un Vector<Double> en un Vector<UInt64>.
ConvertToUInt64Native(Vector<Double>)

Convierte un System.Numerics.Vector{System.Double} en un System.Numerics.Vector{System.UInt64} mediante el comportamiento específico de la plataforma en el desbordamiento.
Create<T>(ReadOnlySpan<T>)

Crea un nuevo Vector<T> a partir de un intervalo de solo lectura determinado.
Create<T>(T)

Crea una nueva instancia de Vector<T> con todos los elementos inicializados en el valor especificado.
CreateSequence<T>(T, T)

Crea una nueva instancia de Vector<T> donde los elementos comienzan en un valor especificado y que se separan según otro valor especificado.
Divide<T>(Vector<T>, T)

Divide un vector por un escalar para calcular el cociente por elemento.
Divide<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector cuyos valores son el resultado de dividir los elementos del primer vector por los elementos correspondientes del segundo vector.
Dot<T>(Vector<T>, Vector<T>)

Devuelve el producto de punto de dos vectores.
Equals(Vector<Double>, Vector<Double>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de dos vectores de precisión doble especificados son iguales.
Equals(Vector<Int32>, Vector<Int32>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de dos vectores enteros especificados son iguales.
Equals(Vector<Int64>, Vector<Int64>)

Devuelve un nuevo vector cuyos elementos indican si los elementos de dos vectores enteros largos especificados son iguales.
Equals(Vector<Single>, Vector<Single>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de dos vectores de precisión única especificados son iguales.
Equals<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector de un tipo especificado cuyos elementos indican si los elementos de dos vectores especificados del mismo tipo son iguales.
EqualsAll<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si cada par de elementos de los vectores especificados es igual.
EqualsAny<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si cualquier par único de elementos de los vectores especificados es igual.
Floor(Vector<Double>)

Devuelve un nuevo vector cuyos elementos son los valores enteros más grandes que son menores o iguales que los elementos del vector especificado.
Floor(Vector<Single>)

Devuelve un nuevo vector cuyos elementos son los valores enteros más grandes que son menores o iguales que los elementos del vector especificado.
FusedMultiplyAdd(Vector<Double>, Vector<Double>, Vector<Double>)

Calcula (left * right) + addend, redondeado como una operación ternaria.
FusedMultiplyAdd(Vector<Single>, Vector<Single>, Vector<Single>)

Calcula (left * right) + addend, redondeado como una operación ternaria.
GetElement<T>(Vector<T>, Int32)

Obtiene el elemento en el índice especificado.
GreaterThan(Vector<Double>, Vector<Double>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector de punto flotante de precisión doble son mayores que sus elementos correspondientes en un segundo vector de punto flotante de precisión doble.
GreaterThan(Vector<Int32>, Vector<Int32>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector entero son mayores que sus elementos correspondientes en un segundo vector entero.
GreaterThan(Vector<Int64>, Vector<Int64>)

Devuelve un nuevo vector entero largo cuyos elementos indican si los elementos de un vector entero largo son mayores que sus elementos correspondientes en un segundo vector entero largo.
GreaterThan(Vector<Single>, Vector<Single>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector de punto flotante de precisión única son mayores que sus elementos correspondientes en un segundo vector de punto flotante de precisión sencilla.
GreaterThan<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector cuyos elementos indican si los elementos de un vector de un tipo especificado son mayores que sus elementos correspondientes en el segundo vector del mismo tiempo.
GreaterThanAll<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si todos los elementos del primer vector son mayores que los elementos correspondientes del segundo vector.
GreaterThanAny<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si algún elemento del primer vector es mayor que el elemento correspondiente en el segundo vector.
GreaterThanOrEqual(Vector<Double>, Vector<Double>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector son mayores o iguales que sus elementos correspondientes en el segundo vector de punto flotante de precisión doble.
GreaterThanOrEqual(Vector<Int32>, Vector<Int32>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector entero son mayores o iguales que sus elementos correspondientes en el segundo vector entero.
GreaterThanOrEqual(Vector<Int64>, Vector<Int64>)

Devuelve un nuevo vector entero largo cuyos elementos indican si los elementos de un vector entero largo son mayores o iguales que sus elementos correspondientes en el segundo vector entero largo.
GreaterThanOrEqual(Vector<Single>, Vector<Single>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector son mayores o iguales que sus elementos correspondientes en el segundo vector de punto flotante de precisión sencilla.
GreaterThanOrEqual<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector cuyos elementos indican si los elementos de un vector de un tipo especificado son mayores o iguales que sus elementos correspondientes en el segundo vector del mismo tipo.
GreaterThanOrEqualAll<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si todos los elementos del primer vector son mayores o iguales que todos los elementos correspondientes del segundo vector.
GreaterThanOrEqualAny<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si cualquier elemento del primer vector es mayor o igual que el elemento correspondiente del segundo vector.
LessThan(Vector<Double>, Vector<Double>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector de punto flotante de precisión doble son menores que sus elementos correspondientes en un segundo vector de punto flotante de precisión doble.
LessThan(Vector<Int32>, Vector<Int32>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector entero son menores que sus elementos correspondientes en un segundo vector entero.
LessThan(Vector<Int64>, Vector<Int64>)

Devuelve un nuevo vector entero largo cuyos elementos indican si los elementos de un vector entero largo son menores que sus elementos correspondientes en un segundo vector entero largo.
LessThan(Vector<Single>, Vector<Single>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector de precisión única son menores que sus elementos correspondientes en un segundo vector de precisión única.
LessThan<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector de un tipo especificado cuyos elementos indican si los elementos de un vector son menores que sus elementos correspondientes en el segundo vector.
LessThanAll<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si todos los elementos del primer vector son menores que sus elementos correspondientes en el segundo vector.
LessThanAny<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si algún elemento del primer vector es menor que el elemento correspondiente del segundo vector.
LessThanOrEqual(Vector<Double>, Vector<Double>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector de punto flotante de precisión doble son menores o iguales que sus elementos correspondientes en un segundo vector de punto flotante de precisión doble.
LessThanOrEqual(Vector<Int32>, Vector<Int32>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector entero son menores o iguales que sus elementos correspondientes en un segundo vector entero.
LessThanOrEqual(Vector<Int64>, Vector<Int64>)

Devuelve un nuevo vector entero largo cuyos elementos indican si los elementos de un vector entero largo son menores o iguales a sus elementos correspondientes en un segundo vector entero largo.
LessThanOrEqual(Vector<Single>, Vector<Single>)

Devuelve un nuevo vector entero cuyos elementos indican si los elementos de un vector de punto flotante de precisión única son menores o iguales que sus elementos correspondientes en un segundo vector de punto flotante de precisión sencilla.
LessThanOrEqual<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector cuyos elementos indican si los elementos de un vector son menores o iguales que sus elementos correspondientes en el segundo vector.
LessThanOrEqualAll<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si todos los elementos del primer vector son menores o iguales que sus elementos correspondientes en el segundo vector.
LessThanOrEqualAny<T>(Vector<T>, Vector<T>)

Devuelve un valor que indica si cualquier elemento del primer vector es menor o igual que el elemento correspondiente del segundo vector.
Load<T>(T*)

Carga un vector del origen especificado.
LoadAligned<T>(T*)

Carga un vector del origen alineado especificado.
LoadAlignedNonTemporal<T>(T*)

Carga un vector del origen alineado especificado.
LoadUnsafe<T>(T)

Carga un vector del origen especificado.
LoadUnsafe<T>(T, UIntPtr)

Carga un vector desde el origen y el desplazamiento de elementos especificados.
Max<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector cuyos elementos son el máximo de cada par de elementos de los dos vectores especificados.
Min<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector cuyos elementos son el mínimo de cada par de elementos de los dos vectores especificados.
Multiply<T>(T, Vector<T>)

Devuelve un nuevo vector cuyos valores son un valor escalar multiplicado por cada uno de los valores de un vector especificado.
Multiply<T>(Vector<T>, T)

Devuelve un nuevo vector cuyos valores son los valores de un vector especificado multiplicado por un valor escalar.
Multiply<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector cuyos valores son el producto de cada par de elementos en dos vectores especificados.
MultiplyAddEstimate(Vector<Double>, Vector<Double>, Vector<Double>)

Proporciona una colección de métodos estáticos para crear, manipular y operar en vectores genéricos.
MultiplyAddEstimate(Vector<Single>, Vector<Single>, Vector<Single>)

Proporciona una colección de métodos estáticos para crear, manipular y operar en vectores genéricos.
Narrow(Vector<Double>, Vector<Double>)

Reduce dos instancias de Vector<Double> en una Vector<Single>.
Narrow(Vector<Int16>, Vector<Int16>)

Reduce dos instancias de Vector<Int16> en una Vector<SByte>.
Narrow(Vector<Int32>, Vector<Int32>)

Reduce dos instancias de Vector<Int32> en una Vector<Int16>.
Narrow(Vector<Int64>, Vector<Int64>)

Reduce dos instancias de Vector<Int64> en una Vector<Int32>.
Narrow(Vector<UInt16>, Vector<UInt16>)

Reduce dos instancias de Vector<UInt16> en una Vector<Byte>.
Narrow(Vector<UInt32>, Vector<UInt32>)

Reduce dos instancias de Vector<UInt32> en una Vector<UInt16>.
Narrow(Vector<UInt64>, Vector<UInt64>)

Reduce dos instancias de Vector<UInt64> en una Vector<UInt32>.
Negate<T>(Vector<T>)

Devuelve un nuevo vector cuyos elementos son la negación del elemento correspondiente en el vector especificado.
OnesComplement<T>(Vector<T>)

Devuelve un nuevo vector cuyos elementos se obtienen tomando el complemento de uno de los elementos de un vector especificado.
ShiftLeft(Vector<Byte>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftLeft(Vector<Int16>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftLeft(Vector<Int32>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftLeft(Vector<Int64>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftLeft(Vector<IntPtr>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftLeft(Vector<SByte>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftLeft(Vector<UInt16>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftLeft(Vector<UInt32>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftLeft(Vector<UInt64>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftLeft(Vector<UIntPtr>, Int32)

Desplaza cada elemento de un vector a la izquierda por la cantidad especificada.
ShiftRightArithmetic(Vector<Int16>, Int32)

Desplaza (firmado) cada elemento de un vector a la derecha por la cantidad especificada.
ShiftRightArithmetic(Vector<Int32>, Int32)

Desplaza (firmado) cada elemento de un vector a la derecha por la cantidad especificada.
ShiftRightArithmetic(Vector<Int64>, Int32)

Desplaza (firmado) cada elemento de un vector a la derecha por la cantidad especificada.
ShiftRightArithmetic(Vector<IntPtr>, Int32)

Desplaza (firmado) cada elemento de un vector a la derecha por la cantidad especificada.
ShiftRightArithmetic(Vector<SByte>, Int32)

Desplaza (firmado) cada elemento de un vector a la derecha por la cantidad especificada.
ShiftRightLogical(Vector<Byte>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
ShiftRightLogical(Vector<Int16>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
ShiftRightLogical(Vector<Int32>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
ShiftRightLogical(Vector<Int64>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
ShiftRightLogical(Vector<IntPtr>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
ShiftRightLogical(Vector<SByte>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
ShiftRightLogical(Vector<UInt16>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
ShiftRightLogical(Vector<UInt32>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
ShiftRightLogical(Vector<UInt64>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
ShiftRightLogical(Vector<UIntPtr>, Int32)

Desplaza (sin signo) cada elemento de un vector derecho por la cantidad especificada.
SquareRoot<T>(Vector<T>)

Devuelve un nuevo vector cuyos elementos son las raíces cuadradas de los elementos de un vector especificado.
Store<T>(Vector<T>, T*)

Almacena un vector en el destino especificado.
StoreAligned<T>(Vector<T>, T*)

Almacena un vector en el destino alineado dado.
StoreAlignedNonTemporal<T>(Vector<T>, T*)

Almacena un vector en el destino alineado dado.
StoreUnsafe<T>(Vector<T>, T)

Almacena un vector en el destino especificado.
StoreUnsafe<T>(Vector<T>, T, UIntPtr)

Almacena un vector en el destino especificado.
Subtract<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector cuyos valores son la diferencia entre los elementos del segundo vector y sus elementos correspondientes en el primer vector.
Sum<T>(Vector<T>)

Devuelve la suma de todos los elementos dentro del vector especificado.
ToScalar<T>(Vector<T>)

Convierte el vector especificado en un escalar que contiene el valor del primer elemento.
Widen(Vector<Byte>, Vector<UInt16>, Vector<UInt16>)

Amplía un Vector<Byte> en dos instancias de Vector<UInt16>.
Widen(Vector<Int16>, Vector<Int32>, Vector<Int32>)

Amplía un Vector<Int16> en dos instancias de Vector<Int32>.
Widen(Vector<Int32>, Vector<Int64>, Vector<Int64>)

Amplía un Vector<Int32> en dos instancias de Vector<Int64>.
Widen(Vector<SByte>, Vector<Int16>, Vector<Int16>)

Amplía un Vector<SByte> en dos instancias de Vector<Int16>.
Widen(Vector<Single>, Vector<Double>, Vector<Double>)

Amplía un Vector<Single> en dos instancias de Vector<Double>.
Widen(Vector<UInt16>, Vector<UInt32>, Vector<UInt32>)

Amplía un Vector<UInt16> en dos instancias de Vector<UInt32>.
Widen(Vector<UInt32>, Vector<UInt64>, Vector<UInt64>)

Amplía un Vector<UInt32> en dos instancias de Vector<UInt64>.
WidenLower(Vector<Byte>)

Amplía la mitad inferior de un Vector<T> en un Vector<T>.
WidenLower(Vector<Int16>)

Amplía la mitad inferior de un Vector<T> en un Vector<T>.
WidenLower(Vector<Int32>)

Amplía la mitad inferior de un Vector<T> en un Vector<T>.
WidenLower(Vector<SByte>)

Amplía la mitad inferior de un Vector<T> en un Vector<T>.
WidenLower(Vector<Single>)

Amplía la mitad inferior de un Vector<T> en un Vector<T>.
WidenLower(Vector<UInt16>)

Amplía la mitad inferior de un Vector<T> en un Vector<T>.
WidenLower(Vector<UInt32>)

Amplía la mitad inferior de un Vector<T> en un Vector<T>.
WidenUpper(Vector<Byte>)

Amplía la mitad superior de un Vector<T> en un Vector<T>.
WidenUpper(Vector<Int16>)

Amplía la mitad superior de un Vector<T> en un Vector<T>.
WidenUpper(Vector<Int32>)

Amplía la mitad superior de un Vector<T> en un Vector<T>.
WidenUpper(Vector<SByte>)

Amplía la mitad superior de un Vector<T> en un Vector<T>.
WidenUpper(Vector<Single>)

Amplía la mitad superior de un Vector<T> en un Vector<T>.
WidenUpper(Vector<UInt16>)

Amplía la mitad superior de un Vector<T> en un Vector<T>.
WidenUpper(Vector<UInt32>)

Amplía la mitad superior de un Vector<T> en un Vector<T>.
WithElement<T>(Vector<T>, Int32, T)

Crea un nuevo Vector<T> con el elemento en el índice especificado establecido en el valor especificado y los elementos restantes establecidos en el mismo valor que en el vector especificado.
Xor<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector realizando una operación or (XOr) exclusiva bit a bit en cada par de elementos de dos vectores.

Se aplica a