Upraviť

Zdieľať cez

Vector Class

  • Reference

Definition

Namespace:
System.Numerics
Assembly:
System.Numerics.Vectors.dll
Assemblies:
netstandard.dll, System.Numerics.Vectors.dll
Assembly:
netstandard.dll
Package:
System.Numerics.Vectors v4.5.0
Source:
Vector.cs
Source:
Vector.cs
Source:
Vector.cs

Provides a collection of static methods for creating, manipulating, and otherwise operating on generic vectors.

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

Properties

IsHardwareAccelerated

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

Methods

Abs<T>(Vector<T>)

Returns a new vector whose elements are the absolute values of the given vector's elements.
Add<T>(Vector<T>, Vector<T>)

Returns a new vector whose values are the sum of each pair of elements from two given vectors.
AndNot<T>(Vector<T>, Vector<T>)

Returns a new vector by performing a bitwise And Not operation on each pair of corresponding elements in two vectors.
As<TFrom,TTo>(Vector<TFrom>)

Reinterprets a Vector<T> as a new Vector<T>.
AsPlane(Vector4)

Reinterprets a Vector4 as a new Plane.
AsQuaternion(Vector4)

Reinterprets a Vector4 as a new Quaternion.
AsVector2(Vector4)

Reinterprets a Vector4 as a new Vector2.
AsVector3(Vector4)

Reinterprets a Vector4 as a new Vector3.
AsVector4(Plane)

Reinterprets a Plane as a new Vector4.
AsVector4(Quaternion)

Reinterprets a Quaternion as a new Vector4.
AsVector4(Vector2)

Reinterprets a Vector2 to a new Vector4 with the new elements zeroed.
AsVector4(Vector3)

Converts a Vector3 to a new Vector4 with the new elements zeroed.
AsVector4Unsafe(Vector2)

Reinterprets a Vector2 to a new Vector4 with the new elements undefined.
AsVector4Unsafe(Vector3)

Converts a Vector3 to a new Vector4 with the new elements undefined.
AsVectorByte<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of unsigned bytes.
AsVectorDouble<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a double-precision floating-point vector.
AsVectorInt16<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of 16-bit integers.
AsVectorInt32<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of integers.
AsVectorInt64<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of long integers.
AsVectorNInt<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of native-sized integers.
AsVectorNUInt<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of native-sized, unsigned integers.
AsVectorSByte<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of signed bytes.
AsVectorSingle<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a single-precision floating-point vector.
AsVectorUInt16<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of unsigned 16-bit integers.
AsVectorUInt32<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of unsigned integers.
AsVectorUInt64<T>(Vector<T>)

Reinterprets the bits of a specified vector into those of a vector of unsigned long integers.
BitwiseAnd<T>(Vector<T>, Vector<T>)

Returns a new vector by performing a bitwise And operation on each pair of elements in two vectors.
BitwiseOr<T>(Vector<T>, Vector<T>)

Returns a new vector by performing a bitwise Or operation on each pair of elements in two vectors.
Ceiling(Vector<Double>)

Returns a new vector whose elements are the smallest integral values that are greater than or equal to the given vector's elements.
Ceiling(Vector<Single>)

Returns a new vector whose elements are the smallest integral values that are greater than or equal to the given vector's elements.
Clamp<T>(Vector<T>, Vector<T>, Vector<T>)

Restricts a vector between a minimum and a maximum value.
ClampNative<T>(Vector<T>, Vector<T>, Vector<T>)

Restricts a vector between a minimum and a maximum value using platform specific behavior for NaN and NegativeZero..
ConditionalSelect(Vector<Int32>, Vector<Single>, Vector<Single>)

Creates a new single-precision vector with elements selected between two specified single-precision source vectors based on an integral mask vector.
ConditionalSelect(Vector<Int64>, Vector<Double>, Vector<Double>)

Creates a new double-precision vector with elements selected between two specified double-precision source vectors based on an integral mask vector.
ConditionalSelect<T>(Vector<T>, Vector<T>, Vector<T>)

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.
ConvertToDouble(Vector<Int64>)

Converts a Vector<Int64> to a Vector<Double>.
ConvertToDouble(Vector<UInt64>)

Converts a Vector<UInt64> to a Vector<Double>.
ConvertToInt32(Vector<Single>)

Converts a Vector<Single> to a Vector<Int32>.
ConvertToInt32Native(Vector<Single>)

Converts a Vector<T> to a Vector<T> using platform specific behavior on overflow.
ConvertToInt64(Vector<Double>)

Converts a Vector<Double> to a Vector<Int64>.
ConvertToInt64Native(Vector<Double>)

Converts a System.Numerics.Vector<System.Double> to a System.Numerics.Vector<System.Int64> using platform specific behavior on overflow.
ConvertToSingle(Vector<Int32>)

Converts a Vector<Int32> to a Vector<Single>.
ConvertToSingle(Vector<UInt32>)

Converts a Vector<UInt32> to a Vector<Single>.
ConvertToUInt32(Vector<Single>)

Converts a Vector<Single> to a Vector<UInt32>.
ConvertToUInt32Native(Vector<Single>)

Converts a System.Numerics.Vector<System.Single> to a System.Numerics.Vector<System.UInt32> using platform specific behavior on overflow.
ConvertToUInt64(Vector<Double>)

Converts a Vector<Double> to a Vector<UInt64>.
ConvertToUInt64Native(Vector<Double>)

Converts a System.Numerics.Vector<System.Double> to a System.Numerics.Vector<System.UInt64> using platform specific behavior on overflow.
CopySign<T>(Vector<T>, Vector<T>)

Copies the per-element sign of a vector to the per-element sign of another vector.
Cos(Vector<Double>)
Cos(Vector<Single>)
Create<T>(ReadOnlySpan<T>)

Creates a new Vector<T> from a given readonly span.
Create<T>(T)

Creates a new Vector<T> instance with all elements initialized to the specified value.
CreateSequence<T>(T, T)

Creates a new Vector<T> instance where the elements begin at a specified value and which are spaced apart according to another specified value.
DegreesToRadians(Vector<Double>)
DegreesToRadians(Vector<Single>)
Divide<T>(Vector<T>, T)

Divides a vector by a scalar to compute the per-element quotient.
Divide<T>(Vector<T>, Vector<T>)

Returns a new vector whose values are the result of dividing the first vector's elements by the corresponding elements in the second vector.
Dot<T>(Vector<T>, Vector<T>)

Returns the dot product of two vectors.
Equals(Vector<Double>, Vector<Double>)

Returns a new integral vector whose elements signal whether the elements in two specified double-precision vectors are equal.
Equals(Vector<Int32>, Vector<Int32>)

Returns a new integral vector whose elements signal whether the elements in two specified integral vectors are equal.
Equals(Vector<Int64>, Vector<Int64>)

Returns a new vector whose elements signal whether the elements in two specified long integer vectors are equal.
Equals(Vector<Single>, Vector<Single>)

Returns a new integral vector whose elements signal whether the elements in two specified single-precision vectors are equal.
Equals<T>(Vector<T>, Vector<T>)

Returns a new vector of a specified type whose elements signal whether the elements in two specified vectors of the same type are equal.
EqualsAll<T>(Vector<T>, Vector<T>)

Returns a value that indicates whether each pair of elements in the given vectors is equal.
EqualsAny<T>(Vector<T>, Vector<T>)

Returns a value that indicates whether any single pair of elements in the given vectors is equal.
Exp(Vector<Double>)
Exp(Vector<Single>)
Floor(Vector<Double>)

Returns a new vector whose elements are the largest integral values that are less than or equal to the given vector's elements.
Floor(Vector<Single>)

Returns a new vector whose elements are the largest integral values that are less than or equal to the given vector's elements.
FusedMultiplyAdd(Vector<Double>, Vector<Double>, Vector<Double>)

Computes (left * right) + addend, rounded as one ternary operation.
FusedMultiplyAdd(Vector<Single>, Vector<Single>, Vector<Single>)

Computes (left * right) + addend, rounded as one ternary operation.
GetElement<T>(Vector<T>, Int32)

