<PackageReference Include="System.Numerics.Vectors" Version="4.5.0-preview2-26406-04" />

System.Numerics.Vector

public static class Vector
Provides a collection of static convenience methods for creating, manipulating, combining, and converting generic vectors.
public static bool IsHardwareAccelerated { get; }

Gets a value that indicates whether vector operations are subject to hardware acceleration through JIT intrinsic support.

public static Vector<T> Abs<T>(Vector<T> value) where T : struct

Returns a new vector whose elements are the absolute values of the given vector&#39;s elements.

public static Vector<T> Add<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector whose values are the sum of each pair of elements from two given vectors.

public static Vector<T> AndNot<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector by performing a bitwise And Not operation on each pair of corresponding elements in two vectors.

public static Vector<byte> AsVectorByte<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a vector of unsigned bytes.

public static Vector<double> AsVectorDouble<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a double-precision floating-point vector.

public static Vector<short> AsVectorInt16<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a vector of 16-bit integers.

public static Vector<int> AsVectorInt32<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a vector of integers.

public static Vector<long> AsVectorInt64<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a vector of long integers.

public static Vector<sbyte> AsVectorSByte<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a vector of signed bytes.

public static Vector<float> AsVectorSingle<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a single-precision floating-point vector.

public static Vector<ushort> AsVectorUInt16<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a vector of unsigned 16-bit integers.

public static Vector<uint> AsVectorUInt32<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a vector of unsigned integers.

public static Vector<ulong> AsVectorUInt64<T>(Vector<T> value) where T : struct

Reinterprets the bits of a specified vector into those of a vector of unsigned long integers.

public static Vector<T> BitwiseAnd<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector by performing a bitwise And operation on each pair of elements in two vectors.

public static Vector<T> BitwiseOr<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector by performing a bitwise Or operation on each pair of elements in two vectors.

public static Vector<float> ConditionalSelect(Vector<int> condition, Vector<float> left, Vector<float> right)

Creates a new single-precision vector with elements selected between two specified single-precision source vectors based on an integral mask vector.

public static Vector<double> ConditionalSelect(Vector<long> condition, Vector<double> left, Vector<double> right)

Creates a new double-precision vector with elements selected between two specified double-precision source vectors based on an integral mask vector.

public static Vector<T> ConditionalSelect<T>(Vector<T> condition, Vector<T> left, Vector<T> right) where T : struct

Creates a new vector of a specified type with elements selected between two specified source vectors of the same type based on an integral mask vector.

public static Vector<double> ConvertToDouble(Vector<long> value)

public static Vector<double> ConvertToDouble(Vector<ulong> value)

public static Vector<int> ConvertToInt32(Vector<float> value)

public static Vector<long> ConvertToInt64(Vector<double> value)

public static Vector<float> ConvertToSingle(Vector<int> value)

public static Vector<float> ConvertToSingle(Vector<uint> value)

public static Vector<uint> ConvertToUInt32(Vector<float> value)

public static Vector<ulong> ConvertToUInt64(Vector<double> value)

public static Vector<T> Divide<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector whose values are the result of dividing the first vector&#39;s elements by the corresponding elements in the second vector.

public static T Dot<T>(Vector<T> left, Vector<T> right) where T : struct

Returns the dot product of two vectors.

public static Vector<T> Equals<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector of a specified type whose elements signal whether the elements in two specified vectors of the same type are equal.

public static Vector<int> Equals(Vector<float> left, Vector<float> right)

Returns a new integral vector whose elements signal whether the elements in two specified single-precision vectors are equal.

public static Vector<int> Equals(Vector<int> left, Vector<int> right)

Returns a new integral vector whose elements signal whether the elements in two specified integral vectors are equal.

public static Vector<long> Equals(Vector<double> left, Vector<double> right)

Returns a new integral vector whose elements signal whether the elements in two specified double-precision vectors are equal.

