You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3485 lines
154 KiB
3485 lines
154 KiB
using System; |
|
using System.Diagnostics; |
|
|
|
namespace Unity.Burst.Intrinsics |
|
{ |
|
public unsafe static partial class X86 |
|
{ |
|
/// <summary> |
|
/// AVX intrinsics |
|
/// </summary> |
|
public static class Avx |
|
{ |
|
/// <summary> |
|
/// Evaluates to true at compile time if AVX intrinsics are supported. |
|
/// </summary> |
|
public static bool IsAvxSupported { get { return false; } } |
|
|
|
/// <summary> |
|
/// Compare predicates for scalar and packed compare intrinsic functions |
|
/// </summary> |
|
public enum CMP |
|
{ |
|
///<summary> |
|
/// Equal (ordered, nonsignaling) |
|
///</summary> |
|
EQ_OQ = 0x00, |
|
/// <summary> |
|
/// Less-than (ordered, signaling) |
|
/// </summary> |
|
LT_OS = 0x01, |
|
/// <summary> |
|
/// Less-than-or-equal (ordered, signaling) |
|
/// </summary> |
|
LE_OS = 0x02, |
|
/// <summary> |
|
/// Unordered (nonsignaling) |
|
/// </summary> |
|
UNORD_Q = 0x03, |
|
/// <summary> |
|
/// Not-equal (unordered, nonsignaling) |
|
/// </summary> |
|
NEQ_UQ = 0x04, |
|
/// <summary> |
|
/// Not-less-than (unordered, signaling) |
|
/// </summary> |
|
NLT_US = 0x05, |
|
/// <summary> |
|
/// Not-less-than-or-equal (unordered, ignaling) |
|
/// </summary> |
|
NLE_US = 0x06, |
|
/// <summary> |
|
/// Ordered (nonsignaling) |
|
/// </summary> |
|
ORD_Q = 0x07, |
|
/// <summary> |
|
/// Equal (unordered, non-signaling) |
|
/// </summary> |
|
EQ_UQ = 0x08, |
|
/// <summary> |
|
/// Not-greater-than-or-equal (unordered, signaling) |
|
/// </summary> |
|
NGE_US = 0x09, |
|
/// <summary> |
|
/// Not-greater-than (unordered, signaling) |
|
/// </summary> |
|
NGT_US = 0x0A, |
|
/// <summary> |
|
/// False (ordered, nonsignaling) |
|
/// </summary> |
|
FALSE_OQ = 0x0B, |
|
/// <summary> |
|
/// Not-equal (ordered, non-signaling) |
|
/// </summary> |
|
NEQ_OQ = 0x0C, |
|
/// <summary> |
|
/// Greater-than-or-equal (ordered, signaling) |
|
/// </summary> |
|
GE_OS = 0x0D, |
|
/// <summary> |
|
/// Greater-than (ordered, signaling) |
|
/// </summary> |
|
GT_OS = 0x0E, |
|
/// <summary> |
|
/// True (unordered, non-signaling) |
|
/// </summary> |
|
TRUE_UQ = 0x0F, |
|
/// <summary> |
|
/// Equal (ordered, signaling) |
|
/// </summary> |
|
EQ_OS = 0x10, |
|
/// <summary> |
|
/// Less-than (ordered, nonsignaling) |
|
/// </summary> |
|
LT_OQ = 0x11, |
|
/// <summary> |
|
/// Less-than-or-equal (ordered, nonsignaling) |
|
/// </summary> |
|
LE_OQ = 0x12, |
|
/// <summary> |
|
/// Unordered (signaling) |
|
/// </summary> |
|
UNORD_S = 0x13, |
|
/// <summary> |
|
/// Not-equal (unordered, signaling) |
|
/// </summary> |
|
NEQ_US = 0x14, |
|
/// <summary> |
|
/// Not-less-than (unordered, nonsignaling) |
|
/// </summary> |
|
NLT_UQ = 0x15, |
|
/// <summary> |
|
/// Not-less-than-or-equal (unordered, nonsignaling) |
|
/// </summary> |
|
NLE_UQ = 0x16, |
|
/// <summary> |
|
/// Ordered (signaling) |
|
/// </summary> |
|
ORD_S = 0x17, |
|
/// <summary> |
|
/// Equal (unordered, signaling) |
|
/// </summary> |
|
EQ_US = 0x18, |
|
/// <summary> |
|
/// Not-greater-than-or-equal (unordered, nonsignaling) |
|
/// </summary> |
|
NGE_UQ = 0x19, |
|
/// <summary> |
|
/// Not-greater-than (unordered, nonsignaling) |
|
/// </summary> |
|
NGT_UQ = 0x1A, |
|
/// <summary> |
|
/// False (ordered, signaling) |
|
/// </summary> |
|
FALSE_OS = 0x1B, |
|
/// <summary> |
|
/// Not-equal (ordered, signaling) |
|
/// </summary> |
|
NEQ_OS = 0x1C, |
|
/// <summary> |
|
/// Greater-than-or-equal (ordered, nonsignaling) |
|
/// </summary> |
|
GE_OQ = 0x1D, |
|
/// <summary> |
|
/// Greater-than (ordered, nonsignaling) |
|
/// </summary> |
|
GT_OQ = 0x1E, |
|
/// <summary> |
|
/// True (unordered, signaling) |
|
/// </summary> |
|
TRUE_US = 0x1F, |
|
} |
|
|
|
/// <summary> |
|
/// Add packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_add_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.add_pd(a.Lo128, b.Lo128), Sse2.add_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Add packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_add_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.add_ps(a.Lo128, b.Lo128), Sse.add_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Alternatively add and subtract packed double-precision (64-bit) floating-point elements in a to/from packed elements in b, and store the results in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_addsub_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse3.addsub_pd(a.Lo128, b.Lo128), Sse3.addsub_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Alternatively add and subtract packed single-precision (32-bit) floating-point elements in a to/from packed elements in b, and store the results in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_addsub_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse3.addsub_ps(a.Lo128, b.Lo128), Sse3.addsub_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_and_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.and_pd(a.Lo128, b.Lo128), Sse2.and_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_and_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.and_ps(a.Lo128, b.Lo128), Sse.and_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise NOT of packed double-precision (64-bit) floating-point elements in a and then AND with b, and store the results in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_andnot_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.andnot_pd(a.Lo128, b.Lo128), Sse2.andnot_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise NOT of packed single-precision (32-bit) floating-point elements in a and then AND with b, and store the results in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_andnot_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.andnot_ps(a.Lo128, b.Lo128), Sse.andnot_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Blend packed double-precision (64-bit) floating-point elements from a and b using control mask imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VBLENDPD ymm1, ymm2, ymm3/v256, imm8 |
|
/// Double-Precision Floating-Point values from the second source operand are |
|
/// conditionally merged with values from the first source operand and written |
|
/// to the destination. The immediate bits [3:0] determine whether the |
|
/// corresponding Double-Precision Floating Point value in the destination is |
|
/// copied from the second source or first source. If a bit in the mask, |
|
/// corresponding to a word, is "1", then the Double-Precision Floating-Point |
|
/// value in the second source operand is copied, else the value in the first |
|
/// source operand is copied |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">Control mask</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_blend_pd(v256 a, v256 b, int imm8) |
|
{ |
|
return new v256(Sse4_1.blend_pd(a.Lo128, b.Lo128, imm8 & 0x3), Sse4_1.blend_pd(a.Hi128, b.Hi128, imm8 >> 2)); |
|
} |
|
|
|
/// <summary> |
|
/// Blend packed single-precision (32-bit) floating-point elements from a and b using control mask imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VBLENDPS ymm1, ymm2, ymm3/v256, imm8 |
|
/// Single precision floating point values from the second source operand are |
|
/// conditionally merged with values from the first source operand and written |
|
/// to the destination. The immediate bits [7:0] determine whether the |
|
/// corresponding single precision floating-point value in the destination is |
|
/// copied from the second source or first source. If a bit in the mask, |
|
/// corresponding to a word, is "1", then the single-precision floating-point |
|
/// value in the second source operand is copied, else the value in the first |
|
/// source operand is copied |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">Control mask</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_blend_ps(v256 a, v256 b, int imm8) |
|
{ |
|
return new v256(Sse4_1.blend_ps(a.Lo128, b.Lo128, imm8 & 0xf), Sse4_1.blend_ps(a.Hi128, b.Hi128, imm8 >> 4)); |
|
} |
|
|
|
/// <summary> |
|
/// Blend packed double-precision (64-bit) floating-point elements from a and b using mask, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VBLENDVPD ymm1, ymm2, ymm3/v256, ymm4 |
|
/// Conditionally copy each quadword data element of double-precision |
|
/// floating-point value from the second source operand (third operand) and the |
|
/// first source operand (second operand) depending on mask bits defined in the |
|
/// mask register operand (fourth operand). |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="mask">Mask</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_blendv_pd(v256 a, v256 b, v256 mask) |
|
{ |
|
return new v256(Sse4_1.blendv_pd(a.Lo128, b.Lo128, mask.Lo128), Sse4_1.blendv_pd(a.Hi128, b.Hi128, mask.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Blend packed single-precision (32-bit) floating-point elements from a and b using mask, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// Blend Packed Single Precision Floating-Point Values |
|
/// **** VBLENDVPS ymm1, ymm2, ymm3/v256, ymm4 |
|
/// Conditionally copy each dword data element of single-precision |
|
/// floating-point value from the second source operand (third operand) and the |
|
/// first source operand (second operand) depending on mask bits defined in the |
|
/// mask register operand (fourth operand). |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="mask">Mask</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_blendv_ps(v256 a, v256 b, v256 mask) |
|
{ |
|
return new v256(Sse4_1.blendv_ps(a.Lo128, b.Lo128, mask.Lo128), Sse4_1.blendv_ps(a.Hi128, b.Hi128, mask.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VDIVPD ymm1, ymm2, ymm3/v256 |
|
/// Performs an SIMD divide of the four packed double-precision floating-point |
|
/// values in the first source operand by the four packed double-precision |
|
/// floating-point values in the second source operand |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_div_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.div_pd(a.Lo128, b.Lo128), Sse2.div_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Divide packed single-precision (32-bit) floating-point elements in a by packed elements in b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// Divide Packed Single-Precision Floating-Point Values |
|
/// **** VDIVPS ymm1, ymm2, ymm3/v256 |
|
/// Performs an SIMD divide of the eight packed single-precision |
|
/// floating-point values in the first source operand by the eight packed |
|
/// single-precision floating-point values in the second source operand |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_div_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.div_ps(a.Lo128, b.Lo128), Sse.div_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Conditionally multiply the packed single-precision (32-bit) |
|
/// floating-point elements in a and b using the high 4 bits in |
|
/// imm8, sum the four products, and conditionally store the sum in |
|
/// dst using the low 4 bits of imm8. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VDPPS ymm1, ymm2, ymm3/v256, imm8 |
|
/// Multiplies the packed single precision floating point values in the |
|
/// first source operand with the packed single-precision floats in the |
|
/// second source. Each of the four resulting single-precision values is |
|
/// conditionally summed depending on a mask extracted from the high 4 bits |
|
/// of the immediate operand. This sum is broadcast to each of 4 positions |
|
/// in the destination if the corresponding bit of the mask selected from |
|
/// the low 4 bits of the immediate operand is "1". If the corresponding |
|
/// low bit 0-3 of the mask is zero, the destination is set to zero. |
|
/// The process is replicated for the high elements of the destination. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_dp_ps(v256 a, v256 b, int imm8) |
|
{ |
|
return new v256(Sse4_1.dp_ps(a.Lo128, b.Lo128, imm8), Sse4_1.dp_ps(a.Hi128, b.Hi128, imm8)); |
|
} |
|
|
|
/// <summary> |
|
/// Horizontally add adjacent pairs of double-precision (64-bit) floating-point elements in a and b, and pack the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VHADDPD ymm1, ymm2, ymm3/v256 |
|
/// Adds pairs of adjacent double-precision floating-point values in the |
|
/// first source operand and second source operand and stores results in |
|
/// the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_hadd_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse3.hadd_pd(a.Lo128, b.Lo128), Sse3.hadd_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Horizontally add adjacent pairs of single-precision (32-bit) floating-point elements in a and b, and pack the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VHADDPS ymm1, ymm2, ymm3/v256 |
|
/// Adds pairs of adjacent single-precision floating-point values in the |
|
/// first source operand and second source operand and stores results in |
|
/// the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_hadd_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse3.hadd_ps(a.Lo128, b.Lo128), Sse3.hadd_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Horizontally subtract adjacent pairs of double-precision (64-bit) floating-point elements in a and b, and pack the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VHSUBPD ymm1, ymm2, ymm3/v256 |
|
/// Subtract pairs of adjacent double-precision floating-point values in |
|
/// the first source operand and second source operand and stores results |
|
/// in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_hsub_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse3.hsub_pd(a.Lo128, b.Lo128), Sse3.hsub_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Horizontally add adjacent pairs of single-precision (32-bit) floating-point elements in a and b, and pack the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VHSUBPS ymm1, ymm2, ymm3/v256 |
|
/// Subtract pairs of adjacent single-precision floating-point values in |
|
/// the first source operand and second source operand and stores results |
|
/// in the destination. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_hsub_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse3.hsub_ps(a.Lo128, b.Lo128), Sse3.hsub_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed maximum values in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMAXPD ymm1, ymm2, ymm3/v256 |
|
/// Performs an SIMD compare of the packed double-precision floating-point |
|
/// values in the first source operand and the second source operand and |
|
/// returns the maximum value for each pair of values to the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_max_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.max_pd(a.Lo128, b.Lo128), Sse2.max_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed maximum values in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMAXPS ymm1, ymm2, ymm3/v256 |
|
/// Performs an SIMD compare of the packed single-precision floating-point |
|
/// values in the first source operand and the second source operand and |
|
/// returns the maximum value for each pair of values to the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_max_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.max_ps(a.Lo128, b.Lo128), Sse.max_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed minimum values in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMINPD ymm1, ymm2, ymm3/v256 |
|
/// Performs an SIMD compare of the packed double-precision floating-point |
|
/// values in the first source operand and the second source operand and |
|
/// returns the minimum value for each pair of values to the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_min_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.min_pd(a.Lo128, b.Lo128), Sse2.min_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed minimum values in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMINPS ymm1, ymm2, ymm3/v256 |
|
/// Performs an SIMD compare of the packed single-precision floating-point |
|
/// values in the first source operand and the second source operand and |
|
/// returns the minimum value for each pair of values to the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_min_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.min_ps(a.Lo128, b.Lo128), Sse.min_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Multiply packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMULPD ymm1, ymm2, ymm3/v256 |
|
/// Performs a SIMD multiply of the four packed double-precision floating-point |
|
/// values from the first Source operand to the Second Source operand, and |
|
/// stores the packed double-precision floating-point results in the |
|
/// destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_mul_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.mul_pd(a.Lo128, b.Lo128), Sse2.mul_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Multiply packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMULPS ymm1, ymm2, ymm3/v256 |
|
/// Performs an SIMD multiply of the eight packed single-precision |
|
/// floating-point values from the first source operand to the second source |
|
/// operand, and stores the packed double-precision floating-point results in |
|
/// the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_mul_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.mul_ps(a.Lo128, b.Lo128), Sse.mul_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise OR of packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VORPD ymm1, ymm2, ymm3/v256 |
|
/// Performs a bitwise logical OR of the four packed double-precision |
|
/// floating-point values from the first source operand and the second |
|
/// source operand, and stores the result in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_or_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.or_pd(a.Lo128, b.Lo128), Sse2.or_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise OR of packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VORPS ymm1, ymm2, ymm3/v256 |
|
/// Performs a bitwise logical OR of the eight packed single-precision |
|
/// floating-point values from the first source operand and the second |
|
/// source operand, and stores the result in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_or_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.or_ps(a.Lo128, b.Lo128), Sse.or_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle double-precision (64-bit) floating-point elements within 128-bit lanes using the control in imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VSHUFPD ymm1, ymm2, ymm3/v256, imm8 |
|
/// Moves either of the two packed double-precision floating-point values from |
|
/// each double quadword in the first source operand into the low quadword |
|
/// of each double quadword of the destination; moves either of the two packed |
|
/// double-precision floating-point values from the second source operand into |
|
/// the high quadword of each double quadword of the destination operand. |
|
/// The selector operand determines which values are moved to the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_shuffle_pd(v256 a, v256 b, int imm8) |
|
{ |
|
return new v256(Sse2.shuffle_pd(a.Lo128, b.Lo128, imm8 & 3), Sse2.shuffle_pd(a.Hi128, b.Hi128, imm8 >> 2)); |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VSHUFPS ymm1, ymm2, ymm3/v256, imm8 |
|
/// Moves two of the four packed single-precision floating-point values |
|
/// from each double qword of the first source operand into the low |
|
/// quadword of each double qword of the destination; moves two of the four |
|
/// packed single-precision floating-point values from each double qword of |
|
/// the second source operand into to the high quadword of each double qword |
|
/// of the destination. The selector operand determines which values are moved |
|
/// to the destination. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_shuffle_ps(v256 a, v256 b, int imm8) |
|
{ |
|
return new v256(Sse.shuffle_ps(a.Lo128, b.Lo128, imm8), Sse.shuffle_ps(a.Hi128, b.Hi128, imm8)); |
|
} |
|
|
|
/// <summary> |
|
/// Subtract packed double-precision (64-bit) floating-point elements in b from packed double-precision (64-bit) floating-point elements in a, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VSUBPD ymm1, ymm2, ymm3/v256 |
|
/// Performs an SIMD subtract of the four packed double-precision floating-point |
|
/// values of the second Source operand from the first Source operand, and |
|
/// stores the packed double-precision floating-point results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_sub_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.sub_pd(a.Lo128, b.Lo128), Sse2.sub_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Subtract packed single-precision (32-bit) floating-point elements in b from packed single-precision (32-bit) floating-point elements in a, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VSUBPS ymm1, ymm2, ymm3/v256 |
|
/// Performs an SIMD subtract of the eight packed single-precision |
|
/// floating-point values in the second Source operand from the First Source |
|
/// operand, and stores the packed single-precision floating-point results in |
|
/// the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_sub_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.sub_ps(a.Lo128, b.Lo128), Sse.sub_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise XOR of packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VXORPD ymm1, ymm2, ymm3/v256 |
|
/// Performs a bitwise logical XOR of the four packed double-precision |
|
/// floating-point values from the first source operand and the second |
|
/// source operand, and stores the result in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_xor_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.xor_pd(a.Lo128, b.Lo128), Sse2.xor_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise XOR of packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VXORPS ymm1, ymm2, ymm3/v256 |
|
/// Performs a bitwise logical XOR of the eight packed single-precision |
|
/// floating-point values from the first source operand and the second |
|
/// source operand, and stores the result in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_xor_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.xor_ps(a.Lo128, b.Lo128), Sse.xor_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCMPPD xmm1, xmm2, xmm3/v128, imm8 |
|
/// Performs an SIMD compare of the four packed double-precision floating-point |
|
/// values in the second source operand (third operand) and the first source |
|
/// operand (second operand) and returns the results of the comparison to the |
|
/// destination operand (first operand). The comparison predicate operand |
|
/// (immediate) specifies the type of comparison performed on each of the pairs |
|
/// of packed values. |
|
/// For 128-bit intrinsic function with compare predicate values in range 0-7 |
|
/// compiler may generate SSE2 instructions if it is warranted for performance |
|
/// reasons. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 cmp_pd(v128 a, v128 b, int imm8) |
|
{ |
|
switch ((CMP)(imm8 & 0x1F)) |
|
{ |
|
// The first variants map to SSE variants |
|
case CMP.EQ_OQ: return Sse2.cmpeq_pd(a, b); |
|
case CMP.LT_OS: return Sse2.cmplt_pd(a, b); |
|
case CMP.LE_OS: return Sse2.cmple_pd(a, b); |
|
case CMP.UNORD_Q: return Sse2.cmpunord_pd(a, b); |
|
case CMP.NEQ_UQ: return Sse2.cmpneq_pd(a, b); |
|
case CMP.NLT_US: return Sse2.cmpnlt_pd(a, b); |
|
case CMP.NLE_US: return Sse2.cmpnle_pd(a, b); |
|
case CMP.ORD_Q: return Sse2.cmpord_pd(a, b); |
|
|
|
case CMP.EQ_UQ: return Sse2.or_pd(Sse2.cmpeq_pd(a, b), Sse2.cmpunord_pd(a, b)); |
|
case CMP.NGE_UQ: return Sse2.or_pd(Sse2.cmpnge_pd(a, b), Sse2.cmpunord_pd(a, b)); |
|
case CMP.NGT_US: return Sse2.or_pd(Sse2.cmpngt_pd(a, b), Sse2.cmpunord_pd(a, b)); |
|
case CMP.FALSE_OQ: return default; |
|
case CMP.NEQ_OQ: return Sse2.and_pd(Sse2.cmpneq_pd(a, b), Sse2.cmpord_pd(a, b)); |
|
case CMP.GE_OS: return Sse2.and_pd(Sse2.cmpge_pd(a, b), Sse2.cmpord_pd(a, b)); |
|
case CMP.GT_OS: return Sse2.and_pd(Sse2.cmpgt_pd(a, b), Sse2.cmpord_pd(a, b)); |
|
case CMP.TRUE_UQ: return new v128(-1); |
|
|
|
case CMP.EQ_OS: return Sse2.and_pd(Sse2.cmpeq_pd(a, b), Sse2.cmpord_pd(a, b)); |
|
case CMP.LT_OQ: return Sse2.and_pd(Sse2.cmplt_pd(a, b), Sse2.cmpord_pd(a, b)); |
|
case CMP.LE_OQ: return Sse2.and_pd(Sse2.cmple_pd(a, b), Sse2.cmpord_pd(a, b)); |
|
case CMP.UNORD_S: return Sse2.cmpunord_pd(a, b); |
|
case CMP.NEQ_US: return Sse2.cmpneq_pd(a, b); |
|
case CMP.NLT_UQ: return Sse2.or_pd(Sse2.cmpnlt_pd(a, b), Sse2.cmpunord_pd(a, b)); |
|
case CMP.NLE_UQ: return Sse2.or_pd(Sse2.cmpnle_pd(a, b), Sse2.cmpunord_pd(a, b)); |
|
case CMP.ORD_S: return Sse2.cmpord_pd(a, b); |
|
case CMP.EQ_US: return Sse2.or_pd(Sse2.cmpeq_pd(a, b), Sse2.cmpunord_pd(a, b)); |
|
case CMP.NGE_US: return Sse2.or_pd(Sse2.cmpnge_pd(a, b), Sse2.cmpunord_pd(a, b)); |
|
case CMP.NGT_UQ: return Sse2.or_pd(Sse2.cmpngt_pd(a, b), Sse2.cmpunord_pd(a, b)); |
|
case CMP.FALSE_OS: return default; |
|
case CMP.NEQ_OS: return Sse2.and_pd(Sse2.cmpneq_pd(a, b), Sse2.cmpord_pd(a, b)); |
|
case CMP.GE_OQ: return Sse2.and_pd(Sse2.cmpge_pd(a, b), Sse2.cmpord_pd(a, b)); |
|
case CMP.GT_OQ: return Sse2.and_pd(Sse2.cmpgt_pd(a, b), Sse2.cmpord_pd(a, b)); |
|
default: |
|
return new v128(-1); |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCMPPD ymm1, ymm2, ymm3/v256, imm8 |
|
/// Performs an SIMD compare of the four packed double-precision floating-point |
|
/// values in the second source operand (third operand) and the first source |
|
/// operand (second operand) and returns the results of the comparison to the |
|
/// destination operand (first operand). The comparison predicate operand |
|
/// (immediate) specifies the type of comparison performed on each of the pairs |
|
/// of packed values. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_cmp_pd(v256 a, v256 b, int imm8) |
|
{ |
|
return new v256(cmp_pd(a.Lo128, b.Lo128, imm8), cmp_pd(a.Hi128, b.Hi128, imm8)); |
|
} |
|
|
|
/// **** VCMPPS ymm1, ymm2, ymm3/v256, imm8 |
|
/// <summary> |
|
/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCMPPS xmm1, xmm2, xmm3/v256, imm8 |
|
/// Performs a SIMD compare of the packed single-precision floating-point values |
|
/// in the second source operand (third operand) and the first source operand |
|
/// (second operand) and returns the results of the comparison to the |
|
/// destination operand (first operand). The comparison predicate operand |
|
/// (immediate) specifies the type of comparison performed on each of the pairs |
|
/// of packed values. |
|
/// For 128-bit intrinsic function with compare predicate values in range 0-7 |
|
/// compiler may generate SSE2 instructions if it is warranted for performance |
|
/// reasons. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 cmp_ps(v128 a, v128 b, int imm8) |
|
{ |
|
switch ((CMP)(imm8 & 0x1F)) |
|
{ |
|
// The first variants map to SSE variants |
|
case CMP.EQ_OQ: return Sse.cmpeq_ps(a, b); |
|
case CMP.LT_OS: return Sse.cmplt_ps(a, b); |
|
case CMP.LE_OS: return Sse.cmple_ps(a, b); |
|
case CMP.UNORD_Q: return Sse.cmpunord_ps(a, b); |
|
case CMP.NEQ_UQ: return Sse.cmpneq_ps(a, b); |
|
case CMP.NLT_US: return Sse.cmpnlt_ps(a, b); |
|
case CMP.NLE_US: return Sse.cmpnle_ps(a, b); |
|
case CMP.ORD_Q: return Sse.cmpord_ps(a, b); |
|
|
|
case CMP.EQ_UQ: return Sse.or_ps(Sse.cmpeq_ps(a, b), Sse.cmpunord_ps(a, b)); |
|
case CMP.NGE_UQ: return Sse.or_ps(Sse.cmpnge_ps(a, b), Sse.cmpunord_ps(a, b)); |
|
case CMP.NGT_US: return Sse.or_ps(Sse.cmpngt_ps(a, b), Sse.cmpunord_ps(a, b)); |
|
case CMP.FALSE_OQ: return default; |
|
case CMP.NEQ_OQ: return Sse.and_ps(Sse.cmpneq_ps(a, b), Sse.cmpord_ps(a, b)); |
|
case CMP.GE_OS: return Sse.and_ps(Sse.cmpge_ps(a, b), Sse.cmpord_ps(a, b)); |
|
case CMP.GT_OS: return Sse.and_ps(Sse.cmpgt_ps(a, b), Sse.cmpord_ps(a, b)); |
|
case CMP.TRUE_UQ: return new v128(-1); |
|
|
|
case CMP.EQ_OS: return Sse.and_ps(Sse.cmpeq_ps(a, b), Sse.cmpord_ps(a, b)); |
|
case CMP.LT_OQ: return Sse.and_ps(Sse.cmplt_ps(a, b), Sse.cmpord_ps(a, b)); |
|
case CMP.LE_OQ: return Sse.and_ps(Sse.cmple_ps(a, b), Sse.cmpord_ps(a, b)); |
|
case CMP.UNORD_S: return Sse.cmpunord_ps(a, b); |
|
case CMP.NEQ_US: return Sse.cmpneq_ps(a, b); |
|
case CMP.NLT_UQ: return Sse.or_ps(Sse.cmpnlt_ps(a, b), Sse.cmpunord_ps(a, b)); |
|
case CMP.NLE_UQ: return Sse.or_ps(Sse.cmpnle_ps(a, b), Sse.cmpunord_ps(a, b)); |
|
case CMP.ORD_S: return Sse.cmpord_ps(a, b); |
|
case CMP.EQ_US: return Sse.or_ps(Sse.cmpeq_ps(a, b), Sse.cmpunord_ps(a, b)); |
|
case CMP.NGE_US: return Sse.or_ps(Sse.cmpnge_ps(a, b), Sse.cmpunord_ps(a, b)); |
|
case CMP.NGT_UQ: return Sse.or_ps(Sse.cmpngt_ps(a, b), Sse.cmpunord_ps(a, b)); |
|
case CMP.FALSE_OS: return default; |
|
case CMP.NEQ_OS: return Sse.and_ps(Sse.cmpneq_ps(a, b), Sse.cmpord_ps(a, b)); |
|
case CMP.GE_OQ: return Sse.and_ps(Sse.cmpge_ps(a, b), Sse.cmpord_ps(a, b)); |
|
case CMP.GT_OQ: return Sse.and_ps(Sse.cmpgt_ps(a, b), Sse.cmpord_ps(a, b)); |
|
default: |
|
return new v128(-1); |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCMPPS xmm1, xmm2, xmm3/v256, imm8 |
|
/// Performs a SIMD compare of the packed single-precision floating-point values |
|
/// in the second source operand (third operand) and the first source operand |
|
/// (second operand) and returns the results of the comparison to the |
|
/// destination operand (first operand). The comparison predicate operand |
|
/// (immediate) specifies the type of comparison performed on each of the pairs |
|
/// of packed values. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_cmp_ps(v256 a, v256 b, int imm8) |
|
{ |
|
return new v256(cmp_ps(a.Lo128, b.Lo128, imm8), cmp_ps(a.Hi128, b.Hi128, imm8)); |
|
} |
|
|
|
/// <summary> |
|
/// Compare the lower double-precision (64-bit) floating-point |
|
/// element in a and b based on the comparison operand specified by |
|
/// imm8, store the result in the lower element of dst, and copy |
|
/// the upper element from a to the upper element of dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCMPSD xmm1, xmm2, xmm3/m64, imm8 |
|
/// Compares the low double-precision floating-point values in the second source |
|
/// operand (third operand) and the first source operand (second operand) and |
|
/// returns the results in of the comparison to the destination operand (first |
|
/// operand). The comparison predicate operand (immediate operand) specifies the |
|
/// type of comparison performed. |
|
/// For compare predicate values in range 0-7 compiler may generate SSE2 |
|
/// instructions if it is warranted for performance reasons. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 cmp_sd(v128 a, v128 b, int imm8) |
|
{ |
|
v128 full = cmp_pd(a, b, imm8); |
|
return new v128(full.ULong0, a.ULong1); |
|
} |
|
|
|
/// <summary> |
|
/// Compare the lower single-precision (32-bit) floating-point |
|
/// element in a and b based on the comparison operand specified by |
|
/// imm8, store the result in the lower element of dst, and copy |
|
/// the upper 3 packed elements from a to the upper elements of |
|
/// dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCMPSS xmm1, xmm2, xmm3/m64, imm8 |
|
/// Compares the low single-precision floating-point values in the second source |
|
/// operand (third operand) and the first source operand (second operand) and |
|
/// returns the results of the comparison to the destination operand (first |
|
/// operand). The comparison predicate operand (immediate operand) specifies |
|
/// the type of comparison performed. |
|
/// For compare predicate values in range 0-7 compiler may generate SSE2 |
|
/// instructions if it is warranted for performance reasons. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 cmp_ss(v128 a, v128 b, int imm8) |
|
{ |
|
v128 full = cmp_ps(a, b, imm8); |
|
return new v128(full.UInt0, a.UInt1, a.UInt2, a.UInt3); |
|
} |
|
|
|
/// <summary> |
|
/// Convert packed 32-bit integers in a to packed double-precision (64-bit) floating-point elements, and store the results in dst. |
|
/// </summary> |
|
/// <param name="a"></param> |
|
/// <remarks> |
|
/// **** VCVTDQ2PD ymm1, xmm2/v128 |
|
/// Converts four packed signed doubleword integers in the source operand to |
|
/// four packed double-precision floating-point values in the destination |
|
/// </remarks> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_cvtepi32_pd(v128 a) |
|
{ |
|
return new v256((double)a.SInt0, (double)a.SInt1, (double)a.SInt2, (double)a.SInt3); |
|
} |
|
|
|
/// <summary> |
|
/// Convert packed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCVTDQ2PS ymm1, ymm2/v256 |
|
/// Converts eight packed signed doubleword integers in the source operand to |
|
/// eight packed double-precision floating-point values in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_cvtepi32_ps(v256 a) |
|
{ |
|
return new v256(Sse2.cvtepi32_ps(a.Lo128), Sse2.cvtepi32_ps(a.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Convert packed double-precision (64-bit) floating-point |
|
/// elements in a to packed single-precision (32-bit) |
|
/// floating-point elements, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCVTPD2PS xmm1, ymm2/v256 |
|
/// Converts four packed double-precision floating-point values in the source |
|
/// operand to four packed single-precision floating-point values in the |
|
/// destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 mm256_cvtpd_ps(v256 a) |
|
{ |
|
v128 lo = Sse2.cvtpd_ps(a.Lo128); |
|
v128 hi = Sse2.cvtpd_ps(a.Hi128); |
|
return new v128(lo.Float0, lo.Float1, hi.Float0, hi.Float1); |
|
} |
|
|
|
/// <summary> |
|
/// Convert packed single-precision (32-bit) floating-point |
|
/// elements in a to packed 32-bit integers, and store the results |
|
/// in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCVTPS2DQ ymm1, ymm2/v256 |
|
/// Converts eight packed single-precision floating-point values in the source |
|
/// operand to eight signed doubleword integers in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_cvtps_epi32(v256 a) |
|
{ |
|
return new v256(Sse2.cvtps_epi32(a.Lo128), Sse2.cvtps_epi32(a.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Convert packed single-precision (32-bit) floating-point |
|
/// elements in a to packed double-precision (64-bit) |
|
/// floating-point elements, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCVTPS2PD ymm1, xmm2/v128 |
|
/// Converts four packed single-precision floating-point values in the source |
|
/// operand to four packed double-precision floating-point values in the |
|
/// destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_cvtps_pd(v128 a) |
|
{ |
|
// The normal Burst IR does fine here. |
|
return new v256(a.Float0, a.Float1, a.Float2, a.Float3); |
|
} |
|
|
|
/// <summary> |
|
/// Convert packed double-precision (64-bit) floating-point |
|
/// elements in a to packed 32-bit integers with truncation, and |
|
/// store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCVTTPD2DQ xmm1, ymm2/v256 |
|
/// Converts four packed double-precision floating-point values in the source |
|
/// operand to four packed signed doubleword integers in the destination. |
|
/// When a conversion is inexact, a truncated (round toward zero) value is |
|
/// returned. If a converted result is larger than the maximum signed doubleword |
|
/// integer, the floating-point invalid exception is raised, and if this |
|
/// exception is masked, the indefinite integer value (80000000H) is returned |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 mm256_cvttpd_epi32(v256 a) |
|
{ |
|
return new v128((int)a.Double0, (int)a.Double1, (int)a.Double2, (int)a.Double3); |
|
} |
|
|
|
/// <summary> |
|
/// Convert packed double-precision(64-bit) floating-point elements |
|
/// in a to packed 32-bit integers, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCVTPD2DQ xmm1, ymm2/v256 |
|
/// Converts four packed double-precision floating-point values in the source |
|
/// operand to four packed signed doubleword integers in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v128 mm256_cvtpd_epi32(v256 a) |
|
{ |
|
v128 q = Sse2.cvtpd_epi32(new v128(a.Double0, a.Double1)); |
|
v128 r = Sse2.cvtpd_epi32(new v128(a.Double2, a.Double3)); |
|
return new v128(q.SInt0, q.SInt1, r.SInt0, r.SInt1); |
|
} |
|
|
|
/// <summary> |
|
/// Convert packed single-precision (32-bit) floating-point |
|
/// elements in a to packed 32-bit integers with truncation, and |
|
/// store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VCVTTPS2DQ ymm1, ymm2/v256 |
|
/// Converts eight packed single-precision floating-point values in the source |
|
/// operand to eight signed doubleword integers in the destination. |
|
/// When a conversion is inexact, a truncated (round toward zero) value is |
|
/// returned. If a converted result is larger than the maximum signed doubleword |
|
/// integer, the floating-point invalid exception is raised, and if this |
|
/// exception is masked, the indefinite integer value (80000000H) is returned |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_cvttps_epi32(v256 a) |
|
{ |
|
return new v256(Sse2.cvttps_epi32(a.Lo128), Sse2.cvttps_epi32(a.Hi128)); |
|
} |
|
|
|
/* |
|
* Convert Scalar Single-Precision Floating-point value in 256-bit vector to |
|
* equivalent C/C++ float type. |
|
*/ |
|
/// <summary> |
|
/// Copy the lower single-precision (32-bit) floating-point element of a to dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// Identical in HPC# to accessing Float0, kept for compatibility with existing code while porting. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Float</returns> |
|
[DebuggerStepThrough] |
|
public static float mm256_cvtss_f32(v256 a) |
|
{ |
|
// Burst IR is fine here. |
|
return a.Float0; |
|
} |
|
|
|
/// <summary> |
|
/// Extract 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from a, selected with imm8, and store the result in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VEXTRACTF128 xmm1/v128, ymm2, imm8 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 mm256_extractf128_ps(v256 a, int imm8) |
|
{ |
|
return imm8 != 0 ? a.Hi128 : a.Lo128; |
|
} |
|
|
|
/// <summary> |
|
/// Extract 128 bits (composed of 2 packed double-precision (64-bit) floating-point elements) from a, selected with imm8, and store the result in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VEXTRACTF128 xmm1/v128, ymm2, imm8 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 mm256_extractf128_pd(v256 a, int imm8) |
|
{ |
|
return imm8 != 0 ? a.Hi128 : a.Lo128; |
|
} |
|
|
|
/// <summary> |
|
/// Extract 128 bits (composed of integer data) from a, selected with imm8, and store the result in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VEXTRACTF128 xmm1/v128, ymm2, imm8 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 mm256_extractf128_si256(v256 a, int imm8) |
|
{ |
|
return imm8 != 0 ? a.Hi128 : a.Lo128; |
|
} |
|
|
|
/// <summary> |
|
/// Zeros the contents of all YMM registers |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VZEROALL |
|
/// </remarks> |
|
[DebuggerStepThrough] |
|
public static void mm256_zeroall() |
|
{ |
|
// This is a no-op in C# land |
|
} |
|
|
|
/// <summary> |
|
/// Zero the upper 128 bits of all YMM registers; the lower 128-bits of the registers are unmodified. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VZEROUPPER |
|
/// </remarks> |
|
[DebuggerStepThrough] |
|
public static void mm256_zeroupper() |
|
{ |
|
// This is a no-op in C# land |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle single-precision (32-bit) floating-point elements in a using the control in b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERMILPS xmm1, xmm2, xmm3/v128 |
|
/// Permute Single-Precision Floating-Point values in the first source operand |
|
/// using 8-bit control fields in the low bytes of corresponding elements the |
|
/// shuffle control and store results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 permutevar_ps(v128 a, v128 b) |
|
{ |
|
v128 dst = default; |
|
uint* dptr = &dst.UInt0; |
|
uint* aptr = &a.UInt0; |
|
int* bptr = &b.SInt0; |
|
|
|
for (int i = 0; i < 4; ++i) |
|
{ |
|
int ndx = bptr[i] & 3; |
|
dptr[i] = aptr[ndx]; |
|
} |
|
|
|
return dst; |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERMILPS ymm1, ymm2, ymm3/v256 |
|
/// Permute Single-Precision Floating-Point values in the first source operand |
|
/// using 8-bit control fields in the low bytes of corresponding elements the |
|
/// shuffle control and store results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_permutevar_ps(v256 a, v256 b) |
|
{ |
|
return new v256(permutevar_ps(a.Lo128, b.Lo128), permutevar_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle single-precision (32-bit) floating-point elements in a using the control in imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERMILPS xmm1, xmm2/v128, imm8 |
|
/// Permute Single-Precision Floating-Point values in the first source operand |
|
/// using four 2-bit control fields in the 8-bit immediate and store results |
|
/// in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 permute_ps(v128 a, int imm8) |
|
{ |
|
return Sse2.shuffle_epi32(a, imm8); |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle single-precision (32-bit) floating-point elements in a |
|
/// within 128-bit lanes using the control in imm8, and store the |
|
/// results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERMILPS ymm1, ymm2/v256, imm8 |
|
/// Permute Single-Precision Floating-Point values in the first source operand |
|
/// using four 2-bit control fields in the 8-bit immediate and store results |
|
/// in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_permute_ps(v256 a, int imm8) |
|
{ |
|
return new v256(permute_ps(a.Lo128, imm8), permute_ps(a.Hi128, imm8)); |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle double-precision (64-bit) floating-point elements in a using the control in b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERMILPD xmm1, xmm2, xmm3/v128 |
|
/// Permute Double-Precision Floating-Point values in the first source operand |
|
/// using 8-bit control fields in the low bytes of the second source operand |
|
/// and store results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 permutevar_pd(v128 a, v128 b) |
|
{ |
|
v128 dst = default; |
|
double* dptr = &dst.Double0; |
|
double* aptr = &a.Double0; |
|
dptr[0] = aptr[(int)(b.SLong0 & 2) >> 1]; |
|
dptr[1] = aptr[(int)(b.SLong1 & 2) >> 1]; |
|
return dst; |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERMILPD ymm1, ymm2, ymm3/v256 |
|
/// Permute Double-Precision Floating-Point values in the first source operand |
|
/// using 8-bit control fields in the low bytes of the second source operand |
|
/// and store results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_permutevar_pd(v256 a, v256 b) |
|
{ |
|
v256 dst = default; |
|
double* dptr = &dst.Double0; |
|
double* aptr = &a.Double0; |
|
dptr[0] = aptr[(int)(b.SLong0 & 2) >> 1]; |
|
dptr[1] = aptr[(int)(b.SLong1 & 2) >> 1]; |
|
dptr[2] = aptr[2 + ((int)(b.SLong2 & 2) >> 1)]; |
|
dptr[3] = aptr[2 + ((int)(b.SLong3 & 2) >> 1)]; |
|
return dst; |
|
} |
|
|
|
/* |
|
* Permute Double-Precision Floating-Point Values |
|
*/ |
|
/// <summary> |
|
/// Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERMILPD ymm1, ymm2/v256, imm8 |
|
/// Permute Double-Precision Floating-Point values in the first source operand |
|
/// using two, 1-bit control fields in the low 2 bits of the 8-bit immediate |
|
/// and store results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_permute_pd(v256 a, int imm8) |
|
{ |
|
return new v256(permute_pd(a.Lo128, imm8 & 3), permute_pd(a.Hi128, imm8 >> 2)); |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle double-precision (64-bit) floating-point elements in a using the control in imm8, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERMILPD xmm1, xmm2/v128, imm8 |
|
/// Permute Double-Precision Floating-Point values in the first source operand |
|
/// using two, 1-bit control fields in the low 2 bits of the 8-bit immediate |
|
/// and store results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 permute_pd(v128 a, int imm8) |
|
{ |
|
v128 dst = default; |
|
double* dptr = &dst.Double0; |
|
double* aptr = &a.Double0; |
|
dptr[0] = aptr[imm8 & 1]; |
|
dptr[1] = aptr[(imm8 >> 1) & 1]; |
|
return dst; |
|
} |
|
|
|
private static v128 Select4(v256 src1, v256 src2, int control) |
|
{ |
|
switch (control & 3) |
|
{ |
|
case 0: return src1.Lo128; |
|
case 1: return src1.Hi128; |
|
case 2: return src2.Lo128; |
|
default: return src2.Hi128; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle 128-bits (composed of 4 packed single-precision (32-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERM2F128 ymm1, ymm2, ymm3/v256, imm8 |
|
/// Permute 128 bit floating-point-containing fields from the first source |
|
/// operand and second source operand using bits in the 8-bit immediate and |
|
/// store results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_permute2f128_ps(v256 a, v256 b, int imm8) |
|
{ |
|
return new v256(Select4(a, b, imm8), Select4(a, b, imm8 >> 4)); |
|
} |
|
|
|
/// <summary> |
|
/// Shuffle 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERM2F128 ymm1, ymm2, ymm3/v256, imm8 |
|
/// Permute 128 bit floating-point-containing fields from the first source |
|
/// operand and second source operand using bits in the 8-bit immediate and |
|
/// store results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_permute2f128_pd(v256 a, v256 b, int imm8) |
|
{ |
|
return mm256_permute2f128_ps(a, b, imm8); |
|
} |
|
|
|
|
|
/// <summary> |
|
/// Shuffle 128-bits (composed of integer data) selected by imm8 from a and b, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VPERM2F128 ymm1, ymm2, ymm3/v256, imm8 |
|
/// Permute 128 bit floating-point-containing fields from the first source |
|
/// operand and second source operand using bits in the 8-bit immediate and |
|
/// store results in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_permute2f128_si256(v256 a, v256 b, int imm8) |
|
{ |
|
return mm256_permute2f128_ps(a, b, imm8); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast a single-precision (32-bit) floating-point element from memory to all elements of dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VBROADCASTSS ymm1, m32 |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_broadcast_ss(void* ptr) |
|
{ |
|
return new v256(*(float*)ptr); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast a single-precision (32-bit) floating-point element from memory to all elements of dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VBROADCASTSS xmm1, m32 |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 broadcast_ss(void* ptr) |
|
{ |
|
return new v128(*(float*)ptr); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast a double-precision (64-bit) floating-point element from memory to all elements of dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VBROADCASTSD ymm1, m64 |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_broadcast_sd(void* ptr) |
|
{ |
|
return new v256(*(double*)ptr); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast 128 bits from memory (composed of 4 packed single-precision (32-bit) floating-point elements) to all elements of dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VBROADCASTF128 ymm1, v128 |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_broadcast_ps(void* ptr) |
|
{ |
|
v128 a = Sse.loadu_ps(ptr); |
|
return new v256(a, a); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast 128 bits from memory (composed of 2 packed double-precision (64-bit) floating-point elements) to all elements of dst. |
|
/// </summary> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns> |
|
/// **** VBROADCASTF128 ymm1, v128 |
|
/// </returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_broadcast_pd(void* ptr) |
|
{ |
|
return mm256_broadcast_ps(ptr); |
|
} |
|
|
|
/// <summary> |
|
/// Copy a to dst, then insert 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from b into dst at the location specified by imm8. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VINSERTF128 ymm1, ymm2, xmm3/v128, imm8 |
|
/// Performs an insertion of 128-bits of packed floating-point values from the |
|
/// second source operand into an the destination at an 128-bit offset from |
|
/// imm8[0]. The remaining portions of the destination are written by the |
|
/// corresponding fields of the first source operand |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_insertf128_ps(v256 a, v128 b, int imm8) |
|
{ |
|
if (0 == (imm8 & 1)) |
|
return new v256(b, a.Hi128); |
|
else |
|
return new v256(a.Lo128, b); |
|
} |
|
|
|
/// <summary> |
|
/// Copy a to dst, then insert 128 bits (composed of 2 packed double-precision (64-bit) floating-point elements) from b into dst at the location specified by imm8. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VINSERTF128 ymm1, ymm2, xmm3/v128, imm8 |
|
/// Performs an insertion of 128-bits of packed floating-point values from the |
|
/// second source operand into an the destination at an 128-bit offset from |
|
/// imm8[0]. The remaining portions of the destination are written by the |
|
/// corresponding fields of the first source operand |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_insertf128_pd(v256 a, v128 b, int imm8) |
|
{ |
|
return mm256_insertf128_ps(a, b, imm8); |
|
} |
|
|
|
/// <summary> |
|
/// Copy a to dst, then insert 128 bits of integer data from b into dst at the location specified by imm8. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VINSERTF128 ymm1, ymm2, xmm3/v128, imm8 |
|
/// Performs an insertion of 128-bits of packed floating-point values from the |
|
/// second source operand into an the destination at an 128-bit offset from |
|
/// imm8[0]. The remaining portions of the destination are written by the |
|
/// corresponding fields of the first source operand |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <param name="imm8">imm8</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_insertf128_si256(v256 a, v128 b, int imm8) |
|
{ |
|
return mm256_insertf128_ps(a, b, imm8); |
|
} |
|
|
|
/// <summary> |
|
/// Load 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVUPS ymm1, v256 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_load_ps(void* ptr) |
|
{ |
|
return *(v256*)ptr; |
|
} |
|
|
|
/// <summary> |
|
/// Store 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from a into memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVUPS v256, ymm1 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <param name="val">Value</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_store_ps(void* ptr, v256 val) |
|
{ |
|
*(v256*)ptr = val; |
|
} |
|
|
|
/// <summary> |
|
/// Load 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVUPS ymm1, v256 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_load_pd(void* ptr) |
|
{ |
|
return mm256_load_ps(ptr); |
|
} |
|
|
|
/// <summary> |
|
/// Store 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from a into memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVUPS v256, ymm1 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_store_pd(void* ptr, v256 a) |
|
{ |
|
mm256_store_ps(ptr, a); |
|
} |
|
|
|
/// <summary> |
|
/// Load 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVUPS ymm1, v256 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_loadu_pd(void* ptr) |
|
{ |
|
return mm256_load_ps(ptr); |
|
} |
|
|
|
/// <summary> |
|
/// Store 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from a into memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVUPS v256, ymm1 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_storeu_pd(void* ptr, v256 a) |
|
{ |
|
mm256_store_ps(ptr, a); |
|
} |
|
|
|
/// <summary> |
|
/// Load 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVUPS ymm1, v256 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_loadu_ps(void* ptr) |
|
{ |
|
return mm256_load_ps(ptr); |
|
} |
|
|
|
/// <summary> |
|
/// Store 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from a into memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVUPS v256, ymm1 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_storeu_ps(void* ptr, v256 a) |
|
{ |
|
mm256_store_ps(ptr, a); |
|
} |
|
|
|
/// <summary> |
|
/// Load 256-bits (composed of 8 packed 32-bit integers elements) from memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVDQU ymm1, v256 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_load_si256(void* ptr) |
|
{ |
|
return mm256_load_ps(ptr); |
|
} |
|
|
|
/// <summary> |
|
/// Store 256-bits (composed of 8 packed 32-bit integer elements) from a into memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVDQU v256, ymm1 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <param name="v">Vector</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_store_si256(void* ptr, v256 v) |
|
{ |
|
mm256_store_ps(ptr, v); |
|
} |
|
|
|
/// <summary> |
|
/// Load 256-bits (composed of 8 packed 32-bit integers elements) from memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVDQU ymm1, v256 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_loadu_si256(void* ptr) |
|
{ |
|
return mm256_load_ps(ptr); |
|
} |
|
|
|
/// <summary> |
|
/// Store 256-bits (composed of 8 packed 32-bit integer elements) from a into memory |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVDQU v256, ymm1 |
|
/// Burst only generates unaligned stores. |
|
/// </remarks> |
|
/// <param name="ptr">Pointer</param> |
|
/// <param name="v">Vector</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_storeu_si256(void* ptr, v256 v) |
|
{ |
|
mm256_store_ps(ptr, v); |
|
} |
|
|
|
/// <summary> |
|
/// Load two 128-bit values (composed of 4 packed single-precision |
|
/// (32-bit) floating-point elements) from memory, and combine them |
|
/// into a 256-bit value in dst. hiaddr and loaddr do not need to |
|
/// be aligned on any particular boundary. |
|
/// </summary> |
|
/// <remarks> |
|
/// This is a composite function which can generate more than one instruction. |
|
/// </remarks> |
|
/// <param name="hiaddr">High address pointer</param> |
|
/// <param name="loaddr">Low address pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_loadu2_m128(void* hiaddr, void* loaddr) |
|
{ |
|
return mm256_set_m128(Sse.loadu_ps(hiaddr), Sse.loadu_ps(loaddr)); |
|
} |
|
|
|
/// <summary> |
|
/// Load two 128-bit values (composed of 2 packed double-precision |
|
/// (64-bit) floating-point elements) from memory, and combine them |
|
/// into a 256-bit value in dst. hiaddr and loaddr do not need to |
|
/// be aligned on any particular boundary. |
|
/// </summary> |
|
/// <remarks> |
|
/// This is a composite function which can generate more than one instruction. |
|
/// </remarks> |
|
/// <param name="hiaddr">High address pointer</param> |
|
/// <param name="loaddr">Low address pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_loadu2_m128d(void* hiaddr, void* loaddr) |
|
{ |
|
return mm256_loadu2_m128(hiaddr, loaddr); |
|
} |
|
|
|
/// <summary> |
|
/// Load two 128-bit values (composed of integer data) from memory, |
|
/// and combine them into a 256-bit value in dst. hiaddr and loaddr |
|
/// do not need to be aligned on any particular boundary. |
|
/// </summary> |
|
/// <remarks> |
|
/// This is a composite function which can generate more than one instruction. |
|
/// </remarks> |
|
/// <param name="hiaddr">High address pointer</param> |
|
/// <param name="loaddr">Low address pointer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_loadu2_m128i(void* hiaddr, void* loaddr) |
|
{ |
|
return mm256_loadu2_m128(hiaddr, loaddr); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed __m256 vector dst with the supplied values. |
|
/// </summary> |
|
/// <remarks> |
|
/// This is a composite function which can generate more than one instruction. |
|
/// </remarks> |
|
/// <param name="hi">High half of the vector</param> |
|
/// <param name="lo">Low half of the vector</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set_m128(v128 hi, v128 lo) |
|
{ |
|
return new v256(lo, hi); |
|
} |
|
|
|
/// <summary> |
|
/// Store the high and low 128-bit halves (each composed of 4 |
|
/// packed single-precision (32-bit) floating-point elements) from |
|
/// a into memory two different 128-bit locations. hiaddr and |
|
/// loaddr do not need to be aligned on any particular boundary. |
|
/// </summary> |
|
/// <remarks> |
|
/// This is a composite function which can generate more than one instruction. |
|
/// </remarks> |
|
/// <param name="hiaddr">High address pointer</param> |
|
/// <param name="loaddr">Low address pointer</param> |
|
/// <param name="val">Value</param> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static void mm256_storeu2_m128(void* hiaddr, void* loaddr, v256 val) |
|
{ |
|
Sse.storeu_ps(hiaddr, val.Hi128); |
|
Sse.storeu_ps(loaddr, val.Lo128); |
|
} |
|
|
|
/// <summary> |
|
/// Store the high and low 128-bit halves (each composed of 2 |
|
/// packed double-precision (64-bit) floating-point elements) from |
|
/// a into memory two different 128-bit locations. hiaddr and |
|
/// loaddr do not need to be aligned on any particular boundary. |
|
/// </summary> |
|
/// <remarks> |
|
/// This is a composite function which can generate more than one instruction. |
|
/// </remarks> |
|
/// <param name="hiaddr">High address pointer</param> |
|
/// <param name="loaddr">Low address pointer</param> |
|
/// <param name="val">Value</param> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static void mm256_storeu2_m128d(void* hiaddr, void* loaddr, v256 val) |
|
{ |
|
Sse.storeu_ps(hiaddr, val.Hi128); |
|
Sse.storeu_ps(loaddr, val.Lo128); |
|
} |
|
|
|
/// <summary> |
|
/// Store the high and low 128-bit halves (each composed of integer |
|
/// data) from a into memory two different 128-bit locations. hiaddr |
|
/// and loaddr do not need to be aligned on any particular boundary. |
|
/// </summary> |
|
/// <remarks> |
|
/// This is a composite function which can generate more than one instruction. |
|
/// </remarks> |
|
/// <param name="hiaddr">High address pointer</param> |
|
/// <param name="loaddr">Low address pointer</param> |
|
/// <param name="val">Value</param> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static void mm256_storeu2_m128i(void* hiaddr, void* loaddr, v256 val) |
|
{ |
|
Sse.storeu_ps(hiaddr, val.Hi128); |
|
Sse.storeu_ps(loaddr, val.Lo128); |
|
} |
|
|
|
/// <summary> |
|
/// Load packed double-precision (64-bit) floating-point elements |
|
/// from memory into dst using mask (elements are zeroed out when |
|
/// the high bit of the corresponding element is not set). |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMASKMOVPD xmm1, xmm2, v128 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="mask">Mask</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 maskload_pd(void* mem_addr, v128 mask) |
|
{ |
|
ulong* addr = (ulong*)mem_addr; |
|
v128 result = default; |
|
if (mask.SLong0 < 0) result.ULong0 = addr[0]; |
|
if (mask.SLong1 < 0) result.ULong1 = addr[1]; |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// Load packed double-precision (64-bit) floating-point elements |
|
/// from memory into dst using mask (elements are zeroed out when |
|
/// the high bit of the corresponding element is not set). |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMASKMOVPD ymm1, ymm2, v256 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="mask">Mask</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_maskload_pd(void* mem_addr, v256 mask) |
|
{ |
|
return new v256(maskload_pd(mem_addr, mask.Lo128), maskload_pd(((byte*)mem_addr) + 16, mask.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Store packed double-precision (64-bit) floating-point elements from a into memory using mask. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMASKMOVPD v128, xmm1, xmm2 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="mask">Mask</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void maskstore_pd(void* mem_addr, v128 mask, v128 a) |
|
{ |
|
ulong* addr = (ulong*)mem_addr; |
|
if (mask.SLong0 < 0) addr[0] = a.ULong0; |
|
if (mask.SLong1 < 0) addr[1] = a.ULong1; |
|
} |
|
|
|
/// <summary> |
|
/// Store packed double-precision (64-bit) floating-point elements from a into memory using mask. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMASKMOVPD v256, ymm1, ymm2 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="mask">Mask</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_maskstore_pd(void* mem_addr, v256 mask, v256 a) |
|
{ |
|
maskstore_pd(mem_addr, mask.Lo128, a.Lo128); |
|
maskstore_pd(((byte*)mem_addr) + 16, mask.Hi128, a.Hi128); |
|
} |
|
|
|
/// <summary> |
|
/// Load packed single-precision (32-bit) floating-point elements |
|
/// from memory into dst using mask (elements are zeroed out when |
|
/// the high bit of the corresponding element is not set). |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMASKMOVPS xmm1, xmm2, v128 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="mask">Mask</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 maskload_ps(void* mem_addr, v128 mask) |
|
{ |
|
uint* addr = (uint*)mem_addr; |
|
v128 result = default; |
|
if (mask.SInt0 < 0) result.UInt0 = addr[0]; |
|
if (mask.SInt1 < 0) result.UInt1 = addr[1]; |
|
if (mask.SInt2 < 0) result.UInt2 = addr[2]; |
|
if (mask.SInt3 < 0) result.UInt3 = addr[3]; |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// Load packed single-precision (32-bit) floating-point elements |
|
/// from memory into dst using mask (elements are zeroed out when |
|
/// the high bit of the corresponding element is not set). |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMASKMOVPS ymm1, ymm2, v256 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="mask">Mask</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_maskload_ps(void* mem_addr, v256 mask) |
|
{ |
|
return new v256(maskload_ps(mem_addr, mask.Lo128), maskload_ps(((byte*)mem_addr) + 16, mask.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Store packed single-precision (32-bit) floating-point elements from a into memory using mask. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMASKMOVPS v128, xmm1, xmm2 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="mask">Mask</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void maskstore_ps(void* mem_addr, v128 mask, v128 a) |
|
{ |
|
uint* addr = (uint*)mem_addr; |
|
if (mask.SInt0 < 0) addr[0] = a.UInt0; |
|
if (mask.SInt1 < 0) addr[1] = a.UInt1; |
|
if (mask.SInt2 < 0) addr[2] = a.UInt2; |
|
if (mask.SInt3 < 0) addr[3] = a.UInt3; |
|
} |
|
|
|
/// <summary> |
|
/// Store packed single-precision (32-bit) floating-point elements from a into memory using mask. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMASKMOVPS v256, ymm1, ymm2 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="mask">Mask</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_maskstore_ps(void* mem_addr, v256 mask, v256 a) |
|
{ |
|
maskstore_ps(mem_addr, mask.Lo128, a.Lo128); |
|
maskstore_ps(((byte*)mem_addr) + 16, mask.Hi128, a.Hi128); |
|
} |
|
|
|
/* |
|
* Replicate Single-Precision Floating-Point Values |
|
* Duplicates odd-indexed single-precision floating-point values from the |
|
* source operand |
|
*/ |
|
/// <summary> |
|
/// Duplicate odd-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVSHDUP ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_movehdup_ps(v256 a) |
|
{ |
|
return new v256(a.UInt1, a.UInt1, a.UInt3, a.UInt3, a.UInt5, a.UInt5, a.UInt7, a.UInt7); |
|
} |
|
|
|
/// <summary> |
|
/// Duplicate even-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVSLDUP ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_moveldup_ps(v256 a) |
|
{ |
|
return new v256(a.UInt0, a.UInt0, a.UInt2, a.UInt2, a.UInt4, a.UInt4, a.UInt6, a.UInt6); |
|
} |
|
|
|
|
|
/// <summary> |
|
/// Duplicate even-indexed double-precision (64-bit) floating-point elements from a, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVDDUP ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_movedup_pd(v256 a) |
|
{ |
|
return new v256(a.Double0, a.Double0, a.Double2, a.Double2); |
|
} |
|
|
|
/// <summary> |
|
/// Load 256-bits of integer data from unaligned memory into dst. |
|
/// This intrinsic may perform better than mm256_loadu_si256 when |
|
/// the data crosses a cache line boundary. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VLDDQU ymm1, v256 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_lddqu_si256(void* mem_addr) |
|
{ |
|
return *(v256*)mem_addr; |
|
} |
|
|
|
/* |
|
* Store Packed Integers Using Non-Temporal Hint |
|
* **** VMOVNTDQ v256, ymm1 |
|
* Moves the packed integers in the source operand to the destination using a |
|
* non-temporal hint to prevent caching of the data during the write to memory |
|
*/ |
|
/// <summary> |
|
/// Store 256-bits of integer data from a into memory using a |
|
/// non-temporal memory hint. mem_addr must be aligned on a 32-byte |
|
/// boundary or a general-protection exception may be generated. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVNTDQ v256, ymm1 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_stream_si256(void* mem_addr, v256 a) |
|
{ |
|
*(v256*)mem_addr = a; |
|
} |
|
|
|
|
|
/// <summary> |
|
/// Store 256-bits (composed of 4 packed double-precision (64-bit) |
|
/// floating-point elements) from a into memory using a |
|
/// non-temporal memory hint. mem_addr must be aligned on a 32-byte |
|
/// boundary or a general-protection exception may be generated. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVNTPD v256, ymm1 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_stream_pd(void* mem_addr, v256 a) |
|
{ |
|
*(v256*)mem_addr = a; |
|
} |
|
|
|
/// <summary> |
|
/// Store 256-bits (composed of 8 packed single-precision (32-bit) |
|
/// floating-point elements) from a into memory using a |
|
/// non-temporal memory hint. mem_addr must be aligned on a 32-byte |
|
/// boundary or a general-protection exception may be generated. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVNTPS v256, ymm1 |
|
/// </remarks> |
|
/// <param name="mem_addr">Memory address</param> |
|
/// <param name="a">Vector a</param> |
|
[DebuggerStepThrough] |
|
public static void mm256_stream_ps(void* mem_addr, v256 a) |
|
{ |
|
*(v256*)mem_addr = a; |
|
} |
|
|
|
/// <summary> |
|
/// Compute the approximate reciprocal of packed single-precision |
|
/// (32-bit) floating-point elements in a, and store the results in |
|
/// dst. The maximum relative error for this approximation is less |
|
/// than 1.5*2^-12. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VRCPPS ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_rcp_ps(v256 a) |
|
{ |
|
return new v256(Sse.rcp_ps(a.Lo128), Sse.rcp_ps(a.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the approximate reciprocal square root of packed |
|
/// single-precision (32-bit) floating-point elements in a, and |
|
/// store the results in dst. The maximum relative error for this |
|
/// approximation is less than 1.5*2^-12. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VRSQRTPS ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_rsqrt_ps(v256 a) |
|
{ |
|
return new v256(Sse.rsqrt_ps(a.Lo128), Sse.rsqrt_ps(a.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the square root of packed double-precision (64-bit) |
|
/// floating-point elements in a, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VSQRTPD ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_sqrt_pd(v256 a) |
|
{ |
|
return new v256(Sse2.sqrt_pd(a.Lo128), Sse2.sqrt_pd(a.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the square root of packed single-precision (32-bit) |
|
/// floating-point elements in a, and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VSQRTPS ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_sqrt_ps(v256 a) |
|
{ |
|
return new v256(Sse.sqrt_ps(a.Lo128), Sse.sqrt_ps(a.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Round the packed double-precision (64-bit) floating-point |
|
/// elements in a using the rounding parameter, and store the |
|
/// results as packed double-precision floating-point elements in |
|
/// dst. |
|
/// </summary> |
|
/// <remarks> |
|
///**** VROUNDPD ymm1,ymm2/v256,imm8 |
|
/// Rounding is done according to the rounding parameter, which can be one of: |
|
/// (_MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) // round to nearest, and suppress exceptions |
|
/// (_MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC) // round down, and suppress exceptions |
|
/// (_MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC) // round up, and suppress exceptions |
|
/// (_MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC) // truncate, and suppress exceptions |
|
/// _MM_FROUND_CUR_DIRECTION // use MXCSR.RC; see _MM_SET_ROUNDING_MODE |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="rounding">Rounding mode</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_round_pd(v256 a, int rounding) |
|
{ |
|
return new v256(Sse4_1.round_pd(a.Lo128, rounding), Sse4_1.round_pd(a.Hi128, rounding)); |
|
} |
|
|
|
|
|
/// <summary> |
|
/// Round the packed double-precision (64-bit) floating-point |
|
/// elements in a up to an integer value, and store the results as |
|
/// packed double-precision floating-point elements in dst. |
|
/// </summary> |
|
/// <param name="val">Value</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_ceil_pd(v256 val) |
|
{ |
|
return mm256_round_pd(val, (int)RoundingMode.FROUND_CEIL); |
|
} |
|
|
|
/// <summary> |
|
/// Round the packed double-precision (64-bit) floating-point |
|
/// elements in a down to an integer value, and store the results |
|
/// as packed double-precision floating-point elements in dst. |
|
/// </summary> |
|
/// <param name="val">Value</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_floor_pd(v256 val) |
|
{ |
|
return mm256_round_pd(val, (int)RoundingMode.FROUND_FLOOR); |
|
} |
|
|
|
/// <summary> |
|
/// Round the packed single-precision (32-bit) floating-point |
|
/// elements in a using the rounding parameter, and store the |
|
/// results as packed single-precision floating-point elements in |
|
/// dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VROUNDPS ymm1,ymm2/v256,imm8 |
|
/// Round the four single-precision floating-point values values in the source |
|
/// operand by the rounding mode specified in the immediate operand and place |
|
/// the result in the destination. The rounding process rounds the input to an |
|
/// integral value and returns the result as a double-precision floating-point |
|
/// value. The Precision Floating Point Exception is signaled according to the |
|
/// immediate operand. If any source operand is an SNaN then it will be |
|
/// converted to a QNaN. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="rounding">Rounding mode</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_round_ps(v256 a, int rounding) |
|
{ |
|
return new v256(Sse4_1.round_ps(a.Lo128, rounding), Sse4_1.round_ps(a.Hi128, rounding)); |
|
} |
|
|
|
/// <summary> |
|
/// Round the packed single-precision (32-bit) floating-point |
|
/// elements in a up to an integer value, and store the results as |
|
/// packed single-precision floating-point elements in dst. |
|
/// </summary> |
|
/// <param name="val">Value</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_ceil_ps(v256 val) |
|
{ |
|
return mm256_round_ps(val, (int)RoundingMode.FROUND_CEIL); |
|
} |
|
|
|
/// <summary> |
|
/// Round the packed single-precision (32-bit) floating-point |
|
/// elements in a down to an integer value, and store the results |
|
/// as packed single-precision floating-point elements in dst. |
|
/// </summary> |
|
/// <param name="val">Value</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_floor_ps(v256 val) |
|
{ |
|
return mm256_round_ps(val, (int)RoundingMode.FROUND_FLOOR); |
|
} |
|
|
|
/// <summary> |
|
/// Unpack and interleave double-precision (64-bit) floating-point |
|
/// elements from the high half of each 128-bit lane in a and b, |
|
/// and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VUNPCKHPD ymm1,ymm2,ymm3/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_unpackhi_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.unpackhi_pd(a.Lo128, b.Lo128), Sse2.unpackhi_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Unpack and interleave double-precision (64-bit) floating-point |
|
/// elements from the low half of each 128-bit lane in a and b, and |
|
/// store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VUNPCKLPD ymm1,ymm2,ymm3/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_unpacklo_pd(v256 a, v256 b) |
|
{ |
|
return new v256(Sse2.unpacklo_pd(a.Lo128, b.Lo128), Sse2.unpacklo_pd(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Unpack and interleave single-precision(32-bit) floating-point |
|
/// elements from the high half of each 128-bit lane in a and b, |
|
/// and store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VUNPCKHPS ymm1,ymm2,ymm3/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_unpackhi_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.unpackhi_ps(a.Lo128, b.Lo128), Sse.unpackhi_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Unpack and interleave single-precision (32-bit) floating-point |
|
/// elements from the low half of each 128-bit lane in a and b, and |
|
/// store the results in dst. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VUNPCKLPS ymm1,ymm2,ymm3/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_unpacklo_ps(v256 a, v256 b) |
|
{ |
|
return new v256(Sse.unpacklo_ps(a.Lo128, b.Lo128), Sse.unpacklo_ps(a.Hi128, b.Hi128)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 256 bits (representing integer data) |
|
/// in a and b, and set ZF to 1 if the result is zero, otherwise |
|
/// set ZF to 0. Compute the bitwise NOT of a and then AND with b, |
|
/// and set CF to 1 if the result is zero, otherwise set CF to 0. |
|
/// Return the ZF value. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>ZF value</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_testz_si256(v256 a, v256 b) |
|
{ |
|
return Sse4_1.testz_si128(a.Lo128, b.Lo128) & Sse4_1.testz_si128(a.Hi128, b.Hi128); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 256 bits (representing integer data) |
|
/// in a and b, and set ZF to 1 if the result is zero, otherwise |
|
/// set ZF to 0. Compute the bitwise NOT of a and then AND with b, |
|
/// and set CF to 1 if the result is zero, otherwise set CF to 0. |
|
/// Return the CF value. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>CF value</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_testc_si256(v256 a, v256 b) |
|
{ |
|
return Sse4_1.testc_si128(a.Lo128, b.Lo128) & Sse4_1.testc_si128(a.Hi128, b.Hi128); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 256 bits (representing integer data) |
|
/// in a and b, and set ZF to 1 if the result is zero, otherwise |
|
/// set ZF to 0. Compute the bitwise NOT of a and then AND with b, |
|
/// and set CF to 1 if the result is zero, otherwise set CF to 0. |
|
/// Return 1 if both the ZF and CF values are zero, otherwise |
|
/// return 0. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Integer</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_testnzc_si256(v256 a, v256 b) |
|
{ |
|
int zf = mm256_testz_si256(a, b); |
|
int cf = mm256_testc_si256(a, b); |
|
return 1 - (zf | cf); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 256 bits (representing |
|
/// double-precision (64-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 256-bit value, and set ZF to 1 if the |
|
/// sign bit of each 64-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 64-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return the ZF value. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPD ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>ZF value</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_testz_pd(v256 a, v256 b) |
|
{ |
|
ulong* aptr = &a.ULong0; |
|
ulong* bptr = &b.ULong0; |
|
for (int i = 0; i < 4; ++i) |
|
{ |
|
if (((aptr[i] & bptr[i]) & 0x8000_0000_0000_0000) != 0) |
|
return 0; |
|
} |
|
return 1; |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 256 bits (representing |
|
/// double-precision (64-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 256-bit value, and set ZF to 1 if the |
|
/// sign bit of each 64-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 64-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return the CF value. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPD ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>CF value</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_testc_pd(v256 a, v256 b) |
|
{ |
|
ulong* aptr = &a.ULong0; |
|
ulong* bptr = &b.ULong0; |
|
for (int i = 0; i < 4; ++i) |
|
{ |
|
if ((((~aptr[i]) & bptr[i]) & 0x8000_0000_0000_0000) != 0) |
|
return 0; |
|
} |
|
return 1; |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 256 bits (representing |
|
/// double-precision (64-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 256-bit value, and set ZF to 1 if the |
|
/// sign bit of each 64-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 64-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return 1 if both the ZF |
|
/// and CF values are zero, otherwise return 0. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPD ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Integer</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_testnzc_pd(v256 a, v256 b) |
|
{ |
|
return 1 - (mm256_testz_pd(a, b) | mm256_testc_pd(a, b)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 128 bits (representing |
|
/// double-precision (64-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 128-bit value, and set ZF to 1 if the |
|
/// sign bit of each 64-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 64-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return the ZF value. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPD xmm1, xmm2/v128 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>ZF value</returns> |
|
[DebuggerStepThrough] |
|
public static int testz_pd(v128 a, v128 b) |
|
{ |
|
ulong* aptr = &a.ULong0; |
|
ulong* bptr = &b.ULong0; |
|
for (int i = 0; i < 2; ++i) |
|
{ |
|
if (((aptr[i] & bptr[i]) & 0x8000_0000_0000_0000) != 0) |
|
return 0; |
|
} |
|
return 1; |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 128 bits (representing |
|
/// double-precision (64-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 128-bit value, and set ZF to 1 if the |
|
/// sign bit of each 64-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 64-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return the CF value. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPD xmm1, xmm2/v128 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>CF value</returns> |
|
[DebuggerStepThrough] |
|
public static int testc_pd(v128 a, v128 b) |
|
{ |
|
ulong* aptr = &a.ULong0; |
|
ulong* bptr = &b.ULong0; |
|
for (int i = 0; i < 2; ++i) |
|
{ |
|
if ((((~aptr[i]) & bptr[i]) & 0x8000_0000_0000_0000) != 0) |
|
return 0; |
|
} |
|
return 1; |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 128 bits (representing |
|
/// double-precision (64-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 128-bit value, and set ZF to 1 if the |
|
/// sign bit of each 64-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 64-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return 1 if both the ZF |
|
/// and CF values are zero, otherwise return 0. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPD xmm1, xmm2/v128 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Integer</returns> |
|
[DebuggerStepThrough] |
|
public static int testnzc_pd(v128 a, v128 b) |
|
{ |
|
return 1 - (testz_pd(a, b) | testc_pd(a, b)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 256 bits (representing |
|
/// single-precision (32-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 256-bit value, and set ZF to 1 if the |
|
/// sign bit of each 32-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 32-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return the ZF value. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPS ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>ZF value</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_testz_ps(v256 a, v256 b) |
|
{ |
|
uint* aptr = &a.UInt0; |
|
uint* bptr = &b.UInt0; |
|
for (int i = 0; i < 8; ++i) |
|
{ |
|
if (((aptr[i] & bptr[i]) & 0x8000_0000) != 0) |
|
return 0; |
|
} |
|
return 1; |
|
|
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 256 bits (representing |
|
/// single-precision (32-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 256-bit value, and set ZF to 1 if the |
|
/// sign bit of each 32-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 32-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return the CF value. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPS ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>CF value</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_testc_ps(v256 a, v256 b) |
|
{ |
|
uint* aptr = &a.UInt0; |
|
uint* bptr = &b.UInt0; |
|
for (int i = 0; i < 8; ++i) |
|
{ |
|
if ((((~aptr[i]) & bptr[i]) & 0x8000_0000) != 0) |
|
return 0; |
|
} |
|
return 1; |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 256 bits (representing |
|
/// single-precision (32-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 256-bit value, and set ZF to 1 if the |
|
/// sign bit of each 32-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 32-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return 1 if both the ZF |
|
/// and CF values are zero, otherwise return 0. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPS ymm1, ymm2/v256 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Integer</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_testnzc_ps(v256 a, v256 b) |
|
{ |
|
return 1 - (mm256_testz_ps(a, b) | mm256_testc_ps(a, b)); |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 128 bits (representing |
|
/// single-precision (32-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 128-bit value, and set ZF to 1 if the |
|
/// sign bit of each 32-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 32-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return the ZF value. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPS xmm1, xmm2/v128 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>ZF value</returns> |
|
[DebuggerStepThrough] |
|
public static int testz_ps(v128 a, v128 b) |
|
{ |
|
uint* aptr = &a.UInt0; |
|
uint* bptr = &b.UInt0; |
|
for (int i = 0; i < 4; ++i) |
|
{ |
|
if (((aptr[i] & bptr[i]) & 0x8000_0000) != 0) |
|
return 0; |
|
} |
|
return 1; |
|
|
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 128 bits (representing |
|
/// single-precision (32-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 128-bit value, and set ZF to 1 if the |
|
/// sign bit of each 32-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 32-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return the CF value. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPS xmm1, xmm2/v128 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>CF value</returns> |
|
[DebuggerStepThrough] |
|
public static int testc_ps(v128 a, v128 b) |
|
{ |
|
uint* aptr = &a.UInt0; |
|
uint* bptr = &b.UInt0; |
|
for (int i = 0; i < 4; ++i) |
|
{ |
|
if ((((~aptr[i]) & bptr[i]) & 0x8000_0000) != 0) |
|
return 0; |
|
} |
|
return 1; |
|
} |
|
|
|
/// <summary> |
|
/// Compute the bitwise AND of 128 bits (representing |
|
/// single-precision (32-bit) floating-point elements) in a and b, |
|
/// producing an intermediate 128-bit value, and set ZF to 1 if the |
|
/// sign bit of each 32-bit element in the intermediate value is |
|
/// zero, otherwise set ZF to 0. Compute the bitwise NOT of a and |
|
/// then AND with b, producing an intermediate value, and set CF to |
|
/// 1 if the sign bit of each 32-bit element in the intermediate |
|
/// value is zero, otherwise set CF to 0. Return 1 if both the ZF |
|
/// and CF values are zero, otherwise return 0. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VTESTPS xmm1, xmm2/v128 |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="b">Vector b</param> |
|
/// <returns>Integer</returns> |
|
[DebuggerStepThrough] |
|
public static int testnzc_ps(v128 a, v128 b) |
|
{ |
|
return 1 - (testz_ps(a, b) | testc_ps(a, b)); |
|
} |
|
|
|
/// <summary> |
|
/// Set each bit of mask dst based on the most significant bit of the corresponding packed double-precision (64-bit) floating-point element in a. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVMSKPD r32, ymm2 |
|
/// Extracts the sign bits from the packed double-precision floating-point |
|
/// values in the source operand, formats them into a 4-bit mask, and stores |
|
/// the mask in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Integer</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_movemask_pd(v256 a) |
|
{ |
|
return Sse2.movemask_pd(a.Lo128) | (Sse2.movemask_pd(a.Hi128) << 2); |
|
} |
|
|
|
|
|
/// <summary> |
|
/// Set each bit of mask dst based on the most significant bit of the corresponding packed single-precision (32-bit) floating-point element in a. |
|
/// </summary> |
|
/// <remarks> |
|
/// **** VMOVMSKPS r32, ymm2 |
|
/// Extracts the sign bits from the packed single-precision floating-point |
|
/// values in the source operand, formats them into a 8-bit mask, and stores |
|
/// the mask in the destination |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Integer</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_movemask_ps(v256 a) |
|
{ |
|
return Sse.movemask_ps(a.Lo128) | (Sse.movemask_ps(a.Hi128) << 4); |
|
} |
|
|
|
// Normal IR is fine for this |
|
|
|
/// <summary> |
|
/// Return Vector with all elements set to zero. |
|
/// </summary> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setzero_pd() { return default; } |
|
|
|
/// <summary> |
|
/// Return Vector with all elements set to zero. |
|
/// </summary> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setzero_ps() { return default; } |
|
|
|
/// <summary> |
|
/// Return Vector with all elements set to zero. |
|
/// </summary> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setzero_si256() { return default; } |
|
|
|
/// <summary> |
|
/// Set packed double-precision (64-bit) floating-point elements in dst with the supplied values. |
|
/// </summary> |
|
/// <param name="d">Element d</param> |
|
/// <param name="c">Element c</param> |
|
/// <param name="b">Element b</param> |
|
/// <param name="a">Element a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set_pd(double d, double c, double b, double a) |
|
{ |
|
return new v256(a, b, c, d); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed single-precision (32-bit) floating-point elements in dst with the supplied values. |
|
/// </summary> |
|
/// <param name="e7">Element 7</param> |
|
/// <param name="e6">Element 6</param> |
|
/// <param name="e5">Element 5</param> |
|
/// <param name="e4">Element 4</param> |
|
/// <param name="e3">Element 3</param> |
|
/// <param name="e2">Element 2</param> |
|
/// <param name="e1">Element 1</param> |
|
/// <param name="e0">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set_ps(float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) |
|
{ |
|
return new v256(e0, e1, e2, e3, e4, e5, e6, e7); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed byte elements in dst with the supplied values. |
|
/// </summary> |
|
/// <param name="e31_">Element 31</param> |
|
/// <param name="e30_">Element 30</param> |
|
/// <param name="e29_">Element 29</param> |
|
/// <param name="e28_">Element 28</param> |
|
/// <param name="e27_">Element 27</param> |
|
/// <param name="e26_">Element 26</param> |
|
/// <param name="e25_">Element 25</param> |
|
/// <param name="e24_">Element 24</param> |
|
/// <param name="e23_">Element 23</param> |
|
/// <param name="e22_">Element 22</param> |
|
/// <param name="e21_">Element 21</param> |
|
/// <param name="e20_">Element 20</param> |
|
/// <param name="e19_">Element 19</param> |
|
/// <param name="e18_">Element 18</param> |
|
/// <param name="e17_">Element 17</param> |
|
/// <param name="e16_">Element 16</param> |
|
/// <param name="e15_">Element 15</param> |
|
/// <param name="e14_">Element 14</param> |
|
/// <param name="e13_">Element 13</param> |
|
/// <param name="e12_">Element 12</param> |
|
/// <param name="e11_">Element 11</param> |
|
/// <param name="e10_">Element 10</param> |
|
/// <param name="e9_">Element 9</param> |
|
/// <param name="e8_">Element 8</param> |
|
/// <param name="e7_">Element 7</param> |
|
/// <param name="e6_">Element 6</param> |
|
/// <param name="e5_">Element 5</param> |
|
/// <param name="e4_">Element 4</param> |
|
/// <param name="e3_">Element 3</param> |
|
/// <param name="e2_">Element 2</param> |
|
/// <param name="e1_">Element 1</param> |
|
/// <param name="e0_">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set_epi8( |
|
byte e31_, byte e30_, byte e29_, byte e28_, byte e27_, byte e26_, byte e25_, byte e24_, byte e23_, byte e22_, byte e21_, byte e20_, byte e19_, byte e18_, byte e17_, byte e16_, |
|
byte e15_, byte e14_, byte e13_, byte e12_, byte e11_, byte e10_, byte e9_, byte e8_, byte e7_, byte e6_, byte e5_, byte e4_, byte e3_, byte e2_, byte e1_, byte e0_) |
|
{ |
|
return new v256( |
|
e0_, e1_, e2_, e3_, e4_, e5_, e6_, e7_, |
|
e8_, e9_, e10_, e11_, e12_, e13_, e14_, e15_, |
|
e16_, e17_, e18_, e19_, e20_, e21_, e22_, e23_, |
|
e24_, e25_, e26_, e27_, e28_, e29_, e30_, e31_); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed short elements in dst with the supplied values. |
|
/// </summary> |
|
/// <param name="e15_">Element 15</param> |
|
/// <param name="e14_">Element 14</param> |
|
/// <param name="e13_">Element 13</param> |
|
/// <param name="e12_">Element 12</param> |
|
/// <param name="e11_">Element 11</param> |
|
/// <param name="e10_">Element 10</param> |
|
/// <param name="e9_">Element 9</param> |
|
/// <param name="e8_">Element 8</param> |
|
/// <param name="e7_">Element 7</param> |
|
/// <param name="e6_">Element 6</param> |
|
/// <param name="e5_">Element 5</param> |
|
/// <param name="e4_">Element 4</param> |
|
/// <param name="e3_">Element 3</param> |
|
/// <param name="e2_">Element 2</param> |
|
/// <param name="e1_">Element 1</param> |
|
/// <param name="e0_">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set_epi16(short e15_, short e14_, short e13_, short e12_, short e11_, short e10_, short e9_, short e8_, short e7_, short e6_, short e5_, short e4_, short e3_, short e2_, short e1_, short e0_) |
|
{ |
|
return new v256( |
|
e0_, e1_, e2_, e3_, e4_, e5_, e6_, e7_, |
|
e8_, e9_, e10_, e11_, e12_, e13_, e14_, e15_); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed int elements in dst with the supplied values. |
|
/// </summary> |
|
/// <param name="e7">Element 7</param> |
|
/// <param name="e6">Element 6</param> |
|
/// <param name="e5">Element 5</param> |
|
/// <param name="e4">Element 4</param> |
|
/// <param name="e3">Element 3</param> |
|
/// <param name="e2">Element 2</param> |
|
/// <param name="e1">Element 1</param> |
|
/// <param name="e0">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set_epi32(int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) |
|
{ |
|
return new v256(e0, e1, e2, e3, e4, e5, e6, e7); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed 64-bit integers in dst with the supplied values. |
|
/// </summary> |
|
/// <param name="e3">Element 3</param> |
|
/// <param name="e2">Element 2</param> |
|
/// <param name="e1">Element 1</param> |
|
/// <param name="e0">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set_epi64x(long e3, long e2, long e1, long e0) |
|
{ |
|
return new v256(e0, e1, e2, e3); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed v256 vector with the supplied values. |
|
/// </summary> |
|
/// <param name="hi">High half of the vector</param> |
|
/// <param name="lo">Low half of the vector</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set_m128d(v128 hi, v128 lo) |
|
{ |
|
return new v256(lo, hi); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed v256 vector with the supplied values. |
|
/// </summary> |
|
/// <param name="hi">High half of the vector</param> |
|
/// <param name="lo">Low half of the vector</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set_m128i(v128 hi, v128 lo) |
|
{ |
|
return new v256(lo, hi); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed double-precision (64-bit) floating-point elements in dst with the supplied values in reverse order. |
|
/// </summary> |
|
/// <param name="d">Element d</param> |
|
/// <param name="c">Element c</param> |
|
/// <param name="b">Element b</param> |
|
/// <param name="a">Element a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setr_pd(double d, double c, double b, double a) |
|
{ |
|
return new v256(d, c, b, a); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed single-precision (32-bit) floating-point elements in dst with the supplied values in reverse order. |
|
/// </summary> |
|
/// <param name="e7">Element 7</param> |
|
/// <param name="e6">Element 6</param> |
|
/// <param name="e5">Element 5</param> |
|
/// <param name="e4">Element 4</param> |
|
/// <param name="e3">Element 3</param> |
|
/// <param name="e2">Element 2</param> |
|
/// <param name="e1">Element 1</param> |
|
/// <param name="e0">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setr_ps(float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) |
|
{ |
|
return new v256(e7, e6, e5, e4, e3, e2, e1, e0); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed byte elements in dst with the supplied values in reverse order. |
|
/// </summary> |
|
/// <param name="e31_">Element 31</param> |
|
/// <param name="e30_">Element 30</param> |
|
/// <param name="e29_">Element 29</param> |
|
/// <param name="e28_">Element 28</param> |
|
/// <param name="e27_">Element 27</param> |
|
/// <param name="e26_">Element 26</param> |
|
/// <param name="e25_">Element 25</param> |
|
/// <param name="e24_">Element 24</param> |
|
/// <param name="e23_">Element 23</param> |
|
/// <param name="e22_">Element 22</param> |
|
/// <param name="e21_">Element 21</param> |
|
/// <param name="e20_">Element 20</param> |
|
/// <param name="e19_">Element 19</param> |
|
/// <param name="e18_">Element 18</param> |
|
/// <param name="e17_">Element 17</param> |
|
/// <param name="e16_">Element 16</param> |
|
/// <param name="e15_">Element 15</param> |
|
/// <param name="e14_">Element 14</param> |
|
/// <param name="e13_">Element 13</param> |
|
/// <param name="e12_">Element 12</param> |
|
/// <param name="e11_">Element 11</param> |
|
/// <param name="e10_">Element 10</param> |
|
/// <param name="e9_">Element 9</param> |
|
/// <param name="e8_">Element 8</param> |
|
/// <param name="e7_">Element 7</param> |
|
/// <param name="e6_">Element 6</param> |
|
/// <param name="e5_">Element 5</param> |
|
/// <param name="e4_">Element 4</param> |
|
/// <param name="e3_">Element 3</param> |
|
/// <param name="e2_">Element 2</param> |
|
/// <param name="e1_">Element 1</param> |
|
/// <param name="e0_">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setr_epi8( |
|
byte e31_, byte e30_, byte e29_, byte e28_, byte e27_, byte e26_, byte e25_, byte e24_, byte e23_, byte e22_, byte e21_, byte e20_, byte e19_, byte e18_, byte e17_, byte e16_, |
|
byte e15_, byte e14_, byte e13_, byte e12_, byte e11_, byte e10_, byte e9_, byte e8_, byte e7_, byte e6_, byte e5_, byte e4_, byte e3_, byte e2_, byte e1_, byte e0_) |
|
{ |
|
return new v256( |
|
e31_, e30_, e29_, e28_, e27_, e26_, e25_, e24_, |
|
e23_, e22_, e21_, e20_, e19_, e18_, e17_, e16_, |
|
e15_, e14_, e13_, e12_, e11_, e10_, e9_, e8_, |
|
e7_, e6_, e5_, e4_, e3_, e2_, e1_, e0_); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed short elements in dst with the supplied values in reverse order. |
|
/// </summary> |
|
/// <param name="e15_">Element 15</param> |
|
/// <param name="e14_">Element 14</param> |
|
/// <param name="e13_">Element 13</param> |
|
/// <param name="e12_">Element 12</param> |
|
/// <param name="e11_">Element 11</param> |
|
/// <param name="e10_">Element 10</param> |
|
/// <param name="e9_">Element 9</param> |
|
/// <param name="e8_">Element 8</param> |
|
/// <param name="e7_">Element 7</param> |
|
/// <param name="e6_">Element 6</param> |
|
/// <param name="e5_">Element 5</param> |
|
/// <param name="e4_">Element 4</param> |
|
/// <param name="e3_">Element 3</param> |
|
/// <param name="e2_">Element 2</param> |
|
/// <param name="e1_">Element 1</param> |
|
/// <param name="e0_">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setr_epi16(short e15_, short e14_, short e13_, short e12_, short e11_, short e10_, short e9_, short e8_, short e7_, short e6_, short e5_, short e4_, short e3_, short e2_, short e1_, short e0_) |
|
{ |
|
return new v256( |
|
e15_, e14_, e13_, e12_, e11_, e10_, e9_, e8_, |
|
e7_, e6_, e5_, e4_, e3_, e2_, e1_, e0_); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed int elements in dst with the supplied values in reverse order. |
|
/// </summary> |
|
/// <param name="e7">Element 7</param> |
|
/// <param name="e6">Element 6</param> |
|
/// <param name="e5">Element 5</param> |
|
/// <param name="e4">Element 4</param> |
|
/// <param name="e3">Element 3</param> |
|
/// <param name="e2">Element 2</param> |
|
/// <param name="e1">Element 1</param> |
|
/// <param name="e0">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setr_epi32(int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) |
|
{ |
|
return new v256(e7, e6, e5, e4, e3, e2, e1, e0); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed 64-bit integers in dst with the supplied values in reverse order. |
|
/// </summary> |
|
/// <param name="e3">Element 3</param> |
|
/// <param name="e2">Element 2</param> |
|
/// <param name="e1">Element 1</param> |
|
/// <param name="e0">Element 0</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setr_epi64x(long e3, long e2, long e1, long e0) |
|
{ |
|
return new v256(e3, e2, e1, e0); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed v256 vector with the supplied values in reverse order. |
|
/// </summary> |
|
/// <param name="hi">High half of the vector</param> |
|
/// <param name="lo">Low half of the vector</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setr_m128(v128 hi, v128 lo) |
|
{ |
|
return new v256(hi, lo); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed v256 vector with the supplied values in reverse order. |
|
/// </summary> |
|
/// <param name="hi">High half of the vector</param> |
|
/// <param name="lo">Low half of the vector</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setr_m128d(v128 hi, v128 lo) |
|
{ |
|
return new v256(hi, lo); |
|
} |
|
|
|
/// <summary> |
|
/// Set packed v256 vector with the supplied values in reverse order. |
|
/// </summary> |
|
/// <param name="hi">High half of the vector</param> |
|
/// <param name="lo">Low half of the vector</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_setr_m128i(v128 hi, v128 lo) |
|
{ |
|
return new v256(hi, lo); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast double-precision (64-bit) floating-point value a to all elements of dst. |
|
/// </summary> |
|
/// <param name="a">Value</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set1_pd(double a) |
|
{ |
|
return new v256(a); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast single-precision (32-bit) floating-point value a to all elements of dst. |
|
/// </summary> |
|
/// <param name="a">Value</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set1_ps(float a) |
|
{ |
|
return new v256(a); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast 8-bit integer a to all elements of dst. This intrinsic may generate the vpbroadcastb instruction. |
|
/// </summary> |
|
/// <param name="a">8-bit integer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set1_epi8(byte a) |
|
{ |
|
return new v256(a); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast 16-bit integer a to all all elements of dst. This intrinsic may generate the vpbroadcastw instruction. |
|
/// </summary> |
|
/// <param name="a">16-bit integer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set1_epi16(short a) |
|
{ |
|
return new v256(a); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast 32-bit integer a to all elements of dst. This intrinsic may generate the vpbroadcastd instruction. |
|
/// </summary> |
|
/// <param name="a">32-bit integer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set1_epi32(int a) |
|
{ |
|
return new v256(a); |
|
} |
|
|
|
/// <summary> |
|
/// Broadcast 64-bit integer a to all elements of dst. This intrinsic may generate the vpbroadcastq instruction. |
|
/// </summary> |
|
/// <param name="a">64-bit integer</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_set1_epi64x(long a) |
|
{ |
|
return new v256(a); |
|
} |
|
|
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_castpd_ps(v256 a) { return a; } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_castps_pd(v256 a) { return a; } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_castps_si256(v256 a) { return a; } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_castpd_si256(v256 a) { return a; } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_castsi256_ps(v256 a) { return a; } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_castsi256_pd(v256 a) { return a; } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 mm256_castps256_ps128(v256 a) { return a.Lo128; } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 mm256_castpd256_pd128(v256 a) { return a.Lo128; } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 mm256_castsi256_si128(v256 a) { return a.Lo128; } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_castps128_ps256(v128 a) { return new v256(a, Sse.setzero_ps()); } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_castpd128_pd256(v128 a) { return new v256(a, Sse.setzero_ps()); } |
|
/// <summary>For compatibility with C++ code only. This is a no-op in Burst.</summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_castsi128_si256(v128 a) { return new v256(a, Sse.setzero_ps()); } |
|
|
|
/// <summary>Return a 128-bit vector with undefined contents.</summary> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v128 undefined_ps() |
|
{ |
|
return default; |
|
} |
|
|
|
/// <summary>Return a 128-bit vector with undefined contents.</summary> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v128 undefined_pd() |
|
{ |
|
return undefined_ps(); |
|
} |
|
|
|
/// <summary>Return a 128-bit vector with undefined contents.</summary> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v128 undefined_si128() |
|
{ |
|
return undefined_ps(); |
|
} |
|
|
|
/// <summary>Return a 256-bit vector with undefined contents.</summary> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_undefined_ps() |
|
{ |
|
return default; |
|
} |
|
|
|
/// <summary>Return a 256-bit vector with undefined contents.</summary> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_undefined_pd() |
|
{ |
|
return mm256_undefined_ps(); |
|
} |
|
|
|
/// <summary>Return a 256-bit vector with undefined contents.</summary> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_undefined_si256() |
|
{ |
|
return mm256_undefined_ps(); |
|
} |
|
|
|
// Zero-extended cast functions |
|
|
|
/// <summary> |
|
/// Casts vector of type v128 to type v256; the upper 128 bits of the result |
|
/// are zeroed. This intrinsic is only used for compilation and does not |
|
/// generate any instructions, thus it has zero latency. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_zextps128_ps256(v128 a) { return new v256(a, Sse.setzero_ps()); } |
|
|
|
/// <summary> |
|
/// Casts vector of type v128 to type v256; the upper 128 bits of the result |
|
/// are zeroed. This intrinsic is only used for compilation and does not |
|
/// generate any instructions, thus it has zero latency. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_zextpd128_pd256(v128 a) { return mm256_zextps128_ps256(a); } |
|
|
|
/// <summary> |
|
/// Casts vector of type v128 to type v256; the upper 128 bits of the result |
|
/// are zeroed. This intrinsic is only used for compilation and does not |
|
/// generate any instructions, thus it has zero latency. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
[BurstTargetCpu(BurstTargetCpu.AVX)] |
|
public static v256 mm256_zextsi128_si256(v128 a) { return mm256_zextps128_ps256(a); } |
|
|
|
|
|
/// <summary> |
|
/// Copy a to dst, and insert the 8-bit integer i into dst at the location specified by index (which must be a constant). |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="i">8-bit integer i</param> |
|
/// <param name="index">Location</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_insert_epi8(v256 a, int i, int index) |
|
{ |
|
v256 dst = a; |
|
byte* target = &dst.Byte0; |
|
target[index & 31] = (byte)i; |
|
return dst; |
|
} |
|
|
|
/// <summary> |
|
/// Copy a to dst, and insert the 16-bit integer i into dst at the location specified by index (which must be a constant). |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="i">16-bit integer i</param> |
|
/// <param name="index">Location</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_insert_epi16(v256 a, int i, int index) |
|
{ |
|
v256 dst = a; |
|
short* target = &dst.SShort0; |
|
target[index & 15] = (short)i; |
|
return dst; |
|
} |
|
|
|
/// <summary> |
|
/// Copy a to dst, and insert the 32-bit integer i into dst at the location specified by index (which must be a constant). |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="i">32-bit integer i</param> |
|
/// <param name="index">Location</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_insert_epi32(v256 a, int i, int index) |
|
{ |
|
v256 dst = a; |
|
int* target = &dst.SInt0; |
|
target[index & 7] = i; |
|
return dst; |
|
} |
|
|
|
/// <summary> |
|
/// Copy a to dst, and insert the 64-bit integer i into dst at the location specified by index (which must be a constant). |
|
/// </summary> |
|
/// <remarks> |
|
/// This intrinsic requires a 64-bit processor. |
|
/// </remarks> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="i">64-bit integer i</param> |
|
/// <param name="index">Location</param> |
|
/// <returns>Vector</returns> |
|
[DebuggerStepThrough] |
|
public static v256 mm256_insert_epi64(v256 a, long i, int index) |
|
{ |
|
v256 dst = a; |
|
long* target = &dst.SLong0; |
|
target[index & 3] = i; |
|
return dst; |
|
} |
|
|
|
/// <summary> |
|
/// Extract a 32-bit integer from a, selected with index (which must be a constant), and store the result in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="index">Index</param> |
|
/// <returns>32-bit integer</returns> |
|
[DebuggerStepThrough] |
|
public static int mm256_extract_epi32(v256 a, int index) |
|
{ |
|
return (&a.SInt0)[index & 7]; |
|
} |
|
|
|
/// <summary> |
|
/// Extract a 64-bit integer from a, selected with index (which must be a constant), and store the result in dst. |
|
/// </summary> |
|
/// <param name="a">Vector a</param> |
|
/// <param name="index">Index</param> |
|
/// <returns>64-bit integer</returns> |
|
[DebuggerStepThrough] |
|
public static long mm256_extract_epi64(v256 a, int index) |
|
{ |
|
return (&a.SLong0)[index & 3]; |
|
} |
|
} |
|
} |
|
}
|
|
|