Gets the element at the specified index.
GreaterThan(Vector<Double>, Vector<Double>)

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.
GreaterThan(Vector<Int32>, Vector<Int32>)

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.
GreaterThan(Vector<Int64>, Vector<Int64>)

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.
GreaterThan(Vector<Single>, Vector<Single>)

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.
GreaterThan<T>(Vector<T>, Vector<T>)

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.
GreaterThanAll<T>(Vector<T>, Vector<T>)

Returns a value that indicates whether all elements in the first vector are greater than the corresponding elements in the second vector.
GreaterThanAny<T>(Vector<T>, Vector<T>)

Returns a value that indicates whether any element in the first vector is greater than the corresponding element in the second vector.
GreaterThanOrEqual(Vector<Double>, Vector<Double>)

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.
GreaterThanOrEqual(Vector<Int32>, Vector<Int32>)

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.
GreaterThanOrEqual(Vector<Int64>, Vector<Int64>)

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.
GreaterThanOrEqual(Vector<Single>, Vector<Single>)

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.
GreaterThanOrEqual<T>(Vector<T>, Vector<T>)

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.
GreaterThanOrEqualAll<T>(Vector<T>, Vector<T>)

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.
GreaterThanOrEqualAny<T>(Vector<T>, Vector<T>)

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.
Hypot(Vector<Double>, Vector<Double>)
Hypot(Vector<Single>, Vector<Single>)
IsNaN<T>(Vector<T>)

Determines which elements in a vector are NaN.
IsNegative<T>(Vector<T>)

Determines which elements in a vector represents negative real numbers.
IsPositive<T>(Vector<T>)

Determines which elements in a vector represents positive real numbers.
IsPositiveInfinity<T>(Vector<T>)

Determines which elements in a vector are positive infinity.
IsZero<T>(Vector<T>)

Determines which elements in a vector are zero.
Lerp(Vector<Double>, Vector<Double>, Vector<Double>)

Performs a linear interpolation between two vectors based on the given weighting.
Lerp(Vector<Single>, Vector<Single>, Vector<Single>)

Performs a linear interpolation between two vectors based on the given weighting.
LessThan(Vector<Double>, Vector<Double>)

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.
LessThan(Vector<Int32>, Vector<Int32>)

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.
LessThan(Vector<Int64>, Vector<Int64>)

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.
LessThan(Vector<Single>, Vector<Single>)

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.
LessThan<T>(Vector<T>, Vector<T>)

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.
LessThanAll<T>(Vector<T>, Vector<T>)

Returns a value that indicates whether all of the elements in the first vector are less than their corresponding elements in the second vector.
LessThanAny<T>(Vector<T>, Vector<T>)

Returns a value that indicates whether any element in the first vector is less than the corresponding element in the second vector.
LessThanOrEqual(Vector<Double>, Vector<Double>)

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.
LessThanOrEqual(Vector<Int32>, Vector<Int32>)

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.
LessThanOrEqual(Vector<Int64>, Vector<Int64>)

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.
LessThanOrEqual(Vector<Single>, Vector<Single>)

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.
LessThanOrEqual<T>(Vector<T>, Vector<T>)

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.
LessThanOrEqualAll<T>(Vector<T>, Vector<T>)

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.
LessThanOrEqualAny<T>(Vector<T>, Vector<T>)

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.
Load<T>(T*)

Loads a vector from the given source.
LoadAligned<T>(T*)

Loads a vector from the given aligned source.
LoadAlignedNonTemporal<T>(T*)

Loads a vector from the given aligned source.
LoadUnsafe<T>(T)

Loads a vector from the given source.
LoadUnsafe<T>(T, UIntPtr)

Loads a vector from the given source and element offset.
Log(Vector<Double>)
Log(Vector<Single>)
Log2(Vector<Double>)
Log2(Vector<Single>)
Max<T>(Vector<T>, Vector<T>)

Returns a new vector whose elements are the maximum of each pair of elements in the two given vectors.
MaxMagnitude<T>(Vector<T>, Vector<T>)

Compares two vectors to compute which has the greater magnitude on a per-element basis.
MaxMagnitudeNumber<T>(Vector<T>, Vector<T>)

Compares two vectors, on a per-element basis, to compute which has the greater magnitude and returning the other value if an input is NaN.
MaxNative<T>(Vector<T>, Vector<T>)