public static Vector<long> Equals(Vector<long> left, Vector<long> right)

Returns a new vector whose elements signal whether the elements in two specified long integer vectors are equal.

public static bool EqualsAll<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether each pair of elements in the given vectors is equal.

public static bool EqualsAny<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether any single pair of elements in the given vectors is equal.

public static Vector<T> GreaterThan<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector whose elements signal whether the elements in one vector of a specified type are greater than their corresponding elements in the second vector of the same time.

public static Vector<int> GreaterThan(Vector<float> left, Vector<float> right)

Returns a new integral vector whose elements signal whether the elements in one single-precision floating-point vector are greater than their corresponding elements in a second single-precision floating-point vector.

public static Vector<int> GreaterThan(Vector<int> left, Vector<int> right)

Returns a new integral vector whose elements signal whether the elements in one integral vector are greater than their corresponding elements in a second integral vector.

public static Vector<long> GreaterThan(Vector<double> left, Vector<double> right)

Returns a new integral vector whose elements signal whether the elements in one double-precision floating-point vector are greater than their corresponding elements in a second double-precision floating-point vector.

public static Vector<long> GreaterThan(Vector<long> left, Vector<long> right)

Returns a new long integer vector whose elements signal whether the elements in one long integer vector are greater than their corresponding elements in a second long integer vector.

public static bool GreaterThanAll<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether all elements in the first vector are greater than the corresponding elements in the second vector.

public static bool GreaterThanAny<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether any element in the first vector is greater than the corresponding element in the second vector.

public static Vector<T> GreaterThanOrEqual<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector whose elements signal whether the elements in one vector of a specified type are greater than or equal to their corresponding elements in the second vector of the same type.

public static Vector<int> GreaterThanOrEqual(Vector<float> left, Vector<float> right)

Returns a new integral vector whose elements signal whether the elements in one vector are greater than or equal to their corresponding elements in the single-precision floating-point second vector.

public static Vector<int> GreaterThanOrEqual(Vector<int> left, Vector<int> right)

Returns a new integral vector whose elements signal whether the elements in one integral vector are greater than or equal to their corresponding elements in the second integral vector.

public static Vector<long> GreaterThanOrEqual(Vector<long> left, Vector<long> right)

Returns a new long integer vector whose elements signal whether the elements in one long integer vector are greater than or equal to their corresponding elements in the second long integer vector.

public static Vector<long> GreaterThanOrEqual(Vector<double> left, Vector<double> right)

Returns a new integral vector whose elements signal whether the elements in one vector are greater than or equal to their corresponding elements in the second double-precision floating-point vector.

public static bool GreaterThanOrEqualAll<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether all elements in the first vector are greater than or equal to all the corresponding elements in the second vector.

public static bool GreaterThanOrEqualAny<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether any element in the first vector is greater than or equal to the corresponding element in the second vector.

public static Vector<T> LessThan<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector of a specified type whose elements signal whether the elements in one vector are less than their corresponding elements in the second vector.

public static Vector<int> LessThan(Vector<float> left, Vector<float> right)

Returns a new integral vector whose elements signal whether the elements in one single-precision vector are less than their corresponding elements in a second single-precision vector.

public static Vector<int> LessThan(Vector<int> left, Vector<int> right)

Returns a new integral vector whose elements signal whether the elements in one integral vector are less than their corresponding elements in a second integral vector.

public static Vector<long> LessThan(Vector<double> left, Vector<double> right)

Returns a new integral vector whose elements signal whether the elements in one double-precision floating-point vector are less than their corresponding elements in a second double-precision floating-point vector.

public static Vector<long> LessThan(Vector<long> left, Vector<long> right)

Returns a new long integer vector whose elements signal whether the elements in one long integer vector are less than their corresponding elements in a second long integer vector.

public static bool LessThanAll<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether all of the elements in the first vector are less than their corresponding elements in the second vector.

