Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches
System.Runtime.Intrinsics.Arm.Rdm Class Referenceabstract

Classes

class  Arm64
 

Static Public Member Functions

static Vector64< shortMultiplyRoundedDoublingAndAddSaturateHigh (Vector64< short > addend, Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplyRoundedDoublingAndAddSaturateHigh (Vector64< int > addend, Vector64< int > left, Vector64< int > right)
 
static Vector128< shortMultiplyRoundedDoublingAndAddSaturateHigh (Vector128< short > addend, Vector128< short > left, Vector128< short > right)
 
static Vector128< int > MultiplyRoundedDoublingAndAddSaturateHigh (Vector128< int > addend, Vector128< int > left, Vector128< int > right)
 
static Vector64< shortMultiplyRoundedDoublingAndSubtractSaturateHigh (Vector64< short > minuend, Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplyRoundedDoublingAndSubtractSaturateHigh (Vector64< int > minuend, Vector64< int > left, Vector64< int > right)
 
static Vector128< shortMultiplyRoundedDoublingAndSubtractSaturateHigh (Vector128< short > minuend, Vector128< short > left, Vector128< short > right)
 
static Vector128< int > MultiplyRoundedDoublingAndSubtractSaturateHigh (Vector128< int > minuend, Vector128< int > left, Vector128< int > right)
 
static Vector64< shortMultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh (Vector64< short > addend, Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector64< shortMultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh (Vector64< short > addend, Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector64< int > MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh (Vector64< int > addend, Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector64< int > MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh (Vector64< int > addend, Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< shortMultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh (Vector128< short > addend, Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< shortMultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh (Vector128< short > addend, Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< int > MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh (Vector128< int > addend, Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< int > MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh (Vector128< int > addend, Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector64< shortMultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh (Vector64< short > minuend, Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector64< shortMultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh (Vector64< short > minuend, Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector64< int > MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh (Vector64< int > minuend, Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector64< int > MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh (Vector64< int > minuend, Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< shortMultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh (Vector128< short > minuend, Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< shortMultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh (Vector128< short > minuend, Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< int > MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh (Vector128< int > minuend, Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< int > MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh (Vector128< int > minuend, Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector64< ushort > Abs (Vector64< short > value)
 
static Vector64< uint > Abs (Vector64< int > value)
 
static Vector64< byte > Abs (Vector64< sbyte > value)
 
static Vector64< float > Abs (Vector64< float > value)
 
static Vector128< ushort > Abs (Vector128< short > value)
 
static Vector128< uint > Abs (Vector128< int > value)
 
static Vector128< byte > Abs (Vector128< sbyte > value)
 
static Vector128< float > Abs (Vector128< float > value)
 
static Vector64< shortAbsSaturate (Vector64< short > value)
 
static Vector64< int > AbsSaturate (Vector64< int > value)
 
static Vector64< sbyte > AbsSaturate (Vector64< sbyte > value)
 
static Vector128< shortAbsSaturate (Vector128< short > value)
 
static Vector128< int > AbsSaturate (Vector128< int > value)
 
static Vector128< sbyte > AbsSaturate (Vector128< sbyte > value)
 
static Vector64< double > AbsScalar (Vector64< double > value)
 
static Vector64< float > AbsScalar (Vector64< float > value)
 
static Vector64< float > AbsoluteCompareGreaterThan (Vector64< float > left, Vector64< float > right)
 
static Vector128< float > AbsoluteCompareGreaterThan (Vector128< float > left, Vector128< float > right)
 
static Vector64< float > AbsoluteCompareGreaterThanOrEqual (Vector64< float > left, Vector64< float > right)
 
static Vector128< float > AbsoluteCompareGreaterThanOrEqual (Vector128< float > left, Vector128< float > right)
 
static Vector64< float > AbsoluteCompareLessThan (Vector64< float > left, Vector64< float > right)
 
static Vector128< float > AbsoluteCompareLessThan (Vector128< float > left, Vector128< float > right)
 
static Vector64< float > AbsoluteCompareLessThanOrEqual (Vector64< float > left, Vector64< float > right)
 
static Vector128< float > AbsoluteCompareLessThanOrEqual (Vector128< float > left, Vector128< float > right)
 
static Vector64< byte > AbsoluteDifference (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< ushort > AbsoluteDifference (Vector64< short > left, Vector64< short > right)
 
static Vector64< uint > AbsoluteDifference (Vector64< int > left, Vector64< int > right)
 
static Vector64< byte > AbsoluteDifference (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > AbsoluteDifference (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > AbsoluteDifference (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > AbsoluteDifference (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > AbsoluteDifference (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< ushort > AbsoluteDifference (Vector128< short > left, Vector128< short > right)
 
static Vector128< uint > AbsoluteDifference (Vector128< int > left, Vector128< int > right)
 
static Vector128< byte > AbsoluteDifference (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > AbsoluteDifference (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > AbsoluteDifference (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > AbsoluteDifference (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > AbsoluteDifferenceAdd (Vector64< byte > addend, Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortAbsoluteDifferenceAdd (Vector64< short > addend, Vector64< short > left, Vector64< short > right)
 
static Vector64< int > AbsoluteDifferenceAdd (Vector64< int > addend, Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > AbsoluteDifferenceAdd (Vector64< sbyte > addend, Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< ushort > AbsoluteDifferenceAdd (Vector64< ushort > addend, Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > AbsoluteDifferenceAdd (Vector64< uint > addend, Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > AbsoluteDifferenceAdd (Vector128< byte > addend, Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortAbsoluteDifferenceAdd (Vector128< short > addend, Vector128< short > left, Vector128< short > right)
 
static Vector128< int > AbsoluteDifferenceAdd (Vector128< int > addend, Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > AbsoluteDifferenceAdd (Vector128< sbyte > addend, Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > AbsoluteDifferenceAdd (Vector128< ushort > addend, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > AbsoluteDifferenceAdd (Vector128< uint > addend, Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ushort > AbsoluteDifferenceWideningLower (Vector64< byte > left, Vector64< byte > right)
 
static Vector128< uint > AbsoluteDifferenceWideningLower (Vector64< short > left, Vector64< short > right)
 
static Vector128< ulong > AbsoluteDifferenceWideningLower (Vector64< int > left, Vector64< int > right)
 
static Vector128< ushort > AbsoluteDifferenceWideningLower (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector128< uint > AbsoluteDifferenceWideningLower (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector128< ulong > AbsoluteDifferenceWideningLower (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< ushort > AbsoluteDifferenceWideningLowerAndAdd (Vector128< ushort > addend, Vector64< byte > left, Vector64< byte > right)
 
static Vector128< int > AbsoluteDifferenceWideningLowerAndAdd (Vector128< int > addend, Vector64< short > left, Vector64< short > right)
 
static Vector128< long > AbsoluteDifferenceWideningLowerAndAdd (Vector128< long > addend, Vector64< int > left, Vector64< int > right)
 
static Vector128< shortAbsoluteDifferenceWideningLowerAndAdd (Vector128< short > addend, Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector128< uint > AbsoluteDifferenceWideningLowerAndAdd (Vector128< uint > addend, Vector64< ushort > left, Vector64< ushort > right)
 
static Vector128< ulong > AbsoluteDifferenceWideningLowerAndAdd (Vector128< ulong > addend, Vector64< uint > left, Vector64< uint > right)
 
static Vector128< ushort > AbsoluteDifferenceWideningUpper (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< uint > AbsoluteDifferenceWideningUpper (Vector128< short > left, Vector128< short > right)
 
static Vector128< ulong > AbsoluteDifferenceWideningUpper (Vector128< int > left, Vector128< int > right)
 
static Vector128< ushort > AbsoluteDifferenceWideningUpper (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< uint > AbsoluteDifferenceWideningUpper (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< ulong > AbsoluteDifferenceWideningUpper (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ushort > AbsoluteDifferenceWideningUpperAndAdd (Vector128< ushort > addend, Vector128< byte > left, Vector128< byte > right)
 
static Vector128< int > AbsoluteDifferenceWideningUpperAndAdd (Vector128< int > addend, Vector128< short > left, Vector128< short > right)
 
static Vector128< long > AbsoluteDifferenceWideningUpperAndAdd (Vector128< long > addend, Vector128< int > left, Vector128< int > right)
 
static Vector128< shortAbsoluteDifferenceWideningUpperAndAdd (Vector128< short > addend, Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< uint > AbsoluteDifferenceWideningUpperAndAdd (Vector128< uint > addend, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< ulong > AbsoluteDifferenceWideningUpperAndAdd (Vector128< ulong > addend, Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > Add (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortAdd (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > Add (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > Add (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > Add (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > Add (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > Add (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > Add (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortAdd (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > Add (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > Add (Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > Add (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > Add (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > Add (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > Add (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > Add (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< byte > AddHighNarrowingLower (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector64< shortAddHighNarrowingLower (Vector128< int > left, Vector128< int > right)
 
static Vector64< int > AddHighNarrowingLower (Vector128< long > left, Vector128< long > right)
 
static Vector64< sbyte > AddHighNarrowingLower (Vector128< short > left, Vector128< short > right)
 
static Vector64< ushort > AddHighNarrowingLower (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< uint > AddHighNarrowingLower (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector128< byte > AddHighNarrowingUpper (Vector64< byte > lower, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< shortAddHighNarrowingUpper (Vector64< short > lower, Vector128< int > left, Vector128< int > right)
 
static Vector128< int > AddHighNarrowingUpper (Vector64< int > lower, Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > AddHighNarrowingUpper (Vector64< sbyte > lower, Vector128< short > left, Vector128< short > right)
 
static Vector128< ushort > AddHighNarrowingUpper (Vector64< ushort > lower, Vector128< uint > left, Vector128< uint > right)
 
static Vector128< uint > AddHighNarrowingUpper (Vector64< uint > lower, Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< byte > AddPairwise (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortAddPairwise (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > AddPairwise (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > AddPairwise (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > AddPairwise (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > AddPairwise (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > AddPairwise (Vector64< uint > left, Vector64< uint > right)
 
static Vector64< ushort > AddPairwiseWidening (Vector64< byte > value)
 
static Vector64< int > AddPairwiseWidening (Vector64< short > value)
 
static Vector64< shortAddPairwiseWidening (Vector64< sbyte > value)
 
static Vector64< uint > AddPairwiseWidening (Vector64< ushort > value)
 
static Vector128< ushort > AddPairwiseWidening (Vector128< byte > value)
 
static Vector128< int > AddPairwiseWidening (Vector128< short > value)
 
static Vector128< long > AddPairwiseWidening (Vector128< int > value)
 
static Vector128< shortAddPairwiseWidening (Vector128< sbyte > value)
 
static Vector128< uint > AddPairwiseWidening (Vector128< ushort > value)
 
static Vector128< ulong > AddPairwiseWidening (Vector128< uint > value)
 
static Vector64< ushort > AddPairwiseWideningAndAdd (Vector64< ushort > addend, Vector64< byte > value)
 
static Vector64< int > AddPairwiseWideningAndAdd (Vector64< int > addend, Vector64< short > value)
 
static Vector64< shortAddPairwiseWideningAndAdd (Vector64< short > addend, Vector64< sbyte > value)
 
static Vector64< uint > AddPairwiseWideningAndAdd (Vector64< uint > addend, Vector64< ushort > value)
 
static Vector128< ushort > AddPairwiseWideningAndAdd (Vector128< ushort > addend, Vector128< byte > value)
 
static Vector128< int > AddPairwiseWideningAndAdd (Vector128< int > addend, Vector128< short > value)
 
static Vector128< long > AddPairwiseWideningAndAdd (Vector128< long > addend, Vector128< int > value)
 
static Vector128< shortAddPairwiseWideningAndAdd (Vector128< short > addend, Vector128< sbyte > value)
 
static Vector128< uint > AddPairwiseWideningAndAdd (Vector128< uint > addend, Vector128< ushort > value)
 
static Vector128< ulong > AddPairwiseWideningAndAdd (Vector128< ulong > addend, Vector128< uint > value)
 
static Vector64< long > AddPairwiseWideningAndAddScalar (Vector64< long > addend, Vector64< int > value)
 
static Vector64< ulong > AddPairwiseWideningAndAddScalar (Vector64< ulong > addend, Vector64< uint > value)
 
static Vector64< long > AddPairwiseWideningScalar (Vector64< int > value)
 
static Vector64< ulong > AddPairwiseWideningScalar (Vector64< uint > value)
 
static Vector64< byte > AddRoundedHighNarrowingLower (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector64< shortAddRoundedHighNarrowingLower (Vector128< int > left, Vector128< int > right)
 
static Vector64< int > AddRoundedHighNarrowingLower (Vector128< long > left, Vector128< long > right)
 
static Vector64< sbyte > AddRoundedHighNarrowingLower (Vector128< short > left, Vector128< short > right)
 
static Vector64< ushort > AddRoundedHighNarrowingLower (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< uint > AddRoundedHighNarrowingLower (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector128< byte > AddRoundedHighNarrowingUpper (Vector64< byte > lower, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< shortAddRoundedHighNarrowingUpper (Vector64< short > lower, Vector128< int > left, Vector128< int > right)
 
static Vector128< int > AddRoundedHighNarrowingUpper (Vector64< int > lower, Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > AddRoundedHighNarrowingUpper (Vector64< sbyte > lower, Vector128< short > left, Vector128< short > right)
 
static Vector128< ushort > AddRoundedHighNarrowingUpper (Vector64< ushort > lower, Vector128< uint > left, Vector128< uint > right)
 
static Vector128< uint > AddRoundedHighNarrowingUpper (Vector64< uint > lower, Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< byte > AddSaturate (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortAddSaturate (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > AddSaturate (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > AddSaturate (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< ushort > AddSaturate (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > AddSaturate (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > AddSaturate (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortAddSaturate (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > AddSaturate (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > AddSaturate (Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > AddSaturate (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > AddSaturate (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > AddSaturate (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > AddSaturate (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< long > AddSaturateScalar (Vector64< long > left, Vector64< long > right)
 
static Vector64< ulong > AddSaturateScalar (Vector64< ulong > left, Vector64< ulong > right)
 
static Vector64< double > AddScalar (Vector64< double > left, Vector64< double > right)
 
static Vector64< long > AddScalar (Vector64< long > left, Vector64< long > right)
 
static Vector64< float > AddScalar (Vector64< float > left, Vector64< float > right)
 
static Vector64< ulong > AddScalar (Vector64< ulong > left, Vector64< ulong > right)
 
static Vector128< ushort > AddWideningLower (Vector64< byte > left, Vector64< byte > right)
 
static Vector128< int > AddWideningLower (Vector64< short > left, Vector64< short > right)
 
static Vector128< long > AddWideningLower (Vector64< int > left, Vector64< int > right)
 
static Vector128< shortAddWideningLower (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector128< uint > AddWideningLower (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector128< ulong > AddWideningLower (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< shortAddWideningLower (Vector128< short > left, Vector64< sbyte > right)
 
static Vector128< int > AddWideningLower (Vector128< int > left, Vector64< short > right)
 
static Vector128< long > AddWideningLower (Vector128< long > left, Vector64< int > right)
 
static Vector128< ushort > AddWideningLower (Vector128< ushort > left, Vector64< byte > right)
 
static Vector128< uint > AddWideningLower (Vector128< uint > left, Vector64< ushort > right)
 
static Vector128< ulong > AddWideningLower (Vector128< ulong > left, Vector64< uint > right)
 
static Vector128< ushort > AddWideningUpper (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< int > AddWideningUpper (Vector128< short > left, Vector128< short > right)
 
static Vector128< shortAddWideningUpper (Vector128< short > left, Vector128< sbyte > right)
 
static Vector128< int > AddWideningUpper (Vector128< int > left, Vector128< short > right)
 
static Vector128< long > AddWideningUpper (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > AddWideningUpper (Vector128< long > left, Vector128< int > right)
 
static Vector128< shortAddWideningUpper (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > AddWideningUpper (Vector128< ushort > left, Vector128< byte > right)
 
static Vector128< uint > AddWideningUpper (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > AddWideningUpper (Vector128< uint > left, Vector128< ushort > right)
 
static Vector128< ulong > AddWideningUpper (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > AddWideningUpper (Vector128< ulong > left, Vector128< uint > right)
 
static Vector64< byte > And (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< double > And (Vector64< double > left, Vector64< double > right)
 
static Vector64< shortAnd (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > And (Vector64< int > left, Vector64< int > right)
 
static Vector64< long > And (Vector64< long > left, Vector64< long > right)
 
static Vector64< sbyte > And (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > And (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > And (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > And (Vector64< uint > left, Vector64< uint > right)
 
static Vector64< ulong > And (Vector64< ulong > left, Vector64< ulong > right)
 
static Vector128< byte > And (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< double > And (Vector128< double > left, Vector128< double > right)
 
static Vector128< shortAnd (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > And (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > And (Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > And (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > And (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > And (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > And (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > And (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< byte > BitwiseClear (Vector64< byte > value, Vector64< byte > mask)
 
static Vector64< double > BitwiseClear (Vector64< double > value, Vector64< double > mask)
 
static Vector64< shortBitwiseClear (Vector64< short > value, Vector64< short > mask)
 
static Vector64< int > BitwiseClear (Vector64< int > value, Vector64< int > mask)
 
static Vector64< long > BitwiseClear (Vector64< long > value, Vector64< long > mask)
 
static Vector64< sbyte > BitwiseClear (Vector64< sbyte > value, Vector64< sbyte > mask)
 
static Vector64< float > BitwiseClear (Vector64< float > value, Vector64< float > mask)
 
static Vector64< ushort > BitwiseClear (Vector64< ushort > value, Vector64< ushort > mask)
 
static Vector64< uint > BitwiseClear (Vector64< uint > value, Vector64< uint > mask)
 
static Vector64< ulong > BitwiseClear (Vector64< ulong > value, Vector64< ulong > mask)
 
static Vector128< byte > BitwiseClear (Vector128< byte > value, Vector128< byte > mask)
 
static Vector128< double > BitwiseClear (Vector128< double > value, Vector128< double > mask)
 
static Vector128< shortBitwiseClear (Vector128< short > value, Vector128< short > mask)
 
static Vector128< int > BitwiseClear (Vector128< int > value, Vector128< int > mask)
 
static Vector128< long > BitwiseClear (Vector128< long > value, Vector128< long > mask)
 
static Vector128< sbyte > BitwiseClear (Vector128< sbyte > value, Vector128< sbyte > mask)
 
static Vector128< float > BitwiseClear (Vector128< float > value, Vector128< float > mask)
 
static Vector128< ushort > BitwiseClear (Vector128< ushort > value, Vector128< ushort > mask)
 
static Vector128< uint > BitwiseClear (Vector128< uint > value, Vector128< uint > mask)
 
static Vector128< ulong > BitwiseClear (Vector128< ulong > value, Vector128< ulong > mask)
 
static Vector64< byte > BitwiseSelect (Vector64< byte > select, Vector64< byte > left, Vector64< byte > right)
 
static Vector64< double > BitwiseSelect (Vector64< double > select, Vector64< double > left, Vector64< double > right)
 
static Vector64< shortBitwiseSelect (Vector64< short > select, Vector64< short > left, Vector64< short > right)
 
static Vector64< int > BitwiseSelect (Vector64< int > select, Vector64< int > left, Vector64< int > right)
 
static Vector64< long > BitwiseSelect (Vector64< long > select, Vector64< long > left, Vector64< long > right)
 
static Vector64< sbyte > BitwiseSelect (Vector64< sbyte > select, Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > BitwiseSelect (Vector64< float > select, Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > BitwiseSelect (Vector64< ushort > select, Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > BitwiseSelect (Vector64< uint > select, Vector64< uint > left, Vector64< uint > right)
 
static Vector64< ulong > BitwiseSelect (Vector64< ulong > select, Vector64< ulong > left, Vector64< ulong > right)
 
static Vector128< byte > BitwiseSelect (Vector128< byte > select, Vector128< byte > left, Vector128< byte > right)
 
static Vector128< double > BitwiseSelect (Vector128< double > select, Vector128< double > left, Vector128< double > right)
 
static Vector128< shortBitwiseSelect (Vector128< short > select, Vector128< short > left, Vector128< short > right)
 
static Vector128< int > BitwiseSelect (Vector128< int > select, Vector128< int > left, Vector128< int > right)
 
static Vector128< long > BitwiseSelect (Vector128< long > select, Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > BitwiseSelect (Vector128< sbyte > select, Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > BitwiseSelect (Vector128< float > select, Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > BitwiseSelect (Vector128< ushort > select, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > BitwiseSelect (Vector128< uint > select, Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > BitwiseSelect (Vector128< ulong > select, Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< float > Ceiling (Vector64< float > value)
 
static Vector128< float > Ceiling (Vector128< float > value)
 
static Vector64< double > CeilingScalar (Vector64< double > value)
 
static Vector64< float > CeilingScalar (Vector64< float > value)
 
static Vector64< byte > CompareEqual (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortCompareEqual (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > CompareEqual (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > CompareEqual (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > CompareEqual (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > CompareEqual (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > CompareEqual (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > CompareEqual (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortCompareEqual (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > CompareEqual (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > CompareEqual (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > CompareEqual (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > CompareEqual (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > CompareEqual (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > CompareGreaterThan (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortCompareGreaterThan (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > CompareGreaterThan (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > CompareGreaterThan (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > CompareGreaterThan (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > CompareGreaterThan (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > CompareGreaterThan (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > CompareGreaterThan (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortCompareGreaterThan (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > CompareGreaterThan (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > CompareGreaterThan (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > CompareGreaterThan (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > CompareGreaterThan (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > CompareGreaterThan (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > CompareGreaterThanOrEqual (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortCompareGreaterThanOrEqual (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > CompareGreaterThanOrEqual (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > CompareGreaterThanOrEqual (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > CompareGreaterThanOrEqual (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > CompareGreaterThanOrEqual (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > CompareGreaterThanOrEqual (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > CompareGreaterThanOrEqual (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortCompareGreaterThanOrEqual (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > CompareGreaterThanOrEqual (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > CompareGreaterThanOrEqual (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > CompareGreaterThanOrEqual (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > CompareGreaterThanOrEqual (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > CompareGreaterThanOrEqual (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > CompareLessThan (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortCompareLessThan (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > CompareLessThan (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > CompareLessThan (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > CompareLessThan (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > CompareLessThan (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > CompareLessThan (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > CompareLessThan (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortCompareLessThan (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > CompareLessThan (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > CompareLessThan (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > CompareLessThan (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > CompareLessThan (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > CompareLessThan (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > CompareLessThanOrEqual (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortCompareLessThanOrEqual (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > CompareLessThanOrEqual (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > CompareLessThanOrEqual (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > CompareLessThanOrEqual (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > CompareLessThanOrEqual (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > CompareLessThanOrEqual (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > CompareLessThanOrEqual (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortCompareLessThanOrEqual (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > CompareLessThanOrEqual (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > CompareLessThanOrEqual (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > CompareLessThanOrEqual (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > CompareLessThanOrEqual (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > CompareLessThanOrEqual (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > CompareTest (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortCompareTest (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > CompareTest (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > CompareTest (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > CompareTest (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > CompareTest (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > CompareTest (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > CompareTest (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortCompareTest (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > CompareTest (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > CompareTest (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > CompareTest (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > CompareTest (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > CompareTest (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< int > ConvertToInt32RoundAwayFromZero (Vector64< float > value)
 
static Vector128< int > ConvertToInt32RoundAwayFromZero (Vector128< float > value)
 
static Vector64< int > ConvertToInt32RoundAwayFromZeroScalar (Vector64< float > value)
 
static Vector64< int > ConvertToInt32RoundToEven (Vector64< float > value)
 
static Vector128< int > ConvertToInt32RoundToEven (Vector128< float > value)
 
static Vector64< int > ConvertToInt32RoundToEvenScalar (Vector64< float > value)
 
static Vector64< int > ConvertToInt32RoundToNegativeInfinity (Vector64< float > value)
 
static Vector128< int > ConvertToInt32RoundToNegativeInfinity (Vector128< float > value)
 
static Vector64< int > ConvertToInt32RoundToNegativeInfinityScalar (Vector64< float > value)
 
static Vector64< int > ConvertToInt32RoundToPositiveInfinity (Vector64< float > value)
 
static Vector128< int > ConvertToInt32RoundToPositiveInfinity (Vector128< float > value)
 
static Vector64< int > ConvertToInt32RoundToPositiveInfinityScalar (Vector64< float > value)
 
static Vector64< int > ConvertToInt32RoundToZero (Vector64< float > value)
 
static Vector128< int > ConvertToInt32RoundToZero (Vector128< float > value)
 
static Vector64< int > ConvertToInt32RoundToZeroScalar (Vector64< float > value)
 
static Vector64< float > ConvertToSingle (Vector64< int > value)
 
static Vector64< float > ConvertToSingle (Vector64< uint > value)
 
static Vector128< float > ConvertToSingle (Vector128< int > value)
 
static Vector128< float > ConvertToSingle (Vector128< uint > value)
 
static Vector64< float > ConvertToSingleScalar (Vector64< int > value)
 
static Vector64< float > ConvertToSingleScalar (Vector64< uint > value)
 
static Vector64< uint > ConvertToUInt32RoundAwayFromZero (Vector64< float > value)
 
static Vector128< uint > ConvertToUInt32RoundAwayFromZero (Vector128< float > value)
 
static Vector64< uint > ConvertToUInt32RoundAwayFromZeroScalar (Vector64< float > value)
 
static Vector64< uint > ConvertToUInt32RoundToEven (Vector64< float > value)
 
static Vector128< uint > ConvertToUInt32RoundToEven (Vector128< float > value)
 
static Vector64< uint > ConvertToUInt32RoundToEvenScalar (Vector64< float > value)
 
static Vector64< uint > ConvertToUInt32RoundToNegativeInfinity (Vector64< float > value)
 
static Vector128< uint > ConvertToUInt32RoundToNegativeInfinity (Vector128< float > value)
 
static Vector64< uint > ConvertToUInt32RoundToNegativeInfinityScalar (Vector64< float > value)
 
static Vector64< uint > ConvertToUInt32RoundToPositiveInfinity (Vector64< float > value)
 
static Vector128< uint > ConvertToUInt32RoundToPositiveInfinity (Vector128< float > value)
 
static Vector64< uint > ConvertToUInt32RoundToPositiveInfinityScalar (Vector64< float > value)
 
static Vector64< uint > ConvertToUInt32RoundToZero (Vector64< float > value)
 
static Vector128< uint > ConvertToUInt32RoundToZero (Vector128< float > value)
 
static Vector64< uint > ConvertToUInt32RoundToZeroScalar (Vector64< float > value)
 
static Vector64< double > DivideScalar (Vector64< double > left, Vector64< double > right)
 
static Vector64< float > DivideScalar (Vector64< float > left, Vector64< float > right)
 
static Vector64< byte > DuplicateSelectedScalarToVector64 (Vector64< byte > value, byte index)
 
static Vector64< shortDuplicateSelectedScalarToVector64 (Vector64< short > value, byte index)
 
static Vector64< int > DuplicateSelectedScalarToVector64 (Vector64< int > value, byte index)
 
static Vector64< float > DuplicateSelectedScalarToVector64 (Vector64< float > value, byte index)
 
static Vector64< sbyte > DuplicateSelectedScalarToVector64 (Vector64< sbyte > value, byte index)
 
static Vector64< ushort > DuplicateSelectedScalarToVector64 (Vector64< ushort > value, byte index)
 
static Vector64< uint > DuplicateSelectedScalarToVector64 (Vector64< uint > value, byte index)
 
static Vector64< byte > DuplicateSelectedScalarToVector64 (Vector128< byte > value, byte index)
 
static Vector64< shortDuplicateSelectedScalarToVector64 (Vector128< short > value, byte index)
 
static Vector64< int > DuplicateSelectedScalarToVector64 (Vector128< int > value, byte index)
 
static Vector64< float > DuplicateSelectedScalarToVector64 (Vector128< float > value, byte index)
 
static Vector64< sbyte > DuplicateSelectedScalarToVector64 (Vector128< sbyte > value, byte index)
 
static Vector64< ushort > DuplicateSelectedScalarToVector64 (Vector128< ushort > value, byte index)
 
static Vector64< uint > DuplicateSelectedScalarToVector64 (Vector128< uint > value, byte index)
 
static Vector128< byte > DuplicateSelectedScalarToVector128 (Vector64< byte > value, byte index)
 
static Vector128< shortDuplicateSelectedScalarToVector128 (Vector64< short > value, byte index)
 
static Vector128< int > DuplicateSelectedScalarToVector128 (Vector64< int > value, byte index)
 
static Vector128< float > DuplicateSelectedScalarToVector128 (Vector64< float > value, byte index)
 
static Vector128< sbyte > DuplicateSelectedScalarToVector128 (Vector64< sbyte > value, byte index)
 
static Vector128< ushort > DuplicateSelectedScalarToVector128 (Vector64< ushort > value, byte index)
 
static Vector128< uint > DuplicateSelectedScalarToVector128 (Vector64< uint > value, byte index)
 
static Vector128< byte > DuplicateSelectedScalarToVector128 (Vector128< byte > value, byte index)
 
static Vector128< shortDuplicateSelectedScalarToVector128 (Vector128< short > value, byte index)
 
static Vector128< int > DuplicateSelectedScalarToVector128 (Vector128< int > value, byte index)
 
static Vector128< float > DuplicateSelectedScalarToVector128 (Vector128< float > value, byte index)
 
static Vector128< sbyte > DuplicateSelectedScalarToVector128 (Vector128< sbyte > value, byte index)
 
static Vector128< ushort > DuplicateSelectedScalarToVector128 (Vector128< ushort > value, byte index)
 
static Vector128< uint > DuplicateSelectedScalarToVector128 (Vector128< uint > value, byte index)
 
static Vector64< byte > DuplicateToVector64 (byte value)
 
static Vector64< shortDuplicateToVector64 (short value)
 
static Vector64< int > DuplicateToVector64 (int value)
 
static Vector64< sbyte > DuplicateToVector64 (sbyte value)
 
static Vector64< float > DuplicateToVector64 (float value)
 
static Vector64< ushort > DuplicateToVector64 (ushort value)
 
static Vector64< uint > DuplicateToVector64 (uint value)
 
static Vector128< byte > DuplicateToVector128 (byte value)
 
static Vector128< shortDuplicateToVector128 (short value)
 
static Vector128< int > DuplicateToVector128 (int value)
 
static Vector128< sbyte > DuplicateToVector128 (sbyte value)
 
static Vector128< float > DuplicateToVector128 (float value)
 
static Vector128< ushort > DuplicateToVector128 (ushort value)
 
static Vector128< uint > DuplicateToVector128 (uint value)
 
static byte Extract (Vector64< byte > vector, byte index)
 
static short Extract (Vector64< short > vector, byte index)
 
static int Extract (Vector64< int > vector, byte index)
 
static sbyte Extract (Vector64< sbyte > vector, byte index)
 
static float Extract (Vector64< float > vector, byte index)
 
static ushort Extract (Vector64< ushort > vector, byte index)
 
static uint Extract (Vector64< uint > vector, byte index)
 
static byte Extract (Vector128< byte > vector, byte index)
 
static double Extract (Vector128< double > vector, byte index)
 
static short Extract (Vector128< short > vector, byte index)
 
static int Extract (Vector128< int > vector, byte index)
 
static long Extract (Vector128< long > vector, byte index)
 
static sbyte Extract (Vector128< sbyte > vector, byte index)
 
static float Extract (Vector128< float > vector, byte index)
 
static ushort Extract (Vector128< ushort > vector, byte index)
 
static uint Extract (Vector128< uint > vector, byte index)
 
static ulong Extract (Vector128< ulong > vector, byte index)
 
static Vector64< byte > ExtractNarrowingLower (Vector128< ushort > value)
 
static Vector64< shortExtractNarrowingLower (Vector128< int > value)
 
static Vector64< int > ExtractNarrowingLower (Vector128< long > value)
 
static Vector64< sbyte > ExtractNarrowingLower (Vector128< short > value)
 
static Vector64< ushort > ExtractNarrowingLower (Vector128< uint > value)
 
static Vector64< uint > ExtractNarrowingLower (Vector128< ulong > value)
 
static Vector64< byte > ExtractNarrowingSaturateLower (Vector128< ushort > value)
 
static Vector64< shortExtractNarrowingSaturateLower (Vector128< int > value)
 
static Vector64< int > ExtractNarrowingSaturateLower (Vector128< long > value)
 
static Vector64< sbyte > ExtractNarrowingSaturateLower (Vector128< short > value)
 
static Vector64< ushort > ExtractNarrowingSaturateLower (Vector128< uint > value)
 
static Vector64< uint > ExtractNarrowingSaturateLower (Vector128< ulong > value)
 
static Vector64< byte > ExtractNarrowingSaturateUnsignedLower (Vector128< short > value)
 
static Vector64< ushort > ExtractNarrowingSaturateUnsignedLower (Vector128< int > value)
 
static Vector64< uint > ExtractNarrowingSaturateUnsignedLower (Vector128< long > value)
 
static Vector128< byte > ExtractNarrowingSaturateUnsignedUpper (Vector64< byte > lower, Vector128< short > value)
 
static Vector128< ushort > ExtractNarrowingSaturateUnsignedUpper (Vector64< ushort > lower, Vector128< int > value)
 
static Vector128< uint > ExtractNarrowingSaturateUnsignedUpper (Vector64< uint > lower, Vector128< long > value)
 
static Vector128< byte > ExtractNarrowingSaturateUpper (Vector64< byte > lower, Vector128< ushort > value)
 
static Vector128< shortExtractNarrowingSaturateUpper (Vector64< short > lower, Vector128< int > value)
 
static Vector128< int > ExtractNarrowingSaturateUpper (Vector64< int > lower, Vector128< long > value)
 
static Vector128< sbyte > ExtractNarrowingSaturateUpper (Vector64< sbyte > lower, Vector128< short > value)
 
static Vector128< ushort > ExtractNarrowingSaturateUpper (Vector64< ushort > lower, Vector128< uint > value)
 
static Vector128< uint > ExtractNarrowingSaturateUpper (Vector64< uint > lower, Vector128< ulong > value)
 
static Vector128< byte > ExtractNarrowingUpper (Vector64< byte > lower, Vector128< ushort > value)
 
static Vector128< shortExtractNarrowingUpper (Vector64< short > lower, Vector128< int > value)
 
static Vector128< int > ExtractNarrowingUpper (Vector64< int > lower, Vector128< long > value)
 
static Vector128< sbyte > ExtractNarrowingUpper (Vector64< sbyte > lower, Vector128< short > value)
 
static Vector128< ushort > ExtractNarrowingUpper (Vector64< ushort > lower, Vector128< uint > value)
 
static Vector128< uint > ExtractNarrowingUpper (Vector64< uint > lower, Vector128< ulong > value)
 
static Vector64< byte > ExtractVector64 (Vector64< byte > upper, Vector64< byte > lower, byte index)
 
static Vector64< shortExtractVector64 (Vector64< short > upper, Vector64< short > lower, byte index)
 
static Vector64< int > ExtractVector64 (Vector64< int > upper, Vector64< int > lower, byte index)
 
static Vector64< sbyte > ExtractVector64 (Vector64< sbyte > upper, Vector64< sbyte > lower, byte index)
 
static Vector64< float > ExtractVector64 (Vector64< float > upper, Vector64< float > lower, byte index)
 
static Vector64< ushort > ExtractVector64 (Vector64< ushort > upper, Vector64< ushort > lower, byte index)
 
static Vector64< uint > ExtractVector64 (Vector64< uint > upper, Vector64< uint > lower, byte index)
 
static Vector128< byte > ExtractVector128 (Vector128< byte > upper, Vector128< byte > lower, byte index)
 
static Vector128< double > ExtractVector128 (Vector128< double > upper, Vector128< double > lower, byte index)
 
static Vector128< shortExtractVector128 (Vector128< short > upper, Vector128< short > lower, byte index)
 
static Vector128< int > ExtractVector128 (Vector128< int > upper, Vector128< int > lower, byte index)
 
static Vector128< long > ExtractVector128 (Vector128< long > upper, Vector128< long > lower, byte index)
 
static Vector128< sbyte > ExtractVector128 (Vector128< sbyte > upper, Vector128< sbyte > lower, byte index)
 
static Vector128< float > ExtractVector128 (Vector128< float > upper, Vector128< float > lower, byte index)
 
static Vector128< ushort > ExtractVector128 (Vector128< ushort > upper, Vector128< ushort > lower, byte index)
 
static Vector128< uint > ExtractVector128 (Vector128< uint > upper, Vector128< uint > lower, byte index)
 
static Vector128< ulong > ExtractVector128 (Vector128< ulong > upper, Vector128< ulong > lower, byte index)
 
static Vector64< float > Floor (Vector64< float > value)
 
static Vector128< float > Floor (Vector128< float > value)
 
static Vector64< double > FloorScalar (Vector64< double > value)
 
static Vector64< float > FloorScalar (Vector64< float > value)
 
static Vector64< byte > FusedAddHalving (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortFusedAddHalving (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > FusedAddHalving (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > FusedAddHalving (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< ushort > FusedAddHalving (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > FusedAddHalving (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > FusedAddHalving (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortFusedAddHalving (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > FusedAddHalving (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > FusedAddHalving (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > FusedAddHalving (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > FusedAddHalving (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > FusedAddRoundedHalving (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortFusedAddRoundedHalving (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > FusedAddRoundedHalving (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > FusedAddRoundedHalving (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< ushort > FusedAddRoundedHalving (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > FusedAddRoundedHalving (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > FusedAddRoundedHalving (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortFusedAddRoundedHalving (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > FusedAddRoundedHalving (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > FusedAddRoundedHalving (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > FusedAddRoundedHalving (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > FusedAddRoundedHalving (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< float > FusedMultiplyAdd (Vector64< float > addend, Vector64< float > left, Vector64< float > right)
 
static Vector128< float > FusedMultiplyAdd (Vector128< float > addend, Vector128< float > left, Vector128< float > right)
 
static Vector64< double > FusedMultiplyAddNegatedScalar (Vector64< double > addend, Vector64< double > left, Vector64< double > right)
 
static Vector64< float > FusedMultiplyAddNegatedScalar (Vector64< float > addend, Vector64< float > left, Vector64< float > right)
 
static Vector64< double > FusedMultiplyAddScalar (Vector64< double > addend, Vector64< double > left, Vector64< double > right)
 
static Vector64< float > FusedMultiplyAddScalar (Vector64< float > addend, Vector64< float > left, Vector64< float > right)
 
static Vector64< float > FusedMultiplySubtract (Vector64< float > minuend, Vector64< float > left, Vector64< float > right)
 
static Vector128< float > FusedMultiplySubtract (Vector128< float > minuend, Vector128< float > left, Vector128< float > right)
 
static Vector64< double > FusedMultiplySubtractNegatedScalar (Vector64< double > minuend, Vector64< double > left, Vector64< double > right)
 
static Vector64< float > FusedMultiplySubtractNegatedScalar (Vector64< float > minuend, Vector64< float > left, Vector64< float > right)
 
static Vector64< double > FusedMultiplySubtractScalar (Vector64< double > minuend, Vector64< double > left, Vector64< double > right)
 
static Vector64< float > FusedMultiplySubtractScalar (Vector64< float > minuend, Vector64< float > left, Vector64< float > right)
 
static Vector64< byte > FusedSubtractHalving (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortFusedSubtractHalving (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > FusedSubtractHalving (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > FusedSubtractHalving (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< ushort > FusedSubtractHalving (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > FusedSubtractHalving (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > FusedSubtractHalving (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortFusedSubtractHalving (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > FusedSubtractHalving (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > FusedSubtractHalving (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > FusedSubtractHalving (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > FusedSubtractHalving (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > Insert (Vector64< byte > vector, byte index, byte data)
 
static Vector64< shortInsert (Vector64< short > vector, byte index, short data)
 
static Vector64< int > Insert (Vector64< int > vector, byte index, int data)
 
static Vector64< sbyte > Insert (Vector64< sbyte > vector, byte index, sbyte data)
 
static Vector64< float > Insert (Vector64< float > vector, byte index, float data)
 
static Vector64< ushort > Insert (Vector64< ushort > vector, byte index, ushort data)
 
static Vector64< uint > Insert (Vector64< uint > vector, byte index, uint data)
 
static Vector128< byte > Insert (Vector128< byte > vector, byte index, byte data)
 
static Vector128< double > Insert (Vector128< double > vector, byte index, double data)
 
static Vector128< shortInsert (Vector128< short > vector, byte index, short data)
 
static Vector128< int > Insert (Vector128< int > vector, byte index, int data)
 
static Vector128< long > Insert (Vector128< long > vector, byte index, long data)
 
static Vector128< sbyte > Insert (Vector128< sbyte > vector, byte index, sbyte data)
 
static Vector128< float > Insert (Vector128< float > vector, byte index, float data)
 
static Vector128< ushort > Insert (Vector128< ushort > vector, byte index, ushort data)
 
static Vector128< uint > Insert (Vector128< uint > vector, byte index, uint data)
 
static Vector128< ulong > Insert (Vector128< ulong > vector, byte index, ulong data)
 
static Vector128< double > InsertScalar (Vector128< double > result, byte resultIndex, Vector64< double > value)
 
static Vector128< long > InsertScalar (Vector128< long > result, byte resultIndex, Vector64< long > value)
 
static Vector128< ulong > InsertScalar (Vector128< ulong > result, byte resultIndex, Vector64< ulong > value)
 
static Vector64< shortLeadingSignCount (Vector64< short > value)
 
static Vector64< int > LeadingSignCount (Vector64< int > value)
 
static Vector64< sbyte > LeadingSignCount (Vector64< sbyte > value)
 
static Vector128< shortLeadingSignCount (Vector128< short > value)
 
static Vector128< int > LeadingSignCount (Vector128< int > value)
 
static Vector128< sbyte > LeadingSignCount (Vector128< sbyte > value)
 
static Vector64< byte > LeadingZeroCount (Vector64< byte > value)
 
static Vector64< shortLeadingZeroCount (Vector64< short > value)
 
static Vector64< int > LeadingZeroCount (Vector64< int > value)
 
static Vector64< sbyte > LeadingZeroCount (Vector64< sbyte > value)
 
static Vector64< ushort > LeadingZeroCount (Vector64< ushort > value)
 
static Vector64< uint > LeadingZeroCount (Vector64< uint > value)
 
static Vector128< byte > LeadingZeroCount (Vector128< byte > value)
 
static Vector128< shortLeadingZeroCount (Vector128< short > value)
 
static Vector128< int > LeadingZeroCount (Vector128< int > value)
 
static Vector128< sbyte > LeadingZeroCount (Vector128< sbyte > value)
 
static Vector128< ushort > LeadingZeroCount (Vector128< ushort > value)
 
static Vector128< uint > LeadingZeroCount (Vector128< uint > value)
 
static int LeadingZeroCount (int value)
 
static int LeadingZeroCount (uint value)
 
static unsafe Vector64< byte > LoadAndInsertScalar (Vector64< byte > value, byte index, byte *address)
 
static unsafe Vector64< shortLoadAndInsertScalar (Vector64< short > value, byte index, short *address)
 
static unsafe Vector64< int > LoadAndInsertScalar (Vector64< int > value, byte index, int *address)
 
static unsafe Vector64< sbyte > LoadAndInsertScalar (Vector64< sbyte > value, byte index, sbyte *address)
 
static unsafe Vector64< float > LoadAndInsertScalar (Vector64< float > value, byte index, float *address)
 
static unsafe Vector64< ushort > LoadAndInsertScalar (Vector64< ushort > value, byte index, ushort *address)
 
static unsafe Vector64< uint > LoadAndInsertScalar (Vector64< uint > value, byte index, uint *address)
 
static unsafe Vector128< byte > LoadAndInsertScalar (Vector128< byte > value, byte index, byte *address)
 
static unsafe Vector128< double > LoadAndInsertScalar (Vector128< double > value, byte index, double *address)
 
static unsafe Vector128< shortLoadAndInsertScalar (Vector128< short > value, byte index, short *address)
 
static unsafe Vector128< int > LoadAndInsertScalar (Vector128< int > value, byte index, int *address)
 
static unsafe Vector128< long > LoadAndInsertScalar (Vector128< long > value, byte index, long *address)
 
static unsafe Vector128< sbyte > LoadAndInsertScalar (Vector128< sbyte > value, byte index, sbyte *address)
 
static unsafe Vector128< float > LoadAndInsertScalar (Vector128< float > value, byte index, float *address)
 
static unsafe Vector128< ushort > LoadAndInsertScalar (Vector128< ushort > value, byte index, ushort *address)
 
static unsafe Vector128< uint > LoadAndInsertScalar (Vector128< uint > value, byte index, uint *address)
 
static unsafe Vector128< ulong > LoadAndInsertScalar (Vector128< ulong > value, byte index, ulong *address)
 
static unsafe Vector64< byte > LoadAndReplicateToVector64 (byte *address)
 
static unsafe Vector64< shortLoadAndReplicateToVector64 (short *address)
 
static unsafe Vector64< int > LoadAndReplicateToVector64 (int *address)
 
static unsafe Vector64< sbyte > LoadAndReplicateToVector64 (sbyte *address)
 
static unsafe Vector64< float > LoadAndReplicateToVector64 (float *address)
 
static unsafe Vector64< ushort > LoadAndReplicateToVector64 (ushort *address)
 
static unsafe Vector64< uint > LoadAndReplicateToVector64 (uint *address)
 
static unsafe Vector128< byte > LoadAndReplicateToVector128 (byte *address)
 
static unsafe Vector128< shortLoadAndReplicateToVector128 (short *address)
 
static unsafe Vector128< int > LoadAndReplicateToVector128 (int *address)
 
static unsafe Vector128< sbyte > LoadAndReplicateToVector128 (sbyte *address)
 
static unsafe Vector128< float > LoadAndReplicateToVector128 (float *address)
 
static unsafe Vector128< ushort > LoadAndReplicateToVector128 (ushort *address)
 
static unsafe Vector128< uint > LoadAndReplicateToVector128 (uint *address)
 
static unsafe Vector64< byte > LoadVector64 (byte *address)
 
static unsafe Vector64< double > LoadVector64 (double *address)
 
static unsafe Vector64< shortLoadVector64 (short *address)
 
static unsafe Vector64< int > LoadVector64 (int *address)
 
static unsafe Vector64< long > LoadVector64 (long *address)
 
static unsafe Vector64< sbyte > LoadVector64 (sbyte *address)
 
static unsafe Vector64< float > LoadVector64 (float *address)
 
static unsafe Vector64< ushort > LoadVector64 (ushort *address)
 
static unsafe Vector64< uint > LoadVector64 (uint *address)
 
static unsafe Vector64< ulong > LoadVector64 (ulong *address)
 
static unsafe Vector128< byte > LoadVector128 (byte *address)
 
static unsafe Vector128< double > LoadVector128 (double *address)
 
static unsafe Vector128< shortLoadVector128 (short *address)
 
static unsafe Vector128< int > LoadVector128 (int *address)
 
static unsafe Vector128< long > LoadVector128 (long *address)
 
static unsafe Vector128< sbyte > LoadVector128 (sbyte *address)
 
static unsafe Vector128< float > LoadVector128 (float *address)
 
static unsafe Vector128< ushort > LoadVector128 (ushort *address)
 
static unsafe Vector128< uint > LoadVector128 (uint *address)
 
static unsafe Vector128< ulong > LoadVector128 (ulong *address)
 
static Vector64< byte > Max (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortMax (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > Max (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > Max (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > Max (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > Max (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > Max (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > Max (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortMax (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > Max (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > Max (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > Max (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > Max (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > Max (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< float > MaxNumber (Vector64< float > left, Vector64< float > right)
 
static Vector128< float > MaxNumber (Vector128< float > left, Vector128< float > right)
 
static Vector64< double > MaxNumberScalar (Vector64< double > left, Vector64< double > right)
 
static Vector64< float > MaxNumberScalar (Vector64< float > left, Vector64< float > right)
 
static Vector64< byte > MaxPairwise (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortMaxPairwise (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MaxPairwise (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > MaxPairwise (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > MaxPairwise (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > MaxPairwise (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > MaxPairwise (Vector64< uint > left, Vector64< uint > right)
 
static Vector64< byte > Min (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortMin (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > Min (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > Min (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > Min (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > Min (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > Min (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > Min (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortMin (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > Min (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > Min (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > Min (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > Min (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > Min (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< float > MinNumber (Vector64< float > left, Vector64< float > right)
 
static Vector128< float > MinNumber (Vector128< float > left, Vector128< float > right)
 
static Vector64< double > MinNumberScalar (Vector64< double > left, Vector64< double > right)
 
static Vector64< float > MinNumberScalar (Vector64< float > left, Vector64< float > right)
 
static Vector64< byte > MinPairwise (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortMinPairwise (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MinPairwise (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > MinPairwise (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > MinPairwise (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > MinPairwise (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > MinPairwise (Vector64< uint > left, Vector64< uint > right)
 
static Vector64< byte > Multiply (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortMultiply (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > Multiply (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > Multiply (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > Multiply (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > Multiply (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > Multiply (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > Multiply (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortMultiply (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > Multiply (Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > Multiply (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > Multiply (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > Multiply (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > Multiply (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< byte > MultiplyAdd (Vector64< byte > addend, Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortMultiplyAdd (Vector64< short > addend, Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplyAdd (Vector64< int > addend, Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > MultiplyAdd (Vector64< sbyte > addend, Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< ushort > MultiplyAdd (Vector64< ushort > addend, Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > MultiplyAdd (Vector64< uint > addend, Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > MultiplyAdd (Vector128< byte > addend, Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortMultiplyAdd (Vector128< short > addend, Vector128< short > left, Vector128< short > right)
 
static Vector128< int > MultiplyAdd (Vector128< int > addend, Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > MultiplyAdd (Vector128< sbyte > addend, Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > MultiplyAdd (Vector128< ushort > addend, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > MultiplyAdd (Vector128< uint > addend, Vector128< uint > left, Vector128< uint > right)
 
static Vector64< shortMultiplyAddByScalar (Vector64< short > addend, Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplyAddByScalar (Vector64< int > addend, Vector64< int > left, Vector64< int > right)
 
static Vector64< ushort > MultiplyAddByScalar (Vector64< ushort > addend, Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > MultiplyAddByScalar (Vector64< uint > addend, Vector64< uint > left, Vector64< uint > right)
 
static Vector128< shortMultiplyAddByScalar (Vector128< short > addend, Vector128< short > left, Vector64< short > right)
 
static Vector128< int > MultiplyAddByScalar (Vector128< int > addend, Vector128< int > left, Vector64< int > right)
 
static Vector128< ushort > MultiplyAddByScalar (Vector128< ushort > addend, Vector128< ushort > left, Vector64< ushort > right)
 
static Vector128< uint > MultiplyAddByScalar (Vector128< uint > addend, Vector128< uint > left, Vector64< uint > right)
 
static Vector64< shortMultiplyAddBySelectedScalar (Vector64< short > addend, Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector64< shortMultiplyAddBySelectedScalar (Vector64< short > addend, Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector64< int > MultiplyAddBySelectedScalar (Vector64< int > addend, Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector64< int > MultiplyAddBySelectedScalar (Vector64< int > addend, Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector64< ushort > MultiplyAddBySelectedScalar (Vector64< ushort > addend, Vector64< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector64< ushort > MultiplyAddBySelectedScalar (Vector64< ushort > addend, Vector64< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector64< uint > MultiplyAddBySelectedScalar (Vector64< uint > addend, Vector64< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector64< uint > MultiplyAddBySelectedScalar (Vector64< uint > addend, Vector64< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< shortMultiplyAddBySelectedScalar (Vector128< short > addend, Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< shortMultiplyAddBySelectedScalar (Vector128< short > addend, Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< int > MultiplyAddBySelectedScalar (Vector128< int > addend, Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< int > MultiplyAddBySelectedScalar (Vector128< int > addend, Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< ushort > MultiplyAddBySelectedScalar (Vector128< ushort > addend, Vector128< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector128< ushort > MultiplyAddBySelectedScalar (Vector128< ushort > addend, Vector128< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector128< uint > MultiplyAddBySelectedScalar (Vector128< uint > addend, Vector128< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector128< uint > MultiplyAddBySelectedScalar (Vector128< uint > addend, Vector128< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector64< shortMultiplyByScalar (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplyByScalar (Vector64< int > left, Vector64< int > right)
 
static Vector64< float > MultiplyByScalar (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > MultiplyByScalar (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > MultiplyByScalar (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< shortMultiplyByScalar (Vector128< short > left, Vector64< short > right)
 
static Vector128< int > MultiplyByScalar (Vector128< int > left, Vector64< int > right)
 
static Vector128< float > MultiplyByScalar (Vector128< float > left, Vector64< float > right)
 
static Vector128< ushort > MultiplyByScalar (Vector128< ushort > left, Vector64< ushort > right)
 
static Vector128< uint > MultiplyByScalar (Vector128< uint > left, Vector64< uint > right)
 
static Vector64< shortMultiplyBySelectedScalar (Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector64< shortMultiplyBySelectedScalar (Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector64< int > MultiplyBySelectedScalar (Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector64< int > MultiplyBySelectedScalar (Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector64< float > MultiplyBySelectedScalar (Vector64< float > left, Vector64< float > right, byte rightIndex)
 
static Vector64< float > MultiplyBySelectedScalar (Vector64< float > left, Vector128< float > right, byte rightIndex)
 
static Vector64< ushort > MultiplyBySelectedScalar (Vector64< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector64< ushort > MultiplyBySelectedScalar (Vector64< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector64< uint > MultiplyBySelectedScalar (Vector64< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector64< uint > MultiplyBySelectedScalar (Vector64< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< shortMultiplyBySelectedScalar (Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< shortMultiplyBySelectedScalar (Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalar (Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalar (Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< float > MultiplyBySelectedScalar (Vector128< float > left, Vector64< float > right, byte rightIndex)
 
static Vector128< float > MultiplyBySelectedScalar (Vector128< float > left, Vector128< float > right, byte rightIndex)
 
static Vector128< ushort > MultiplyBySelectedScalar (Vector128< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector128< ushort > MultiplyBySelectedScalar (Vector128< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalar (Vector128< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalar (Vector128< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningLower (Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningLower (Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningLower (Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningLower (Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningLower (Vector64< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningLower (Vector64< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningLower (Vector64< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningLower (Vector64< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningLowerAndAdd (Vector128< int > addend, Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningLowerAndAdd (Vector128< int > addend, Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningLowerAndAdd (Vector128< long > addend, Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningLowerAndAdd (Vector128< long > addend, Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningLowerAndAdd (Vector128< uint > addend, Vector64< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningLowerAndAdd (Vector128< uint > addend, Vector64< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningLowerAndAdd (Vector128< ulong > addend, Vector64< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningLowerAndAdd (Vector128< ulong > addend, Vector64< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningLowerAndSubtract (Vector128< int > minuend, Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningLowerAndSubtract (Vector128< int > minuend, Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningLowerAndSubtract (Vector128< long > minuend, Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningLowerAndSubtract (Vector128< long > minuend, Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningLowerAndSubtract (Vector128< uint > minuend, Vector64< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningLowerAndSubtract (Vector128< uint > minuend, Vector64< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningLowerAndSubtract (Vector128< ulong > minuend, Vector64< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningLowerAndSubtract (Vector128< ulong > minuend, Vector64< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningUpper (Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningUpper (Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningUpper (Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningUpper (Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningUpper (Vector128< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningUpper (Vector128< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningUpper (Vector128< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningUpper (Vector128< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningUpperAndAdd (Vector128< int > addend, Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningUpperAndAdd (Vector128< int > addend, Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningUpperAndAdd (Vector128< long > addend, Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningUpperAndAdd (Vector128< long > addend, Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningUpperAndAdd (Vector128< uint > addend, Vector128< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningUpperAndAdd (Vector128< uint > addend, Vector128< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningUpperAndAdd (Vector128< ulong > addend, Vector128< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningUpperAndAdd (Vector128< ulong > addend, Vector128< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningUpperAndSubtract (Vector128< int > minuend, Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyBySelectedScalarWideningUpperAndSubtract (Vector128< int > minuend, Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningUpperAndSubtract (Vector128< long > minuend, Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyBySelectedScalarWideningUpperAndSubtract (Vector128< long > minuend, Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningUpperAndSubtract (Vector128< uint > minuend, Vector128< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector128< uint > MultiplyBySelectedScalarWideningUpperAndSubtract (Vector128< uint > minuend, Vector128< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningUpperAndSubtract (Vector128< ulong > minuend, Vector128< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector128< ulong > MultiplyBySelectedScalarWideningUpperAndSubtract (Vector128< ulong > minuend, Vector128< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector64< shortMultiplyDoublingByScalarSaturateHigh (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplyDoublingByScalarSaturateHigh (Vector64< int > left, Vector64< int > right)
 
static Vector128< shortMultiplyDoublingByScalarSaturateHigh (Vector128< short > left, Vector64< short > right)
 
static Vector128< int > MultiplyDoublingByScalarSaturateHigh (Vector128< int > left, Vector64< int > right)
 
static Vector64< shortMultiplyDoublingBySelectedScalarSaturateHigh (Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector64< shortMultiplyDoublingBySelectedScalarSaturateHigh (Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector64< int > MultiplyDoublingBySelectedScalarSaturateHigh (Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector64< int > MultiplyDoublingBySelectedScalarSaturateHigh (Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< shortMultiplyDoublingBySelectedScalarSaturateHigh (Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< shortMultiplyDoublingBySelectedScalarSaturateHigh (Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingBySelectedScalarSaturateHigh (Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingBySelectedScalarSaturateHigh (Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector64< shortMultiplyDoublingSaturateHigh (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplyDoublingSaturateHigh (Vector64< int > left, Vector64< int > right)
 
static Vector128< shortMultiplyDoublingSaturateHigh (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > MultiplyDoublingSaturateHigh (Vector128< int > left, Vector128< int > right)
 
static Vector128< int > MultiplyDoublingWideningLowerAndAddSaturate (Vector128< int > addend, Vector64< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyDoublingWideningLowerAndAddSaturate (Vector128< long > addend, Vector64< int > left, Vector64< int > right)
 
static Vector128< int > MultiplyDoublingWideningLowerAndSubtractSaturate (Vector128< int > minuend, Vector64< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyDoublingWideningLowerAndSubtractSaturate (Vector128< long > minuend, Vector64< int > left, Vector64< int > right)
 
static Vector128< int > MultiplyDoublingWideningLowerByScalarAndAddSaturate (Vector128< int > addend, Vector64< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyDoublingWideningLowerByScalarAndAddSaturate (Vector128< long > addend, Vector64< int > left, Vector64< int > right)
 
static Vector128< int > MultiplyDoublingWideningLowerByScalarAndSubtractSaturate (Vector128< int > minuend, Vector64< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyDoublingWideningLowerByScalarAndSubtractSaturate (Vector128< long > minuend, Vector64< int > left, Vector64< int > right)
 
static Vector128< int > MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate (Vector128< int > addend, Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate (Vector128< int > addend, Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate (Vector128< long > addend, Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate (Vector128< long > addend, Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate (Vector128< int > minuend, Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate (Vector128< int > minuend, Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate (Vector128< long > minuend, Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate (Vector128< long > minuend, Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningSaturateLower (Vector64< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyDoublingWideningSaturateLower (Vector64< int > left, Vector64< int > right)
 
static Vector128< int > MultiplyDoublingWideningSaturateLowerByScalar (Vector64< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyDoublingWideningSaturateLowerByScalar (Vector64< int > left, Vector64< int > right)
 
static Vector128< int > MultiplyDoublingWideningSaturateLowerBySelectedScalar (Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningSaturateLowerBySelectedScalar (Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningSaturateLowerBySelectedScalar (Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningSaturateLowerBySelectedScalar (Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningSaturateUpper (Vector128< short > left, Vector128< short > right)
 
static Vector128< long > MultiplyDoublingWideningSaturateUpper (Vector128< int > left, Vector128< int > right)
 
static Vector128< int > MultiplyDoublingWideningSaturateUpperByScalar (Vector128< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyDoublingWideningSaturateUpperByScalar (Vector128< int > left, Vector64< int > right)
 
static Vector128< int > MultiplyDoublingWideningSaturateUpperBySelectedScalar (Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningSaturateUpperBySelectedScalar (Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningSaturateUpperBySelectedScalar (Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningSaturateUpperBySelectedScalar (Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningUpperAndAddSaturate (Vector128< int > addend, Vector128< short > left, Vector128< short > right)
 
static Vector128< long > MultiplyDoublingWideningUpperAndAddSaturate (Vector128< long > addend, Vector128< int > left, Vector128< int > right)
 
static Vector128< int > MultiplyDoublingWideningUpperAndSubtractSaturate (Vector128< int > minuend, Vector128< short > left, Vector128< short > right)
 
static Vector128< long > MultiplyDoublingWideningUpperAndSubtractSaturate (Vector128< long > minuend, Vector128< int > left, Vector128< int > right)
 
static Vector128< int > MultiplyDoublingWideningUpperByScalarAndAddSaturate (Vector128< int > addend, Vector128< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyDoublingWideningUpperByScalarAndAddSaturate (Vector128< long > addend, Vector128< int > left, Vector64< int > right)
 
static Vector128< int > MultiplyDoublingWideningUpperByScalarAndSubtractSaturate (Vector128< int > minuend, Vector128< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyDoublingWideningUpperByScalarAndSubtractSaturate (Vector128< long > minuend, Vector128< int > left, Vector64< int > right)
 
static Vector128< int > MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate (Vector128< int > addend, Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate (Vector128< int > addend, Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate (Vector128< long > addend, Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate (Vector128< long > addend, Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate (Vector128< int > minuend, Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< int > MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate (Vector128< int > minuend, Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate (Vector128< long > minuend, Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< long > MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate (Vector128< long > minuend, Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector64< shortMultiplyRoundedDoublingByScalarSaturateHigh (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplyRoundedDoublingByScalarSaturateHigh (Vector64< int > left, Vector64< int > right)
 
static Vector128< shortMultiplyRoundedDoublingByScalarSaturateHigh (Vector128< short > left, Vector64< short > right)
 
static Vector128< int > MultiplyRoundedDoublingByScalarSaturateHigh (Vector128< int > left, Vector64< int > right)
 
static Vector64< shortMultiplyRoundedDoublingBySelectedScalarSaturateHigh (Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector64< shortMultiplyRoundedDoublingBySelectedScalarSaturateHigh (Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector64< int > MultiplyRoundedDoublingBySelectedScalarSaturateHigh (Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector64< int > MultiplyRoundedDoublingBySelectedScalarSaturateHigh (Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< shortMultiplyRoundedDoublingBySelectedScalarSaturateHigh (Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< shortMultiplyRoundedDoublingBySelectedScalarSaturateHigh (Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< int > MultiplyRoundedDoublingBySelectedScalarSaturateHigh (Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< int > MultiplyRoundedDoublingBySelectedScalarSaturateHigh (Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector64< shortMultiplyRoundedDoublingSaturateHigh (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplyRoundedDoublingSaturateHigh (Vector64< int > left, Vector64< int > right)
 
static Vector128< shortMultiplyRoundedDoublingSaturateHigh (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > MultiplyRoundedDoublingSaturateHigh (Vector128< int > left, Vector128< int > right)
 
static Vector64< double > MultiplyScalar (Vector64< double > left, Vector64< double > right)
 
static Vector64< float > MultiplyScalar (Vector64< float > left, Vector64< float > right)
 
static Vector64< float > MultiplyScalarBySelectedScalar (Vector64< float > left, Vector64< float > right, byte rightIndex)
 
static Vector64< float > MultiplyScalarBySelectedScalar (Vector64< float > left, Vector128< float > right, byte rightIndex)
 
static Vector64< byte > MultiplySubtract (Vector64< byte > minuend, Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortMultiplySubtract (Vector64< short > minuend, Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplySubtract (Vector64< int > minuend, Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > MultiplySubtract (Vector64< sbyte > minuend, Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< ushort > MultiplySubtract (Vector64< ushort > minuend, Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > MultiplySubtract (Vector64< uint > minuend, Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > MultiplySubtract (Vector128< byte > minuend, Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortMultiplySubtract (Vector128< short > minuend, Vector128< short > left, Vector128< short > right)
 
static Vector128< int > MultiplySubtract (Vector128< int > minuend, Vector128< int > left, Vector128< int > right)
 
static Vector128< sbyte > MultiplySubtract (Vector128< sbyte > minuend, Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > MultiplySubtract (Vector128< ushort > minuend, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > MultiplySubtract (Vector128< uint > minuend, Vector128< uint > left, Vector128< uint > right)
 
static Vector64< shortMultiplySubtractByScalar (Vector64< short > minuend, Vector64< short > left, Vector64< short > right)
 
static Vector64< int > MultiplySubtractByScalar (Vector64< int > minuend, Vector64< int > left, Vector64< int > right)
 
static Vector64< ushort > MultiplySubtractByScalar (Vector64< ushort > minuend, Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > MultiplySubtractByScalar (Vector64< uint > minuend, Vector64< uint > left, Vector64< uint > right)
 
static Vector128< shortMultiplySubtractByScalar (Vector128< short > minuend, Vector128< short > left, Vector64< short > right)
 
static Vector128< int > MultiplySubtractByScalar (Vector128< int > minuend, Vector128< int > left, Vector64< int > right)
 
static Vector128< ushort > MultiplySubtractByScalar (Vector128< ushort > minuend, Vector128< ushort > left, Vector64< ushort > right)
 
static Vector128< uint > MultiplySubtractByScalar (Vector128< uint > minuend, Vector128< uint > left, Vector64< uint > right)
 
static Vector64< shortMultiplySubtractBySelectedScalar (Vector64< short > minuend, Vector64< short > left, Vector64< short > right, byte rightIndex)
 
static Vector64< shortMultiplySubtractBySelectedScalar (Vector64< short > minuend, Vector64< short > left, Vector128< short > right, byte rightIndex)
 
static Vector64< int > MultiplySubtractBySelectedScalar (Vector64< int > minuend, Vector64< int > left, Vector64< int > right, byte rightIndex)
 
static Vector64< int > MultiplySubtractBySelectedScalar (Vector64< int > minuend, Vector64< int > left, Vector128< int > right, byte rightIndex)
 
static Vector64< ushort > MultiplySubtractBySelectedScalar (Vector64< ushort > minuend, Vector64< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector64< ushort > MultiplySubtractBySelectedScalar (Vector64< ushort > minuend, Vector64< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector64< uint > MultiplySubtractBySelectedScalar (Vector64< uint > minuend, Vector64< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector64< uint > MultiplySubtractBySelectedScalar (Vector64< uint > minuend, Vector64< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< shortMultiplySubtractBySelectedScalar (Vector128< short > minuend, Vector128< short > left, Vector64< short > right, byte rightIndex)
 
static Vector128< shortMultiplySubtractBySelectedScalar (Vector128< short > minuend, Vector128< short > left, Vector128< short > right, byte rightIndex)
 
static Vector128< int > MultiplySubtractBySelectedScalar (Vector128< int > minuend, Vector128< int > left, Vector64< int > right, byte rightIndex)
 
static Vector128< int > MultiplySubtractBySelectedScalar (Vector128< int > minuend, Vector128< int > left, Vector128< int > right, byte rightIndex)
 
static Vector128< ushort > MultiplySubtractBySelectedScalar (Vector128< ushort > minuend, Vector128< ushort > left, Vector64< ushort > right, byte rightIndex)
 
static Vector128< ushort > MultiplySubtractBySelectedScalar (Vector128< ushort > minuend, Vector128< ushort > left, Vector128< ushort > right, byte rightIndex)
 
static Vector128< uint > MultiplySubtractBySelectedScalar (Vector128< uint > minuend, Vector128< uint > left, Vector64< uint > right, byte rightIndex)
 
static Vector128< uint > MultiplySubtractBySelectedScalar (Vector128< uint > minuend, Vector128< uint > left, Vector128< uint > right, byte rightIndex)
 
static Vector128< ushort > MultiplyWideningLower (Vector64< byte > left, Vector64< byte > right)
 
static Vector128< int > MultiplyWideningLower (Vector64< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyWideningLower (Vector64< int > left, Vector64< int > right)
 
static Vector128< shortMultiplyWideningLower (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector128< uint > MultiplyWideningLower (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector128< ulong > MultiplyWideningLower (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< ushort > MultiplyWideningLowerAndAdd (Vector128< ushort > addend, Vector64< byte > left, Vector64< byte > right)
 
static Vector128< int > MultiplyWideningLowerAndAdd (Vector128< int > addend, Vector64< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyWideningLowerAndAdd (Vector128< long > addend, Vector64< int > left, Vector64< int > right)
 
static Vector128< shortMultiplyWideningLowerAndAdd (Vector128< short > addend, Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector128< uint > MultiplyWideningLowerAndAdd (Vector128< uint > addend, Vector64< ushort > left, Vector64< ushort > right)
 
static Vector128< ulong > MultiplyWideningLowerAndAdd (Vector128< ulong > addend, Vector64< uint > left, Vector64< uint > right)
 
static Vector128< ushort > MultiplyWideningLowerAndSubtract (Vector128< ushort > minuend, Vector64< byte > left, Vector64< byte > right)
 
static Vector128< int > MultiplyWideningLowerAndSubtract (Vector128< int > minuend, Vector64< short > left, Vector64< short > right)
 
static Vector128< long > MultiplyWideningLowerAndSubtract (Vector128< long > minuend, Vector64< int > left, Vector64< int > right)
 
static Vector128< shortMultiplyWideningLowerAndSubtract (Vector128< short > minuend, Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector128< uint > MultiplyWideningLowerAndSubtract (Vector128< uint > minuend, Vector64< ushort > left, Vector64< ushort > right)
 
static Vector128< ulong > MultiplyWideningLowerAndSubtract (Vector128< ulong > minuend, Vector64< uint > left, Vector64< uint > right)
 
static Vector128< ushort > MultiplyWideningUpper (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< int > MultiplyWideningUpper (Vector128< short > left, Vector128< short > right)
 
static Vector128< long > MultiplyWideningUpper (Vector128< int > left, Vector128< int > right)
 
static Vector128< shortMultiplyWideningUpper (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< uint > MultiplyWideningUpper (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< ulong > MultiplyWideningUpper (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ushort > MultiplyWideningUpperAndAdd (Vector128< ushort > addend, Vector128< byte > left, Vector128< byte > right)
 
static Vector128< int > MultiplyWideningUpperAndAdd (Vector128< int > addend, Vector128< short > left, Vector128< short > right)
 
static Vector128< long > MultiplyWideningUpperAndAdd (Vector128< long > addend, Vector128< int > left, Vector128< int > right)
 
static Vector128< shortMultiplyWideningUpperAndAdd (Vector128< short > addend, Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< uint > MultiplyWideningUpperAndAdd (Vector128< uint > addend, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< ulong > MultiplyWideningUpperAndAdd (Vector128< ulong > addend, Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ushort > MultiplyWideningUpperAndSubtract (Vector128< ushort > minuend, Vector128< byte > left, Vector128< byte > right)
 
static Vector128< int > MultiplyWideningUpperAndSubtract (Vector128< int > minuend, Vector128< short > left, Vector128< short > right)
 
static Vector128< long > MultiplyWideningUpperAndSubtract (Vector128< long > minuend, Vector128< int > left, Vector128< int > right)
 
static Vector128< shortMultiplyWideningUpperAndSubtract (Vector128< short > minuend, Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< uint > MultiplyWideningUpperAndSubtract (Vector128< uint > minuend, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< ulong > MultiplyWideningUpperAndSubtract (Vector128< ulong > minuend, Vector128< uint > left, Vector128< uint > right)
 
static Vector64< shortNegate (Vector64< short > value)
 
static Vector64< int > Negate (Vector64< int > value)
 
static Vector64< sbyte > Negate (Vector64< sbyte > value)
 
static Vector64< float > Negate (Vector64< float > value)
 
static Vector128< shortNegate (Vector128< short > value)
 
static Vector128< int > Negate (Vector128< int > value)
 
static Vector128< sbyte > Negate (Vector128< sbyte > value)
 
static Vector128< float > Negate (Vector128< float > value)
 
static Vector64< shortNegateSaturate (Vector64< short > value)
 
static Vector64< int > NegateSaturate (Vector64< int > value)
 
static Vector64< sbyte > NegateSaturate (Vector64< sbyte > value)
 
static Vector128< shortNegateSaturate (Vector128< short > value)
 
static Vector128< int > NegateSaturate (Vector128< int > value)
 
static Vector128< sbyte > NegateSaturate (Vector128< sbyte > value)
 
static Vector64< double > NegateScalar (Vector64< double > value)
 
static Vector64< float > NegateScalar (Vector64< float > value)
 
static Vector64< byte > Not (Vector64< byte > value)
 
static Vector64< double > Not (Vector64< double > value)
 
static Vector64< shortNot (Vector64< short > value)
 
static Vector64< int > Not (Vector64< int > value)
 
static Vector64< long > Not (Vector64< long > value)
 
static Vector64< sbyte > Not (Vector64< sbyte > value)
 
static Vector64< float > Not (Vector64< float > value)
 
static Vector64< ushort > Not (Vector64< ushort > value)
 
static Vector64< uint > Not (Vector64< uint > value)
 
static Vector64< ulong > Not (Vector64< ulong > value)
 
static Vector128< byte > Not (Vector128< byte > value)
 
static Vector128< double > Not (Vector128< double > value)
 
static Vector128< shortNot (Vector128< short > value)
 
static Vector128< int > Not (Vector128< int > value)
 
static Vector128< long > Not (Vector128< long > value)
 
static Vector128< sbyte > Not (Vector128< sbyte > value)
 
static Vector128< float > Not (Vector128< float > value)
 
static Vector128< ushort > Not (Vector128< ushort > value)
 
static Vector128< uint > Not (Vector128< uint > value)
 
static Vector128< ulong > Not (Vector128< ulong > value)
 
static Vector64< byte > Or (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< double > Or (Vector64< double > left, Vector64< double > right)
 
static Vector64< shortOr (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > Or (Vector64< int > left, Vector64< int > right)
 
static Vector64< long > Or (Vector64< long > left, Vector64< long > right)
 
static Vector64< sbyte > Or (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > Or (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > Or (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > Or (Vector64< uint > left, Vector64< uint > right)
 
static Vector64< ulong > Or (Vector64< ulong > left, Vector64< ulong > right)
 
static Vector128< byte > Or (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< double > Or (Vector128< double > left, Vector128< double > right)
 
static Vector128< shortOr (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > Or (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > Or (Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > Or (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > Or (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > Or (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > Or (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > Or (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< byte > OrNot (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< double > OrNot (Vector64< double > left, Vector64< double > right)
 
static Vector64< shortOrNot (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > OrNot (Vector64< int > left, Vector64< int > right)
 
static Vector64< long > OrNot (Vector64< long > left, Vector64< long > right)
 
static Vector64< sbyte > OrNot (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > OrNot (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > OrNot (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > OrNot (Vector64< uint > left, Vector64< uint > right)
 
static Vector64< ulong > OrNot (Vector64< ulong > left, Vector64< ulong > right)
 
static Vector128< byte > OrNot (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< double > OrNot (Vector128< double > left, Vector128< double > right)
 
static Vector128< shortOrNot (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > OrNot (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > OrNot (Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > OrNot (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > OrNot (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > OrNot (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > OrNot (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > OrNot (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< byte > PolynomialMultiply (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< sbyte > PolynomialMultiply (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector128< byte > PolynomialMultiply (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< sbyte > PolynomialMultiply (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > PolynomialMultiplyWideningLower (Vector64< byte > left, Vector64< byte > right)
 
static Vector128< shortPolynomialMultiplyWideningLower (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector128< ushort > PolynomialMultiplyWideningUpper (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortPolynomialMultiplyWideningUpper (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector64< byte > PopCount (Vector64< byte > value)
 
static Vector64< sbyte > PopCount (Vector64< sbyte > value)
 
static Vector128< byte > PopCount (Vector128< byte > value)
 
static Vector128< sbyte > PopCount (Vector128< sbyte > value)
 
static Vector64< float > ReciprocalEstimate (Vector64< float > value)
 
static Vector64< uint > ReciprocalEstimate (Vector64< uint > value)
 
static Vector128< float > ReciprocalEstimate (Vector128< float > value)
 
static Vector128< uint > ReciprocalEstimate (Vector128< uint > value)
 
static Vector64< float > ReciprocalSquareRootEstimate (Vector64< float > value)
 
static Vector64< uint > ReciprocalSquareRootEstimate (Vector64< uint > value)
 
static Vector128< float > ReciprocalSquareRootEstimate (Vector128< float > value)
 
static Vector128< uint > ReciprocalSquareRootEstimate (Vector128< uint > value)
 
static Vector64< float > ReciprocalSquareRootStep (Vector64< float > left, Vector64< float > right)
 
static Vector128< float > ReciprocalSquareRootStep (Vector128< float > left, Vector128< float > right)
 
static Vector64< float > ReciprocalStep (Vector64< float > left, Vector64< float > right)
 
static Vector128< float > ReciprocalStep (Vector128< float > left, Vector128< float > right)
 
static Vector64< int > ReverseElement16 (Vector64< int > value)
 
static Vector64< long > ReverseElement16 (Vector64< long > value)
 
static Vector64< uint > ReverseElement16 (Vector64< uint > value)
 
static Vector64< ulong > ReverseElement16 (Vector64< ulong > value)
 
static Vector128< int > ReverseElement16 (Vector128< int > value)
 
static Vector128< long > ReverseElement16 (Vector128< long > value)
 
static Vector128< uint > ReverseElement16 (Vector128< uint > value)
 
static Vector128< ulong > ReverseElement16 (Vector128< ulong > value)
 
static Vector64< long > ReverseElement32 (Vector64< long > value)
 
static Vector64< ulong > ReverseElement32 (Vector64< ulong > value)
 
static Vector128< long > ReverseElement32 (Vector128< long > value)
 
static Vector128< ulong > ReverseElement32 (Vector128< ulong > value)
 
static Vector64< shortReverseElement8 (Vector64< short > value)
 
static Vector64< int > ReverseElement8 (Vector64< int > value)
 
static Vector64< long > ReverseElement8 (Vector64< long > value)
 
static Vector64< ushort > ReverseElement8 (Vector64< ushort > value)
 
static Vector64< uint > ReverseElement8 (Vector64< uint > value)
 
static Vector64< ulong > ReverseElement8 (Vector64< ulong > value)
 
static Vector128< shortReverseElement8 (Vector128< short > value)
 
static Vector128< int > ReverseElement8 (Vector128< int > value)
 
static Vector128< long > ReverseElement8 (Vector128< long > value)
 
static Vector128< ushort > ReverseElement8 (Vector128< ushort > value)
 
static Vector128< uint > ReverseElement8 (Vector128< uint > value)
 
static Vector128< ulong > ReverseElement8 (Vector128< ulong > value)
 
static Vector64< float > RoundAwayFromZero (Vector64< float > value)
 
static Vector128< float > RoundAwayFromZero (Vector128< float > value)
 
static Vector64< double > RoundAwayFromZeroScalar (Vector64< double > value)
 
static Vector64< float > RoundAwayFromZeroScalar (Vector64< float > value)
 
static Vector64< float > RoundToNearest (Vector64< float > value)
 
static Vector128< float > RoundToNearest (Vector128< float > value)
 
static Vector64< double > RoundToNearestScalar (Vector64< double > value)
 
static Vector64< float > RoundToNearestScalar (Vector64< float > value)
 
static Vector64< float > RoundToNegativeInfinity (Vector64< float > value)
 
static Vector128< float > RoundToNegativeInfinity (Vector128< float > value)
 
static Vector64< double > RoundToNegativeInfinityScalar (Vector64< double > value)
 
static Vector64< float > RoundToNegativeInfinityScalar (Vector64< float > value)
 
static Vector64< float > RoundToPositiveInfinity (Vector64< float > value)
 
static Vector128< float > RoundToPositiveInfinity (Vector128< float > value)
 
static Vector64< double > RoundToPositiveInfinityScalar (Vector64< double > value)
 
static Vector64< float > RoundToPositiveInfinityScalar (Vector64< float > value)
 
static Vector64< float > RoundToZero (Vector64< float > value)
 
static Vector128< float > RoundToZero (Vector128< float > value)
 
static Vector64< double > RoundToZeroScalar (Vector64< double > value)
 
static Vector64< float > RoundToZeroScalar (Vector64< float > value)
 
static Vector64< shortShiftArithmetic (Vector64< short > value, Vector64< short > count)
 
static Vector64< int > ShiftArithmetic (Vector64< int > value, Vector64< int > count)
 
static Vector64< sbyte > ShiftArithmetic (Vector64< sbyte > value, Vector64< sbyte > count)
 
static Vector128< shortShiftArithmetic (Vector128< short > value, Vector128< short > count)
 
static Vector128< int > ShiftArithmetic (Vector128< int > value, Vector128< int > count)
 
static Vector128< long > ShiftArithmetic (Vector128< long > value, Vector128< long > count)
 
static Vector128< sbyte > ShiftArithmetic (Vector128< sbyte > value, Vector128< sbyte > count)
 
static Vector64< shortShiftArithmeticRounded (Vector64< short > value, Vector64< short > count)
 
static Vector64< int > ShiftArithmeticRounded (Vector64< int > value, Vector64< int > count)
 
static Vector64< sbyte > ShiftArithmeticRounded (Vector64< sbyte > value, Vector64< sbyte > count)
 
static Vector128< shortShiftArithmeticRounded (Vector128< short > value, Vector128< short > count)
 
static Vector128< int > ShiftArithmeticRounded (Vector128< int > value, Vector128< int > count)
 
static Vector128< long > ShiftArithmeticRounded (Vector128< long > value, Vector128< long > count)
 
static Vector128< sbyte > ShiftArithmeticRounded (Vector128< sbyte > value, Vector128< sbyte > count)
 
static Vector64< shortShiftArithmeticRoundedSaturate (Vector64< short > value, Vector64< short > count)
 
static Vector64< int > ShiftArithmeticRoundedSaturate (Vector64< int > value, Vector64< int > count)
 
static Vector64< sbyte > ShiftArithmeticRoundedSaturate (Vector64< sbyte > value, Vector64< sbyte > count)
 
static Vector128< shortShiftArithmeticRoundedSaturate (Vector128< short > value, Vector128< short > count)
 
static Vector128< int > ShiftArithmeticRoundedSaturate (Vector128< int > value, Vector128< int > count)
 
static Vector128< long > ShiftArithmeticRoundedSaturate (Vector128< long > value, Vector128< long > count)
 
static Vector128< sbyte > ShiftArithmeticRoundedSaturate (Vector128< sbyte > value, Vector128< sbyte > count)
 
static Vector64< long > ShiftArithmeticRoundedSaturateScalar (Vector64< long > value, Vector64< long > count)
 
static Vector64< long > ShiftArithmeticRoundedScalar (Vector64< long > value, Vector64< long > count)
 
static Vector64< shortShiftArithmeticSaturate (Vector64< short > value, Vector64< short > count)
 
static Vector64< int > ShiftArithmeticSaturate (Vector64< int > value, Vector64< int > count)
 
static Vector64< sbyte > ShiftArithmeticSaturate (Vector64< sbyte > value, Vector64< sbyte > count)
 
static Vector128< shortShiftArithmeticSaturate (Vector128< short > value, Vector128< short > count)
 
static Vector128< int > ShiftArithmeticSaturate (Vector128< int > value, Vector128< int > count)
 
static Vector128< long > ShiftArithmeticSaturate (Vector128< long > value, Vector128< long > count)
 
static Vector128< sbyte > ShiftArithmeticSaturate (Vector128< sbyte > value, Vector128< sbyte > count)
 
static Vector64< long > ShiftArithmeticSaturateScalar (Vector64< long > value, Vector64< long > count)
 
static Vector64< long > ShiftArithmeticScalar (Vector64< long > value, Vector64< long > count)
 
static Vector64< byte > ShiftLeftAndInsert (Vector64< byte > left, Vector64< byte > right, byte shift)
 
static Vector64< shortShiftLeftAndInsert (Vector64< short > left, Vector64< short > right, byte shift)
 
static Vector64< int > ShiftLeftAndInsert (Vector64< int > left, Vector64< int > right, byte shift)
 
static Vector64< sbyte > ShiftLeftAndInsert (Vector64< sbyte > left, Vector64< sbyte > right, byte shift)
 
static Vector64< ushort > ShiftLeftAndInsert (Vector64< ushort > left, Vector64< ushort > right, byte shift)
 
static Vector64< uint > ShiftLeftAndInsert (Vector64< uint > left, Vector64< uint > right, byte shift)
 
static Vector128< byte > ShiftLeftAndInsert (Vector128< byte > left, Vector128< byte > right, byte shift)
 
static Vector128< shortShiftLeftAndInsert (Vector128< short > left, Vector128< short > right, byte shift)
 
static Vector128< int > ShiftLeftAndInsert (Vector128< int > left, Vector128< int > right, byte shift)
 
static Vector128< long > ShiftLeftAndInsert (Vector128< long > left, Vector128< long > right, byte shift)
 
static Vector128< sbyte > ShiftLeftAndInsert (Vector128< sbyte > left, Vector128< sbyte > right, byte shift)
 
static Vector128< ushort > ShiftLeftAndInsert (Vector128< ushort > left, Vector128< ushort > right, byte shift)
 
static Vector128< uint > ShiftLeftAndInsert (Vector128< uint > left, Vector128< uint > right, byte shift)
 
static Vector128< ulong > ShiftLeftAndInsert (Vector128< ulong > left, Vector128< ulong > right, byte shift)
 
static Vector64< long > ShiftLeftAndInsertScalar (Vector64< long > left, Vector64< long > right, byte shift)
 
static Vector64< ulong > ShiftLeftAndInsertScalar (Vector64< ulong > left, Vector64< ulong > right, byte shift)
 
static Vector64< byte > ShiftLeftLogical (Vector64< byte > value, byte count)
 
static Vector64< shortShiftLeftLogical (Vector64< short > value, byte count)
 
static Vector64< int > ShiftLeftLogical (Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftLeftLogical (Vector64< sbyte > value, byte count)
 
static Vector64< ushort > ShiftLeftLogical (Vector64< ushort > value, byte count)
 
static Vector64< uint > ShiftLeftLogical (Vector64< uint > value, byte count)
 
static Vector128< byte > ShiftLeftLogical (Vector128< byte > value, byte count)
 
static Vector128< shortShiftLeftLogical (Vector128< short > value, byte count)
 
static Vector128< long > ShiftLeftLogical (Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftLeftLogical (Vector128< sbyte > value, byte count)
 
static Vector128< ushort > ShiftLeftLogical (Vector128< ushort > value, byte count)
 
static Vector128< uint > ShiftLeftLogical (Vector128< uint > value, byte count)
 
static Vector128< ulong > ShiftLeftLogical (Vector128< ulong > value, byte count)
 
static Vector64< byte > ShiftLeftLogicalSaturate (Vector64< byte > value, byte count)
 
static Vector64< shortShiftLeftLogicalSaturate (Vector64< short > value, byte count)
 
static Vector64< int > ShiftLeftLogicalSaturate (Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftLeftLogicalSaturate (Vector64< sbyte > value, byte count)
 
static Vector64< ushort > ShiftLeftLogicalSaturate (Vector64< ushort > value, byte count)
 
static Vector64< uint > ShiftLeftLogicalSaturate (Vector64< uint > value, byte count)
 
static Vector128< byte > ShiftLeftLogicalSaturate (Vector128< byte > value, byte count)
 
static Vector128< shortShiftLeftLogicalSaturate (Vector128< short > value, byte count)
 
static Vector128< int > ShiftLeftLogicalSaturate (Vector128< int > value, byte count)
 
static Vector128< long > ShiftLeftLogicalSaturate (Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftLeftLogicalSaturate (Vector128< sbyte > value, byte count)
 
static Vector128< ushort > ShiftLeftLogicalSaturate (Vector128< ushort > value, byte count)
 
static Vector128< uint > ShiftLeftLogicalSaturate (Vector128< uint > value, byte count)
 
static Vector128< ulong > ShiftLeftLogicalSaturate (Vector128< ulong > value, byte count)
 
static Vector64< long > ShiftLeftLogicalSaturateScalar (Vector64< long > value, byte count)
 
static Vector64< ulong > ShiftLeftLogicalSaturateScalar (Vector64< ulong > value, byte count)
 
static Vector64< ushort > ShiftLeftLogicalSaturateUnsigned (Vector64< short > value, byte count)
 
static Vector64< uint > ShiftLeftLogicalSaturateUnsigned (Vector64< int > value, byte count)
 
static Vector64< byte > ShiftLeftLogicalSaturateUnsigned (Vector64< sbyte > value, byte count)
 
static Vector128< ushort > ShiftLeftLogicalSaturateUnsigned (Vector128< short > value, byte count)
 
static Vector128< uint > ShiftLeftLogicalSaturateUnsigned (Vector128< int > value, byte count)
 
static Vector128< ulong > ShiftLeftLogicalSaturateUnsigned (Vector128< long > value, byte count)
 
static Vector128< byte > ShiftLeftLogicalSaturateUnsigned (Vector128< sbyte > value, byte count)
 
static Vector64< ulong > ShiftLeftLogicalSaturateUnsignedScalar (Vector64< long > value, byte count)
 
static Vector64< long > ShiftLeftLogicalScalar (Vector64< long > value, byte count)
 
static Vector64< ulong > ShiftLeftLogicalScalar (Vector64< ulong > value, byte count)
 
static Vector128< ushort > ShiftLeftLogicalWideningLower (Vector64< byte > value, byte count)
 
static Vector128< int > ShiftLeftLogicalWideningLower (Vector64< short > value, byte count)
 
static Vector128< long > ShiftLeftLogicalWideningLower (Vector64< int > value, byte count)
 
static Vector128< shortShiftLeftLogicalWideningLower (Vector64< sbyte > value, byte count)
 
static Vector128< uint > ShiftLeftLogicalWideningLower (Vector64< ushort > value, byte count)
 
static Vector128< ulong > ShiftLeftLogicalWideningLower (Vector64< uint > value, byte count)
 
static Vector128< ushort > ShiftLeftLogicalWideningUpper (Vector128< byte > value, byte count)
 
static Vector128< int > ShiftLeftLogicalWideningUpper (Vector128< short > value, byte count)
 
static Vector128< long > ShiftLeftLogicalWideningUpper (Vector128< int > value, byte count)
 
static Vector128< shortShiftLeftLogicalWideningUpper (Vector128< sbyte > value, byte count)
 
static Vector128< uint > ShiftLeftLogicalWideningUpper (Vector128< ushort > value, byte count)
 
static Vector128< ulong > ShiftLeftLogicalWideningUpper (Vector128< uint > value, byte count)
 
static Vector64< byte > ShiftLogical (Vector64< byte > value, Vector64< sbyte > count)
 
static Vector64< shortShiftLogical (Vector64< short > value, Vector64< short > count)
 
static Vector64< int > ShiftLogical (Vector64< int > value, Vector64< int > count)
 
static Vector64< sbyte > ShiftLogical (Vector64< sbyte > value, Vector64< sbyte > count)
 
static Vector64< ushort > ShiftLogical (Vector64< ushort > value, Vector64< short > count)
 
static Vector64< uint > ShiftLogical (Vector64< uint > value, Vector64< int > count)
 
static Vector128< byte > ShiftLogical (Vector128< byte > value, Vector128< sbyte > count)
 
static Vector128< shortShiftLogical (Vector128< short > value, Vector128< short > count)
 
static Vector128< int > ShiftLogical (Vector128< int > value, Vector128< int > count)
 
static Vector128< long > ShiftLogical (Vector128< long > value, Vector128< long > count)
 
static Vector128< sbyte > ShiftLogical (Vector128< sbyte > value, Vector128< sbyte > count)
 
static Vector128< ushort > ShiftLogical (Vector128< ushort > value, Vector128< short > count)
 
static Vector128< uint > ShiftLogical (Vector128< uint > value, Vector128< int > count)
 
static Vector128< ulong > ShiftLogical (Vector128< ulong > value, Vector128< long > count)
 
static Vector64< byte > ShiftLogicalRounded (Vector64< byte > value, Vector64< sbyte > count)
 
static Vector64< shortShiftLogicalRounded (Vector64< short > value, Vector64< short > count)
 
static Vector64< int > ShiftLogicalRounded (Vector64< int > value, Vector64< int > count)
 
static Vector64< sbyte > ShiftLogicalRounded (Vector64< sbyte > value, Vector64< sbyte > count)
 
static Vector64< ushort > ShiftLogicalRounded (Vector64< ushort > value, Vector64< short > count)
 
static Vector64< uint > ShiftLogicalRounded (Vector64< uint > value, Vector64< int > count)
 
static Vector128< byte > ShiftLogicalRounded (Vector128< byte > value, Vector128< sbyte > count)
 
static Vector128< shortShiftLogicalRounded (Vector128< short > value, Vector128< short > count)
 
static Vector128< int > ShiftLogicalRounded (Vector128< int > value, Vector128< int > count)
 
static Vector128< long > ShiftLogicalRounded (Vector128< long > value, Vector128< long > count)
 
static Vector128< sbyte > ShiftLogicalRounded (Vector128< sbyte > value, Vector128< sbyte > count)
 
static Vector128< ushort > ShiftLogicalRounded (Vector128< ushort > value, Vector128< short > count)
 
static Vector128< uint > ShiftLogicalRounded (Vector128< uint > value, Vector128< int > count)
 
static Vector128< ulong > ShiftLogicalRounded (Vector128< ulong > value, Vector128< long > count)
 
static Vector64< byte > ShiftLogicalRoundedSaturate (Vector64< byte > value, Vector64< sbyte > count)
 
static Vector64< shortShiftLogicalRoundedSaturate (Vector64< short > value, Vector64< short > count)
 
static Vector64< int > ShiftLogicalRoundedSaturate (Vector64< int > value, Vector64< int > count)
 
static Vector64< sbyte > ShiftLogicalRoundedSaturate (Vector64< sbyte > value, Vector64< sbyte > count)
 
static Vector64< ushort > ShiftLogicalRoundedSaturate (Vector64< ushort > value, Vector64< short > count)
 
static Vector64< uint > ShiftLogicalRoundedSaturate (Vector64< uint > value, Vector64< int > count)
 
static Vector128< byte > ShiftLogicalRoundedSaturate (Vector128< byte > value, Vector128< sbyte > count)
 
static Vector128< shortShiftLogicalRoundedSaturate (Vector128< short > value, Vector128< short > count)
 
static Vector128< int > ShiftLogicalRoundedSaturate (Vector128< int > value, Vector128< int > count)
 
static Vector128< long > ShiftLogicalRoundedSaturate (Vector128< long > value, Vector128< long > count)
 
static Vector128< sbyte > ShiftLogicalRoundedSaturate (Vector128< sbyte > value, Vector128< sbyte > count)
 
static Vector128< ushort > ShiftLogicalRoundedSaturate (Vector128< ushort > value, Vector128< short > count)
 
static Vector128< uint > ShiftLogicalRoundedSaturate (Vector128< uint > value, Vector128< int > count)
 
static Vector128< ulong > ShiftLogicalRoundedSaturate (Vector128< ulong > value, Vector128< long > count)
 
static Vector64< long > ShiftLogicalRoundedSaturateScalar (Vector64< long > value, Vector64< long > count)
 
static Vector64< ulong > ShiftLogicalRoundedSaturateScalar (Vector64< ulong > value, Vector64< long > count)
 
static Vector64< long > ShiftLogicalRoundedScalar (Vector64< long > value, Vector64< long > count)
 
static Vector64< ulong > ShiftLogicalRoundedScalar (Vector64< ulong > value, Vector64< long > count)
 
static Vector64< byte > ShiftLogicalSaturate (Vector64< byte > value, Vector64< sbyte > count)
 
static Vector64< shortShiftLogicalSaturate (Vector64< short > value, Vector64< short > count)
 
static Vector64< int > ShiftLogicalSaturate (Vector64< int > value, Vector64< int > count)
 
static Vector64< sbyte > ShiftLogicalSaturate (Vector64< sbyte > value, Vector64< sbyte > count)
 
static Vector64< ushort > ShiftLogicalSaturate (Vector64< ushort > value, Vector64< short > count)
 
static Vector64< uint > ShiftLogicalSaturate (Vector64< uint > value, Vector64< int > count)
 
static Vector128< byte > ShiftLogicalSaturate (Vector128< byte > value, Vector128< sbyte > count)
 
static Vector128< shortShiftLogicalSaturate (Vector128< short > value, Vector128< short > count)
 
static Vector128< int > ShiftLogicalSaturate (Vector128< int > value, Vector128< int > count)
 
static Vector128< long > ShiftLogicalSaturate (Vector128< long > value, Vector128< long > count)
 
static Vector128< sbyte > ShiftLogicalSaturate (Vector128< sbyte > value, Vector128< sbyte > count)
 
static Vector128< ushort > ShiftLogicalSaturate (Vector128< ushort > value, Vector128< short > count)
 
static Vector128< uint > ShiftLogicalSaturate (Vector128< uint > value, Vector128< int > count)
 
static Vector128< ulong > ShiftLogicalSaturate (Vector128< ulong > value, Vector128< long > count)
 
static Vector64< long > ShiftLogicalSaturateScalar (Vector64< long > value, Vector64< long > count)
 
static Vector64< ulong > ShiftLogicalSaturateScalar (Vector64< ulong > value, Vector64< long > count)
 
static Vector64< long > ShiftLogicalScalar (Vector64< long > value, Vector64< long > count)
 
static Vector64< ulong > ShiftLogicalScalar (Vector64< ulong > value, Vector64< long > count)
 
static Vector64< byte > ShiftRightAndInsert (Vector64< byte > left, Vector64< byte > right, byte shift)
 
static Vector64< shortShiftRightAndInsert (Vector64< short > left, Vector64< short > right, byte shift)
 
static Vector64< int > ShiftRightAndInsert (Vector64< int > left, Vector64< int > right, byte shift)
 
static Vector64< sbyte > ShiftRightAndInsert (Vector64< sbyte > left, Vector64< sbyte > right, byte shift)
 
static Vector64< ushort > ShiftRightAndInsert (Vector64< ushort > left, Vector64< ushort > right, byte shift)
 
static Vector64< uint > ShiftRightAndInsert (Vector64< uint > left, Vector64< uint > right, byte shift)
 
static Vector128< byte > ShiftRightAndInsert (Vector128< byte > left, Vector128< byte > right, byte shift)
 
static Vector128< shortShiftRightAndInsert (Vector128< short > left, Vector128< short > right, byte shift)
 
static Vector128< int > ShiftRightAndInsert (Vector128< int > left, Vector128< int > right, byte shift)
 
static Vector128< long > ShiftRightAndInsert (Vector128< long > left, Vector128< long > right, byte shift)
 
static Vector128< sbyte > ShiftRightAndInsert (Vector128< sbyte > left, Vector128< sbyte > right, byte shift)
 
static Vector128< ushort > ShiftRightAndInsert (Vector128< ushort > left, Vector128< ushort > right, byte shift)
 
static Vector128< uint > ShiftRightAndInsert (Vector128< uint > left, Vector128< uint > right, byte shift)
 
static Vector128< ulong > ShiftRightAndInsert (Vector128< ulong > left, Vector128< ulong > right, byte shift)
 
static Vector64< long > ShiftRightAndInsertScalar (Vector64< long > left, Vector64< long > right, byte shift)
 
static Vector64< ulong > ShiftRightAndInsertScalar (Vector64< ulong > left, Vector64< ulong > right, byte shift)
 
static Vector64< shortShiftRightArithmetic (Vector64< short > value, byte count)
 
static Vector64< int > ShiftRightArithmetic (Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftRightArithmetic (Vector64< sbyte > value, byte count)
 
static Vector128< shortShiftRightArithmetic (Vector128< short > value, byte count)
 
static Vector128< int > ShiftRightArithmetic (Vector128< int > value, byte count)
 
static Vector128< long > ShiftRightArithmetic (Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightArithmetic (Vector128< sbyte > value, byte count)
 
static Vector64< shortShiftRightArithmeticAdd (Vector64< short > addend, Vector64< short > value, byte count)
 
static Vector64< int > ShiftRightArithmeticAdd (Vector64< int > addend, Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftRightArithmeticAdd (Vector64< sbyte > addend, Vector64< sbyte > value, byte count)
 
static Vector128< shortShiftRightArithmeticAdd (Vector128< short > addend, Vector128< short > value, byte count)
 
static Vector128< int > ShiftRightArithmeticAdd (Vector128< int > addend, Vector128< int > value, byte count)
 
static Vector128< long > ShiftRightArithmeticAdd (Vector128< long > addend, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightArithmeticAdd (Vector128< sbyte > addend, Vector128< sbyte > value, byte count)
 
static Vector64< long > ShiftRightArithmeticAddScalar (Vector64< long > addend, Vector64< long > value, byte count)
 
static Vector64< shortShiftRightArithmeticNarrowingSaturateLower (Vector128< int > value, byte count)
 
static Vector64< int > ShiftRightArithmeticNarrowingSaturateLower (Vector128< long > value, byte count)
 
static Vector64< sbyte > ShiftRightArithmeticNarrowingSaturateLower (Vector128< short > value, byte count)
 
static Vector64< byte > ShiftRightArithmeticNarrowingSaturateUnsignedLower (Vector128< short > value, byte count)
 
static Vector64< ushort > ShiftRightArithmeticNarrowingSaturateUnsignedLower (Vector128< int > value, byte count)
 
static Vector64< uint > ShiftRightArithmeticNarrowingSaturateUnsignedLower (Vector128< long > value, byte count)
 
static Vector128< byte > ShiftRightArithmeticNarrowingSaturateUnsignedUpper (Vector64< byte > lower, Vector128< short > value, byte count)
 
static Vector128< ushort > ShiftRightArithmeticNarrowingSaturateUnsignedUpper (Vector64< ushort > lower, Vector128< int > value, byte count)
 
static Vector128< uint > ShiftRightArithmeticNarrowingSaturateUnsignedUpper (Vector64< uint > lower, Vector128< long > value, byte count)
 
static Vector128< shortShiftRightArithmeticNarrowingSaturateUpper (Vector64< short > lower, Vector128< int > value, byte count)
 
static Vector128< int > ShiftRightArithmeticNarrowingSaturateUpper (Vector64< int > lower, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightArithmeticNarrowingSaturateUpper (Vector64< sbyte > lower, Vector128< short > value, byte count)
 
static Vector64< shortShiftRightArithmeticRounded (Vector64< short > value, byte count)
 
static Vector64< int > ShiftRightArithmeticRounded (Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftRightArithmeticRounded (Vector64< sbyte > value, byte count)
 
static Vector128< shortShiftRightArithmeticRounded (Vector128< short > value, byte count)
 
static Vector128< int > ShiftRightArithmeticRounded (Vector128< int > value, byte count)
 
static Vector128< long > ShiftRightArithmeticRounded (Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightArithmeticRounded (Vector128< sbyte > value, byte count)
 
static Vector64< shortShiftRightArithmeticRoundedAdd (Vector64< short > addend, Vector64< short > value, byte count)
 
static Vector64< int > ShiftRightArithmeticRoundedAdd (Vector64< int > addend, Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftRightArithmeticRoundedAdd (Vector64< sbyte > addend, Vector64< sbyte > value, byte count)
 
static Vector128< shortShiftRightArithmeticRoundedAdd (Vector128< short > addend, Vector128< short > value, byte count)
 
static Vector128< int > ShiftRightArithmeticRoundedAdd (Vector128< int > addend, Vector128< int > value, byte count)
 
static Vector128< long > ShiftRightArithmeticRoundedAdd (Vector128< long > addend, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightArithmeticRoundedAdd (Vector128< sbyte > addend, Vector128< sbyte > value, byte count)
 
static Vector64< long > ShiftRightArithmeticRoundedAddScalar (Vector64< long > addend, Vector64< long > value, byte count)
 
static Vector64< shortShiftRightArithmeticRoundedNarrowingSaturateLower (Vector128< int > value, byte count)
 
static Vector64< int > ShiftRightArithmeticRoundedNarrowingSaturateLower (Vector128< long > value, byte count)
 
static Vector64< sbyte > ShiftRightArithmeticRoundedNarrowingSaturateLower (Vector128< short > value, byte count)
 
static Vector64< byte > ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower (Vector128< short > value, byte count)
 
static Vector64< ushort > ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower (Vector128< int > value, byte count)
 
static Vector64< uint > ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower (Vector128< long > value, byte count)
 
static Vector128< byte > ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper (Vector64< byte > lower, Vector128< short > value, byte count)
 
static Vector128< ushort > ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper (Vector64< ushort > lower, Vector128< int > value, byte count)
 
static Vector128< uint > ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper (Vector64< uint > lower, Vector128< long > value, byte count)
 
static Vector128< shortShiftRightArithmeticRoundedNarrowingSaturateUpper (Vector64< short > lower, Vector128< int > value, byte count)
 
static Vector128< int > ShiftRightArithmeticRoundedNarrowingSaturateUpper (Vector64< int > lower, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightArithmeticRoundedNarrowingSaturateUpper (Vector64< sbyte > lower, Vector128< short > value, byte count)
 
static Vector64< long > ShiftRightArithmeticRoundedScalar (Vector64< long > value, byte count)
 
static Vector64< long > ShiftRightArithmeticScalar (Vector64< long > value, byte count)
 
static Vector64< byte > ShiftRightLogical (Vector64< byte > value, byte count)
 
static Vector64< shortShiftRightLogical (Vector64< short > value, byte count)
 
static Vector64< int > ShiftRightLogical (Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftRightLogical (Vector64< sbyte > value, byte count)
 
static Vector64< ushort > ShiftRightLogical (Vector64< ushort > value, byte count)
 
static Vector64< uint > ShiftRightLogical (Vector64< uint > value, byte count)
 
static Vector128< byte > ShiftRightLogical (Vector128< byte > value, byte count)
 
static Vector128< shortShiftRightLogical (Vector128< short > value, byte count)
 
static Vector128< int > ShiftRightLogical (Vector128< int > value, byte count)
 
static Vector128< long > ShiftRightLogical (Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightLogical (Vector128< sbyte > value, byte count)
 
static Vector128< ushort > ShiftRightLogical (Vector128< ushort > value, byte count)
 
static Vector128< uint > ShiftRightLogical (Vector128< uint > value, byte count)
 
static Vector128< ulong > ShiftRightLogical (Vector128< ulong > value, byte count)
 
static Vector64< byte > ShiftRightLogicalAdd (Vector64< byte > addend, Vector64< byte > value, byte count)
 
static Vector64< shortShiftRightLogicalAdd (Vector64< short > addend, Vector64< short > value, byte count)
 
static Vector64< int > ShiftRightLogicalAdd (Vector64< int > addend, Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftRightLogicalAdd (Vector64< sbyte > addend, Vector64< sbyte > value, byte count)
 
static Vector64< ushort > ShiftRightLogicalAdd (Vector64< ushort > addend, Vector64< ushort > value, byte count)
 
static Vector64< uint > ShiftRightLogicalAdd (Vector64< uint > addend, Vector64< uint > value, byte count)
 
static Vector128< byte > ShiftRightLogicalAdd (Vector128< byte > addend, Vector128< byte > value, byte count)
 
static Vector128< shortShiftRightLogicalAdd (Vector128< short > addend, Vector128< short > value, byte count)
 
static Vector128< int > ShiftRightLogicalAdd (Vector128< int > addend, Vector128< int > value, byte count)
 
static Vector128< long > ShiftRightLogicalAdd (Vector128< long > addend, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightLogicalAdd (Vector128< sbyte > addend, Vector128< sbyte > value, byte count)
 
static Vector128< ushort > ShiftRightLogicalAdd (Vector128< ushort > addend, Vector128< ushort > value, byte count)
 
static Vector128< uint > ShiftRightLogicalAdd (Vector128< uint > addend, Vector128< uint > value, byte count)
 
static Vector128< ulong > ShiftRightLogicalAdd (Vector128< ulong > addend, Vector128< ulong > value, byte count)
 
static Vector64< long > ShiftRightLogicalAddScalar (Vector64< long > addend, Vector64< long > value, byte count)
 
static Vector64< ulong > ShiftRightLogicalAddScalar (Vector64< ulong > addend, Vector64< ulong > value, byte count)
 
static Vector64< byte > ShiftRightLogicalNarrowingLower (Vector128< ushort > value, byte count)
 
static Vector64< shortShiftRightLogicalNarrowingLower (Vector128< int > value, byte count)
 
static Vector64< int > ShiftRightLogicalNarrowingLower (Vector128< long > value, byte count)
 
static Vector64< sbyte > ShiftRightLogicalNarrowingLower (Vector128< short > value, byte count)
 
static Vector64< ushort > ShiftRightLogicalNarrowingLower (Vector128< uint > value, byte count)
 
static Vector64< uint > ShiftRightLogicalNarrowingLower (Vector128< ulong > value, byte count)
 
static Vector64< byte > ShiftRightLogicalNarrowingSaturateLower (Vector128< ushort > value, byte count)
 
static Vector64< shortShiftRightLogicalNarrowingSaturateLower (Vector128< int > value, byte count)
 
static Vector64< int > ShiftRightLogicalNarrowingSaturateLower (Vector128< long > value, byte count)
 
static Vector64< sbyte > ShiftRightLogicalNarrowingSaturateLower (Vector128< short > value, byte count)
 
static Vector64< ushort > ShiftRightLogicalNarrowingSaturateLower (Vector128< uint > value, byte count)
 
static Vector64< uint > ShiftRightLogicalNarrowingSaturateLower (Vector128< ulong > value, byte count)
 
static Vector128< byte > ShiftRightLogicalNarrowingSaturateUpper (Vector64< byte > lower, Vector128< ushort > value, byte count)
 
static Vector128< shortShiftRightLogicalNarrowingSaturateUpper (Vector64< short > lower, Vector128< int > value, byte count)
 
static Vector128< int > ShiftRightLogicalNarrowingSaturateUpper (Vector64< int > lower, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightLogicalNarrowingSaturateUpper (Vector64< sbyte > lower, Vector128< short > value, byte count)
 
static Vector128< ushort > ShiftRightLogicalNarrowingSaturateUpper (Vector64< ushort > lower, Vector128< uint > value, byte count)
 
static Vector128< uint > ShiftRightLogicalNarrowingSaturateUpper (Vector64< uint > lower, Vector128< ulong > value, byte count)
 
static Vector128< byte > ShiftRightLogicalNarrowingUpper (Vector64< byte > lower, Vector128< ushort > value, byte count)
 
static Vector128< shortShiftRightLogicalNarrowingUpper (Vector64< short > lower, Vector128< int > value, byte count)
 
static Vector128< int > ShiftRightLogicalNarrowingUpper (Vector64< int > lower, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightLogicalNarrowingUpper (Vector64< sbyte > lower, Vector128< short > value, byte count)
 
static Vector128< ushort > ShiftRightLogicalNarrowingUpper (Vector64< ushort > lower, Vector128< uint > value, byte count)
 
static Vector128< uint > ShiftRightLogicalNarrowingUpper (Vector64< uint > lower, Vector128< ulong > value, byte count)
 
static Vector64< byte > ShiftRightLogicalRounded (Vector64< byte > value, byte count)
 
static Vector64< shortShiftRightLogicalRounded (Vector64< short > value, byte count)
 
static Vector64< int > ShiftRightLogicalRounded (Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftRightLogicalRounded (Vector64< sbyte > value, byte count)
 
static Vector64< ushort > ShiftRightLogicalRounded (Vector64< ushort > value, byte count)
 
static Vector64< uint > ShiftRightLogicalRounded (Vector64< uint > value, byte count)
 
static Vector128< byte > ShiftRightLogicalRounded (Vector128< byte > value, byte count)
 
static Vector128< shortShiftRightLogicalRounded (Vector128< short > value, byte count)
 
static Vector128< int > ShiftRightLogicalRounded (Vector128< int > value, byte count)
 
static Vector128< long > ShiftRightLogicalRounded (Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightLogicalRounded (Vector128< sbyte > value, byte count)
 
static Vector128< ushort > ShiftRightLogicalRounded (Vector128< ushort > value, byte count)
 
static Vector128< uint > ShiftRightLogicalRounded (Vector128< uint > value, byte count)
 
static Vector128< ulong > ShiftRightLogicalRounded (Vector128< ulong > value, byte count)
 
static Vector64< byte > ShiftRightLogicalRoundedAdd (Vector64< byte > addend, Vector64< byte > value, byte count)
 
static Vector64< shortShiftRightLogicalRoundedAdd (Vector64< short > addend, Vector64< short > value, byte count)
 
static Vector64< int > ShiftRightLogicalRoundedAdd (Vector64< int > addend, Vector64< int > value, byte count)
 
static Vector64< sbyte > ShiftRightLogicalRoundedAdd (Vector64< sbyte > addend, Vector64< sbyte > value, byte count)
 
static Vector64< ushort > ShiftRightLogicalRoundedAdd (Vector64< ushort > addend, Vector64< ushort > value, byte count)
 
static Vector64< uint > ShiftRightLogicalRoundedAdd (Vector64< uint > addend, Vector64< uint > value, byte count)
 
static Vector128< byte > ShiftRightLogicalRoundedAdd (Vector128< byte > addend, Vector128< byte > value, byte count)
 
static Vector128< shortShiftRightLogicalRoundedAdd (Vector128< short > addend, Vector128< short > value, byte count)
 
static Vector128< int > ShiftRightLogicalRoundedAdd (Vector128< int > addend, Vector128< int > value, byte count)
 
static Vector128< long > ShiftRightLogicalRoundedAdd (Vector128< long > addend, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightLogicalRoundedAdd (Vector128< sbyte > addend, Vector128< sbyte > value, byte count)
 
static Vector128< ushort > ShiftRightLogicalRoundedAdd (Vector128< ushort > addend, Vector128< ushort > value, byte count)
 
static Vector128< uint > ShiftRightLogicalRoundedAdd (Vector128< uint > addend, Vector128< uint > value, byte count)
 
static Vector128< ulong > ShiftRightLogicalRoundedAdd (Vector128< ulong > addend, Vector128< ulong > value, byte count)
 
static Vector64< long > ShiftRightLogicalRoundedAddScalar (Vector64< long > addend, Vector64< long > value, byte count)
 
static Vector64< ulong > ShiftRightLogicalRoundedAddScalar (Vector64< ulong > addend, Vector64< ulong > value, byte count)
 
static Vector64< byte > ShiftRightLogicalRoundedNarrowingLower (Vector128< ushort > value, byte count)
 
static Vector64< shortShiftRightLogicalRoundedNarrowingLower (Vector128< int > value, byte count)
 
static Vector64< int > ShiftRightLogicalRoundedNarrowingLower (Vector128< long > value, byte count)
 
static Vector64< sbyte > ShiftRightLogicalRoundedNarrowingLower (Vector128< short > value, byte count)
 
static Vector64< ushort > ShiftRightLogicalRoundedNarrowingLower (Vector128< uint > value, byte count)
 
static Vector64< uint > ShiftRightLogicalRoundedNarrowingLower (Vector128< ulong > value, byte count)
 
static Vector64< byte > ShiftRightLogicalRoundedNarrowingSaturateLower (Vector128< ushort > value, byte count)
 
static Vector64< shortShiftRightLogicalRoundedNarrowingSaturateLower (Vector128< int > value, byte count)
 
static Vector64< int > ShiftRightLogicalRoundedNarrowingSaturateLower (Vector128< long > value, byte count)
 
static Vector64< sbyte > ShiftRightLogicalRoundedNarrowingSaturateLower (Vector128< short > value, byte count)
 
static Vector64< ushort > ShiftRightLogicalRoundedNarrowingSaturateLower (Vector128< uint > value, byte count)
 
static Vector64< uint > ShiftRightLogicalRoundedNarrowingSaturateLower (Vector128< ulong > value, byte count)
 
static Vector128< byte > ShiftRightLogicalRoundedNarrowingSaturateUpper (Vector64< byte > lower, Vector128< ushort > value, byte count)
 
static Vector128< shortShiftRightLogicalRoundedNarrowingSaturateUpper (Vector64< short > lower, Vector128< int > value, byte count)
 
static Vector128< int > ShiftRightLogicalRoundedNarrowingSaturateUpper (Vector64< int > lower, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightLogicalRoundedNarrowingSaturateUpper (Vector64< sbyte > lower, Vector128< short > value, byte count)
 
static Vector128< ushort > ShiftRightLogicalRoundedNarrowingSaturateUpper (Vector64< ushort > lower, Vector128< uint > value, byte count)
 
static Vector128< uint > ShiftRightLogicalRoundedNarrowingSaturateUpper (Vector64< uint > lower, Vector128< ulong > value, byte count)
 
static Vector128< byte > ShiftRightLogicalRoundedNarrowingUpper (Vector64< byte > lower, Vector128< ushort > value, byte count)
 
static Vector128< shortShiftRightLogicalRoundedNarrowingUpper (Vector64< short > lower, Vector128< int > value, byte count)
 
static Vector128< int > ShiftRightLogicalRoundedNarrowingUpper (Vector64< int > lower, Vector128< long > value, byte count)
 
static Vector128< sbyte > ShiftRightLogicalRoundedNarrowingUpper (Vector64< sbyte > lower, Vector128< short > value, byte count)
 
static Vector128< ushort > ShiftRightLogicalRoundedNarrowingUpper (Vector64< ushort > lower, Vector128< uint > value, byte count)
 
static Vector128< uint > ShiftRightLogicalRoundedNarrowingUpper (Vector64< uint > lower, Vector128< ulong > value, byte count)
 
static Vector64< long > ShiftRightLogicalRoundedScalar (Vector64< long > value, byte count)
 
static Vector64< ulong > ShiftRightLogicalRoundedScalar (Vector64< ulong > value, byte count)
 
static Vector64< long > ShiftRightLogicalScalar (Vector64< long > value, byte count)
 
static Vector64< ulong > ShiftRightLogicalScalar (Vector64< ulong > value, byte count)
 
static Vector128< int > SignExtendWideningLower (Vector64< short > value)
 
static Vector128< long > SignExtendWideningLower (Vector64< int > value)
 
static Vector128< shortSignExtendWideningLower (Vector64< sbyte > value)
 
static Vector128< int > SignExtendWideningUpper (Vector128< short > value)
 
static Vector128< long > SignExtendWideningUpper (Vector128< int > value)
 
static Vector128< shortSignExtendWideningUpper (Vector128< sbyte > value)
 
static Vector64< double > SqrtScalar (Vector64< double > value)
 
static Vector64< float > SqrtScalar (Vector64< float > value)
 
static unsafe void Store (byte *address, Vector64< byte > source)
 
static unsafe void Store (double *address, Vector64< double > source)
 
static unsafe void Store (short *address, Vector64< short > source)
 
static unsafe void Store (int *address, Vector64< int > source)
 
static unsafe void Store (long *address, Vector64< long > source)
 
static unsafe void Store (sbyte *address, Vector64< sbyte > source)
 
static unsafe void Store (float *address, Vector64< float > source)
 
static unsafe void Store (ushort *address, Vector64< ushort > source)
 
static unsafe void Store (uint *address, Vector64< uint > source)
 
static unsafe void Store (ulong *address, Vector64< ulong > source)
 
static unsafe void Store (byte *address, Vector128< byte > source)
 
static unsafe void Store (double *address, Vector128< double > source)
 
static unsafe void Store (short *address, Vector128< short > source)
 
static unsafe void Store (int *address, Vector128< int > source)
 
static unsafe void Store (long *address, Vector128< long > source)
 
static unsafe void Store (sbyte *address, Vector128< sbyte > source)
 
static unsafe void Store (float *address, Vector128< float > source)
 
static unsafe void Store (ushort *address, Vector128< ushort > source)
 
static unsafe void Store (uint *address, Vector128< uint > source)
 
static unsafe void Store (ulong *address, Vector128< ulong > source)
 
static unsafe void StoreSelectedScalar (byte *address, Vector64< byte > value, byte index)
 
static unsafe void StoreSelectedScalar (short *address, Vector64< short > value, byte index)
 
static unsafe void StoreSelectedScalar (int *address, Vector64< int > value, byte index)
 
static unsafe void StoreSelectedScalar (sbyte *address, Vector64< sbyte > value, byte index)
 
static unsafe void StoreSelectedScalar (float *address, Vector64< float > value, byte index)
 
static unsafe void StoreSelectedScalar (ushort *address, Vector64< ushort > value, byte index)
 
static unsafe void StoreSelectedScalar (uint *address, Vector64< uint > value, byte index)
 
static unsafe void StoreSelectedScalar (byte *address, Vector128< byte > value, byte index)
 
static unsafe void StoreSelectedScalar (double *address, Vector128< double > value, byte index)
 
static unsafe void StoreSelectedScalar (short *address, Vector128< short > value, byte index)
 
static unsafe void StoreSelectedScalar (int *address, Vector128< int > value, byte index)
 
static unsafe void StoreSelectedScalar (long *address, Vector128< long > value, byte index)
 
static unsafe void StoreSelectedScalar (sbyte *address, Vector128< sbyte > value, byte index)
 
static unsafe void StoreSelectedScalar (float *address, Vector128< float > value, byte index)
 
static unsafe void StoreSelectedScalar (ushort *address, Vector128< ushort > value, byte index)
 
static unsafe void StoreSelectedScalar (uint *address, Vector128< uint > value, byte index)
 
static unsafe void StoreSelectedScalar (ulong *address, Vector128< ulong > value, byte index)
 
static Vector64< byte > Subtract (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortSubtract (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > Subtract (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > Subtract (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > Subtract (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > Subtract (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > Subtract (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > Subtract (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortSubtract (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > Subtract (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > Subtract (Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > Subtract (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > Subtract (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > Subtract (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > Subtract (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > Subtract (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< byte > SubtractHighNarrowingLower (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector64< shortSubtractHighNarrowingLower (Vector128< int > left, Vector128< int > right)
 
static Vector64< int > SubtractHighNarrowingLower (Vector128< long > left, Vector128< long > right)
 
static Vector64< sbyte > SubtractHighNarrowingLower (Vector128< short > left, Vector128< short > right)
 
static Vector64< ushort > SubtractHighNarrowingLower (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< uint > SubtractHighNarrowingLower (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector128< byte > SubtractHighNarrowingUpper (Vector64< byte > lower, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< shortSubtractHighNarrowingUpper (Vector64< short > lower, Vector128< int > left, Vector128< int > right)
 
static Vector128< int > SubtractHighNarrowingUpper (Vector64< int > lower, Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > SubtractHighNarrowingUpper (Vector64< sbyte > lower, Vector128< short > left, Vector128< short > right)
 
static Vector128< ushort > SubtractHighNarrowingUpper (Vector64< ushort > lower, Vector128< uint > left, Vector128< uint > right)
 
static Vector128< uint > SubtractHighNarrowingUpper (Vector64< uint > lower, Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< byte > SubtractRoundedHighNarrowingLower (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector64< shortSubtractRoundedHighNarrowingLower (Vector128< int > left, Vector128< int > right)
 
static Vector64< int > SubtractRoundedHighNarrowingLower (Vector128< long > left, Vector128< long > right)
 
static Vector64< sbyte > SubtractRoundedHighNarrowingLower (Vector128< short > left, Vector128< short > right)
 
static Vector64< ushort > SubtractRoundedHighNarrowingLower (Vector128< uint > left, Vector128< uint > right)
 
static Vector64< uint > SubtractRoundedHighNarrowingLower (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector128< byte > SubtractRoundedHighNarrowingUpper (Vector64< byte > lower, Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< shortSubtractRoundedHighNarrowingUpper (Vector64< short > lower, Vector128< int > left, Vector128< int > right)
 
static Vector128< int > SubtractRoundedHighNarrowingUpper (Vector64< int > lower, Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > SubtractRoundedHighNarrowingUpper (Vector64< sbyte > lower, Vector128< short > left, Vector128< short > right)
 
static Vector128< ushort > SubtractRoundedHighNarrowingUpper (Vector64< ushort > lower, Vector128< uint > left, Vector128< uint > right)
 
static Vector128< uint > SubtractRoundedHighNarrowingUpper (Vector64< uint > lower, Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< byte > SubtractSaturate (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< shortSubtractSaturate (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > SubtractSaturate (Vector64< int > left, Vector64< int > right)
 
static Vector64< sbyte > SubtractSaturate (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< ushort > SubtractSaturate (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > SubtractSaturate (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< byte > SubtractSaturate (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< shortSubtractSaturate (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > SubtractSaturate (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > SubtractSaturate (Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > SubtractSaturate (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > SubtractSaturate (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > SubtractSaturate (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > SubtractSaturate (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector64< long > SubtractSaturateScalar (Vector64< long > left, Vector64< long > right)
 
static Vector64< ulong > SubtractSaturateScalar (Vector64< ulong > left, Vector64< ulong > right)
 
static Vector64< double > SubtractScalar (Vector64< double > left, Vector64< double > right)
 
static Vector64< long > SubtractScalar (Vector64< long > left, Vector64< long > right)
 
static Vector64< float > SubtractScalar (Vector64< float > left, Vector64< float > right)
 
static Vector64< ulong > SubtractScalar (Vector64< ulong > left, Vector64< ulong > right)
 
static Vector128< ushort > SubtractWideningLower (Vector64< byte > left, Vector64< byte > right)
 
static Vector128< int > SubtractWideningLower (Vector64< short > left, Vector64< short > right)
 
static Vector128< long > SubtractWideningLower (Vector64< int > left, Vector64< int > right)
 
static Vector128< shortSubtractWideningLower (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector128< uint > SubtractWideningLower (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector128< ulong > SubtractWideningLower (Vector64< uint > left, Vector64< uint > right)
 
static Vector128< shortSubtractWideningLower (Vector128< short > left, Vector64< sbyte > right)
 
static Vector128< int > SubtractWideningLower (Vector128< int > left, Vector64< short > right)
 
static Vector128< long > SubtractWideningLower (Vector128< long > left, Vector64< int > right)
 
static Vector128< ushort > SubtractWideningLower (Vector128< ushort > left, Vector64< byte > right)
 
static Vector128< uint > SubtractWideningLower (Vector128< uint > left, Vector64< ushort > right)
 
static Vector128< ulong > SubtractWideningLower (Vector128< ulong > left, Vector64< uint > right)
 
static Vector128< ushort > SubtractWideningUpper (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< int > SubtractWideningUpper (Vector128< short > left, Vector128< short > right)
 
static Vector128< shortSubtractWideningUpper (Vector128< short > left, Vector128< sbyte > right)
 
static Vector128< int > SubtractWideningUpper (Vector128< int > left, Vector128< short > right)
 
static Vector128< long > SubtractWideningUpper (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > SubtractWideningUpper (Vector128< long > left, Vector128< int > right)
 
static Vector128< shortSubtractWideningUpper (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< ushort > SubtractWideningUpper (Vector128< ushort > left, Vector128< byte > right)
 
static Vector128< uint > SubtractWideningUpper (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > SubtractWideningUpper (Vector128< uint > left, Vector128< ushort > right)
 
static Vector128< ulong > SubtractWideningUpper (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > SubtractWideningUpper (Vector128< ulong > left, Vector128< uint > right)
 
static Vector64< byte > VectorTableLookup (Vector128< byte > table, Vector64< byte > byteIndexes)
 
static Vector64< sbyte > VectorTableLookup (Vector128< sbyte > table, Vector64< sbyte > byteIndexes)
 
static Vector64< byte > VectorTableLookupExtension (Vector64< byte > defaultValues, Vector128< byte > table, Vector64< byte > byteIndexes)
 
static Vector64< sbyte > VectorTableLookupExtension (Vector64< sbyte > defaultValues, Vector128< sbyte > table, Vector64< sbyte > byteIndexes)
 
static Vector64< byte > Xor (Vector64< byte > left, Vector64< byte > right)
 
static Vector64< double > Xor (Vector64< double > left, Vector64< double > right)
 
static Vector64< shortXor (Vector64< short > left, Vector64< short > right)
 
static Vector64< int > Xor (Vector64< int > left, Vector64< int > right)
 
static Vector64< long > Xor (Vector64< long > left, Vector64< long > right)
 
static Vector64< sbyte > Xor (Vector64< sbyte > left, Vector64< sbyte > right)
 
static Vector64< float > Xor (Vector64< float > left, Vector64< float > right)
 
static Vector64< ushort > Xor (Vector64< ushort > left, Vector64< ushort > right)
 
static Vector64< uint > Xor (Vector64< uint > left, Vector64< uint > right)
 
static Vector64< ulong > Xor (Vector64< ulong > left, Vector64< ulong > right)
 
static Vector128< byte > Xor (Vector128< byte > left, Vector128< byte > right)
 
static Vector128< double > Xor (Vector128< double > left, Vector128< double > right)
 
static Vector128< shortXor (Vector128< short > left, Vector128< short > right)
 
static Vector128< int > Xor (Vector128< int > left, Vector128< int > right)
 
static Vector128< long > Xor (Vector128< long > left, Vector128< long > right)
 
static Vector128< sbyte > Xor (Vector128< sbyte > left, Vector128< sbyte > right)
 
static Vector128< float > Xor (Vector128< float > left, Vector128< float > right)
 
static Vector128< ushort > Xor (Vector128< ushort > left, Vector128< ushort > right)
 
static Vector128< uint > Xor (Vector128< uint > left, Vector128< uint > right)
 
static Vector128< ulong > Xor (Vector128< ulong > left, Vector128< ulong > right)
 
static Vector128< ushort > ZeroExtendWideningLower (Vector64< byte > value)
 
static Vector128< int > ZeroExtendWideningLower (Vector64< short > value)
 
static Vector128< long > ZeroExtendWideningLower (Vector64< int > value)
 
static Vector128< shortZeroExtendWideningLower (Vector64< sbyte > value)
 
static Vector128< uint > ZeroExtendWideningLower (Vector64< ushort > value)
 
static Vector128< ulong > ZeroExtendWideningLower (Vector64< uint > value)
 
static Vector128< ushort > ZeroExtendWideningUpper (Vector128< byte > value)
 
static Vector128< int > ZeroExtendWideningUpper (Vector128< short > value)
 
static Vector128< long > ZeroExtendWideningUpper (Vector128< int > value)
 
static Vector128< shortZeroExtendWideningUpper (Vector128< sbyte > value)
 
static Vector128< uint > ZeroExtendWideningUpper (Vector128< ushort > value)
 
static Vector128< ulong > ZeroExtendWideningUpper (Vector128< uint > value)
 
static int ReverseElementBits (int value)
 
static uint ReverseElementBits (uint value)
 

Properties

static new bool IsSupported [get]
 

Detailed Description

Definition at line 6 of file Rdm.cs.


The documentation for this class was generated from the following file: