Vector Clase

Definición

Espacio de nombres:
System.Numerics
Ensamblado:
System.Numerics.Vectors.dll
Ensamblado:
netstandard.dll

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
Herencia
Object
Vector

Propiedades

Nombre Description
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

Nombre Description
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.
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.
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 bit a bit And en cada par de elementos de dos vectores.
BitwiseOr<T>(Vector<T>, Vector<T>)

Devuelve un nuevo vector realizando una operación bit a bit Or en cada par de elementos de dos vectores.
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 Vector<Int64> en Vector<Double>.
ConvertToDouble(Vector<UInt64>)

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

Convierte Vector<Single> en Vector<Int32>.
ConvertToInt64(Vector<Double>)

Convierte Vector<Double> en Vector<Int64>.
ConvertToSingle(Vector<Int32>)

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

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

Convierte Vector<Single> en Vector<UInt32>.
ConvertToUInt64(Vector<Double>)

Convierte Vector<Double> en Vector<UInt64>.
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.
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.
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.
Narrow(Vector<Double>, Vector<Double>)

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

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

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

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

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

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

Limita dos Vector<UInt64> instancias 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.
SquareRoot<T>(Vector<T>)

Devuelve un nuevo vector cuyos elementos son las raíces cuadradas de los elementos de un vector 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.
Widen(Vector<Byte>, Vector<UInt16>, Vector<UInt16>)

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

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

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

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

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

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

Amplía en Vector<UInt32> dos Vector<UInt64> instancias.
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