public static bool LessThanAny<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether any element in the first vector is less than the corresponding element in the second vector.

public static Vector<T> LessThanOrEqual<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector whose elements signal whether the elements in one vector are less than or equal to their corresponding elements in the second vector.

public static Vector<int> LessThanOrEqual(Vector<float> left, Vector<float> right)

Returns a new integral vector whose elements signal whether the elements in one single-precision floating-point vector are less than or equal to their corresponding elements in a second single-precision floating-point vector.

public static Vector<int> LessThanOrEqual(Vector<int> left, Vector<int> right)

Returns a new integral vector whose elements signal whether the elements in one integral vector are less than or equal to their corresponding elements in a second integral vector.

public static Vector<long> LessThanOrEqual(Vector<long> left, Vector<long> right)

Returns a new long integer vector whose elements signal whether the elements in one long integer vector are less or equal to their corresponding elements in a second long integer vector.

public static Vector<long> LessThanOrEqual(Vector<double> left, Vector<double> right)

Returns a new integral vector whose elements signal whether the elements in one double-precision floating-point vector are less than or equal to their corresponding elements in a second double-precision floating-point vector.

public static bool LessThanOrEqualAll<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether all elements in the first vector are less than or equal to their corresponding elements in the second vector.

public static bool LessThanOrEqualAny<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a value that indicates whether any element in the first vector is less than or equal to the corresponding element in the second vector.

public static Vector<T> Max<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector whose elements are the maximum of each pair of elements in the two given vectors.

public static Vector<T> Min<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector whose elements are the minimum of each pair of elements in the two given vectors.

public static Vector<T> Multiply<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector whose values are the product of each pair of elements in two specified vectors.

public static Vector<T> Multiply<T>(Vector<T> left, T right) where T : struct

Returns a new vector whose values are the values of a specified vector each multiplied by a scalar value.

public static Vector<T> Multiply<T>(T left, Vector<T> right) where T : struct

Returns a new vector whose values are a scalar value multiplied by each of the values of a specified vector.

public static Vector<byte> Narrow(Vector<ushort> low, Vector<ushort> high)

public static Vector<ushort> Narrow(Vector<uint> low, Vector<uint> high)

public static Vector<uint> Narrow(Vector<ulong> low, Vector<ulong> high)

public static Vector<sbyte> Narrow(Vector<short> low, Vector<short> high)

public static Vector<short> Narrow(Vector<int> low, Vector<int> high)

public static Vector<int> Narrow(Vector<long> low, Vector<long> high)

public static Vector<float> Narrow(Vector<double> low, Vector<double> high)

public static Vector<T> Negate<T>(Vector<T> value) where T : struct

Returns a new vector whose elements are the negation of the corresponding element in the specified vector.

public static Vector<T> OnesComplement<T>(Vector<T> value) where T : struct

Returns a new vector whose elements are obtained by taking the one&#39;s complement of a specified vector&#39;s elements.

public static Vector<T> SquareRoot<T>(Vector<T> value) where T : struct

Returns a new vector whose elements are the square roots of a specified vector&#39;s elements.

public static Vector<T> Subtract<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector whose values are the difference between the elements in the second vector and their corresponding elements in the first vector.

public static void Widen(Vector<byte> source, out Vector low, out Vector high)

public static void Widen(Vector<ushort> source, out Vector low, out Vector high)

public static void Widen(Vector<uint> source, out Vector low, out Vector high)

public static void Widen(Vector<sbyte> source, out Vector low, out Vector high)

public static void Widen(Vector<short> source, out Vector low, out Vector high)

public static void Widen(Vector<int> source, out Vector low, out Vector high)

public static void Widen(Vector<float> source, out Vector low, out Vector high)

public static Vector<T> Xor<T>(Vector<T> left, Vector<T> right) where T : struct

Returns a new vector by performing a bitwise exclusive Or (XOr) operation on each pair of elements in two vectors.