Compare two vectors to determine which is greater on a per-element basis using platform specific behavior for NaN and NegativeZero.
MaxNumber<T>(Vector<T>, Vector<T>)

Compares two vectors, on a per-element basis, to compute which is greater and returning the other value if an element is NaN.
Min<T>(Vector<T>, Vector<T>)

Returns a new vector whose elements are the minimum of each pair of elements in the two given vectors.
MinMagnitude<T>(Vector<T>, Vector<T>)

Compares two vectors to compute which has the lesser magnitude on a per-element basis.
MinMagnitudeNumber<T>(Vector<T>, Vector<T>)

Compares two vectors, on a per-element basis, to compute which has the lesser magnitude and returning the other value if an input is NaN.
MinNative<T>(Vector<T>, Vector<T>)

Compare two vectors to determine which is lesser on a per-element basis using platform specific behavior for NaN and NegativeZero.
MinNumber<T>(Vector<T>, Vector<T>)

Compares two vectors, on a per-element basis, to compute which is lesser and returning the other value if an element is NaN.
Multiply<T>(T, Vector<T>)

Returns a new vector whose values are a scalar value multiplied by each of the values of a specified vector.
Multiply<T>(Vector<T>, T)

Returns a new vector whose values are the values of a specified vector each multiplied by a scalar value.
Multiply<T>(Vector<T>, Vector<T>)

Returns a new vector whose values are the product of each pair of elements in two specified vectors.
MultiplyAddEstimate(Vector<Double>, Vector<Double>, Vector<Double>)
MultiplyAddEstimate(Vector<Single>, Vector<Single>, Vector<Single>)
Narrow(Vector<Double>, Vector<Double>)

Narrows two Vector<Double> instances into one Vector<Single>.
Narrow(Vector<Int16>, Vector<Int16>)

Narrows two Vector<Int16> instances into one Vector<SByte>.
Narrow(Vector<Int32>, Vector<Int32>)

Narrows two Vector<Int32> instances into one Vector<Int16>.
Narrow(Vector<Int64>, Vector<Int64>)

Narrows two Vector<Int64> instances into one Vector<Int32>.
Narrow(Vector<UInt16>, Vector<UInt16>)

Narrows two Vector<UInt16> instances into one Vector<Byte>.
Narrow(Vector<UInt32>, Vector<UInt32>)

Narrows two Vector<UInt32> instances into one Vector<UInt16>.
Narrow(Vector<UInt64>, Vector<UInt64>)

Narrows two Vector<UInt64> instances into one Vector<UInt32>.
Negate<T>(Vector<T>)

Returns a new vector whose elements are the negation of the corresponding element in the specified vector.
OnesComplement<T>(Vector<T>)

Returns a new vector whose elements are obtained by taking the one's complement of a specified vector's elements.
RadiansToDegrees(Vector<Double>)
RadiansToDegrees(Vector<Single>)
Round(Vector<Double>)
Round(Vector<Double>, MidpointRounding)
Round(Vector<Single>)
Round(Vector<Single>, MidpointRounding)
ShiftLeft(Vector<Byte>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftLeft(Vector<Int16>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftLeft(Vector<Int32>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftLeft(Vector<Int64>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftLeft(Vector<IntPtr>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftLeft(Vector<SByte>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftLeft(Vector<UInt16>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftLeft(Vector<UInt32>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftLeft(Vector<UInt64>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftLeft(Vector<UIntPtr>, Int32)

Shifts each element of a vector left by the specified amount.
ShiftRightArithmetic(Vector<Int16>, Int32)

Shifts (signed) each element of a vector right by the specified amount.
ShiftRightArithmetic(Vector<Int32>, Int32)

Shifts (signed) each element of a vector right by the specified amount.
ShiftRightArithmetic(Vector<Int64>, Int32)

Shifts (signed) each element of a vector right by the specified amount.
ShiftRightArithmetic(Vector<IntPtr>, Int32)

Shifts (signed) each element of a vector right by the specified amount.
ShiftRightArithmetic(Vector<SByte>, Int32)

Shifts (signed) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<Byte>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<Int16>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<Int32>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<Int64>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<IntPtr>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<SByte>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<UInt16>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<UInt32>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<UInt64>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
ShiftRightLogical(Vector<UIntPtr>, Int32)

Shifts (unsigned) each element of a vector right by the specified amount.
Sin(Vector<Double>)
Sin(Vector<Single>)
SinCos(Vector<Double>)
SinCos(Vector<Single>)
SquareRoot<T>(Vector<T>)

Returns a new vector whose elements are the square roots of a specified vector's elements.
Store<T>(Vector<T>, T*)

Stores a vector at the given destination.
StoreAligned<T>(Vector<T>, T*)

Stores a vector at the given aligned destination.
StoreAlignedNonTemporal<T>(Vector<T>, T*)

Stores a vector at the given aligned destination.
StoreUnsafe<T>(Vector<T>, T)

Stores a vector at the given destination.
StoreUnsafe<T>(Vector<T>, T, UIntPtr)

Stores a vector at the given destination.
Subtract<T>(Vector<T>, Vector<T>)

Returns a new vector whose values are the difference between the elements in the second vector and their corresponding elements in the first vector.
Sum<T>(Vector<T>)

Returns the sum of all the elements inside the specified vector.
ToScalar<T>(Vector<T>)

Converts the given vector to a scalar containing the value of the first element.
Truncate(Vector<Double>)
Truncate(Vector<Single>)
Widen(Vector<Byte>, Vector<UInt16>, Vector<UInt16>)

Widens a Vector<Byte> into two Vector<UInt16> instances.
Widen(Vector<Int16>, Vector<Int32>, Vector<Int32>)

Widens a Vector<Int16> into two Vector<Int32> instances.
Widen(Vector<Int32>, Vector<Int64>, Vector<Int64>)

Widens a Vector<Int32> into two Vector<Int64> instances.
Widen(Vector<SByte>, Vector<Int16>, Vector<Int16>)

Widens a Vector<SByte> into two Vector<Int16> instances.
Widen(Vector<Single>, Vector<Double>, Vector<Double>)

Widens a Vector<Single> into two Vector<Double> instances.
Widen(Vector<UInt16>, Vector<UInt32>, Vector<UInt32>)

Widens a Vector<UInt16> into two Vector<UInt32> instances.
Widen(Vector<UInt32>, Vector<UInt64>, Vector<UInt64>)

Widens a Vector<UInt32> into two Vector<UInt64> instances.
WidenLower(Vector<Byte>)

Widens the lower half of a Vector<T> into a Vector<T>.
WidenLower(Vector<Int16>)

Widens the lower half of a Vector<T> into a Vector<T>.
WidenLower(Vector<Int32>)

Widens the lower half of a Vector<T> into a Vector<T>.
WidenLower(Vector<SByte>)

Widens the lower half of a Vector<T> into a Vector<T>.
WidenLower(Vector<Single>)

Widens the lower half of a Vector<T> into a Vector<T>.
WidenLower(Vector<UInt16>)

Widens the lower half of a Vector<T> into a Vector<T>.
WidenLower(Vector<UInt32>)

Widens the lower half of a Vector<T> into a Vector<T>.
WidenUpper(Vector<Byte>)

Widens the upper half of a Vector<T> into a Vector<T>.
WidenUpper(Vector<Int16>)

Widens the upper half of a Vector<T> into a Vector<T>.
WidenUpper(Vector<Int32>)

Widens the upper half of a Vector<T> into a Vector<T>.
WidenUpper(Vector<SByte>)

Widens the upper half of a Vector<T> into a Vector<T>.
WidenUpper(Vector<Single>)

Widens the upper half of a Vector<T> into a Vector<T>.
WidenUpper(Vector<UInt16>)

Widens the upper half of a Vector<T> into a Vector<T>.
WidenUpper(Vector<UInt32>)

Widens the upper half of a Vector<T> into a Vector<T>.
WithElement<T>(Vector<T>, Int32, T)

Creates a new Vector<T> with the element at the specified index set to the specified value and the remaining elements set to the same value as that in the given vector.
Xor<T>(Vector<T>, Vector<T>)

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

Applies to