Sdílet prostřednictvím


Avx Třída

Definice

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Tato třída poskytuje přístup k hardwarovým instrukcím Intel AVX prostřednictvím vnitřních součástí.

public ref class Avx abstract : System::Runtime::Intrinsics::X86::Sse42
[System.CLSCompliant(false)]
public abstract class Avx : System.Runtime.Intrinsics.X86.Sse42
[<System.CLSCompliant(false)>]
type Avx = class
    inherit Sse42
Public MustInherit Class Avx
Inherits Sse42
Dědičnost
Dědičnost
Odvozené
Atributy

Vlastnosti

IsSupported

Tato třída poskytuje přístup k hardwarovým instrukcím Intel AVX prostřednictvím vnitřních součástí.

Metody

Add(Vector256<Double>, Vector256<Double>)

__m256d _mm256_add_pd (__m256d a, __m256d b)

VADDPD ymm, ymm, ymm/m256

Add(Vector256<Single>, Vector256<Single>)

__m256 _mm256_add_ps (__m256 a, __m256 b)

VADDPS ymm, ymm, ymm/m256

AddSubtract(Vector256<Double>, Vector256<Double>)

__m256d _mm256_addsub_pd (__m256d a, __m256d b)

VADDSUBPD ymm, ymm, ymm/m256

AddSubtract(Vector256<Single>, Vector256<Single>)

__m256 _mm256_addsub_ps (__m256 a, __m256 b)

VADDSUBPS ymm, ymm, ymm/m256

And(Vector256<Double>, Vector256<Double>)

__m256d _mm256_and_pd (__m256d a, __m256d b)

VANDPD ymm, ymm, ymm/m256

And(Vector256<Single>, Vector256<Single>)

__m256 _mm256_and_ps (__m256 a, __m256 b)

VANDPS ymm, ymm, ymm/m256

AndNot(Vector256<Double>, Vector256<Double>)

__m256d _mm256_andnot_pd (__m256d a, __m256d b)

VANDNPD ymm, ymm, ymm/m256

AndNot(Vector256<Single>, Vector256<Single>)

__m256 _mm256_andnot_ps (__m256 a, __m256 b)

VANDNPS ymm, ymm, ymm/m256

Blend(Vector256<Double>, Vector256<Double>, Byte)

__m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8)

VBLENDPD ymm, ymm, ymm/m256, imm8

Blend(Vector256<Single>, Vector256<Single>, Byte)

__m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8)

VBLENDPS ymm, ymm, ymm/m256, imm8

BlendVariable(Vector256<Double>, Vector256<Double>, Vector256<Double>)

__m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d maska)

VBLENDVPD ymm, ymm, ymm/m256, ymm

BlendVariable(Vector256<Single>, Vector256<Single>, Vector256<Single>)

__m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 maska)

VBLENDVPS ymm, ymm, ymm/m256, ymm

BroadcastScalarToVector128(Single*)

__m128 _mm_broadcast_ss (float const × mem_addr)

VBROADCASTSS xmm, m32

BroadcastScalarToVector256(Double*)

__m256d _mm256_broadcast_sd (dvojitá konstanta * mem_addr)

VBROADCASTSD ymm, m64

BroadcastScalarToVector256(Single*)

__m256 _mm256_broadcast_ss (float const × mem_addr)

VBROADCASTSS ymm, m32

BroadcastVector128ToVector256(Double*)

__m256d _mm256_broadcast_pd (__m128d const * mem_addr)

VBROADCASTF128, ymm, m128

BroadcastVector128ToVector256(Single*)

__m256 _mm256_broadcast_ps (__m128 × mem_addr)

VBROADCASTF128, ymm, m128

Ceiling(Vector256<Double>)

__m256d _mm256_ceil_pd (__m256d a)

VROUNDPD ymm, ymm/m256, imm8(10)

Ceiling(Vector256<Single>)

__m256 _mm256_ceil_ps (__m256 a)

VROUNDPS ymm, ymm/m256, imm8(10)

Compare(Vector128<Double>, Vector128<Double>, FloatComparisonMode)

__m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8)

VCMPPD xmm, xmm, xmm/m128, imm8

Compare(Vector128<Single>, Vector128<Single>, FloatComparisonMode)

__m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8)

VCMPPS xmm, xmm, xmm/m128, imm8

Compare(Vector256<Double>, Vector256<Double>, FloatComparisonMode)

__m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8)

VCMPPD ymm, ymm, ymm/m256, imm8

Compare(Vector256<Single>, Vector256<Single>, FloatComparisonMode)

__m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8)

VCMPPS ymm, ymm, ymm/m256, imm8

CompareEqual(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpeq_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(0)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareEqual(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpeq_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(0)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareGreaterThan(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpgt_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(14)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareGreaterThan(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpgt_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(14)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareGreaterThanOrEqual(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpge_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(13)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareGreaterThanOrEqual(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpge_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(13)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareLessThan(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmplt_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(1)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareLessThan(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmplt_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(1)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareLessThanOrEqual(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmple_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(2)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareLessThanOrEqual(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmple_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(2)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotEqual(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpneq_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(4)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotEqual(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpneq_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(4)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotGreaterThan(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpngt_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(10)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotGreaterThan(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpngt_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(10)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotGreaterThanOrEqual(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpnge_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(9)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotGreaterThanOrEqual(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpnge_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(9)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotLessThan(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpnlt_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(5)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotLessThan(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpnlt_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(5)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotLessThanOrEqual(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpnle_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(6)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareNotLessThanOrEqual(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpnle_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(6)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareOrdered(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpord_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(7)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareOrdered(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpord_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(7)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareScalar(Vector128<Double>, Vector128<Double>, FloatComparisonMode)

__m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8)

VCMPSS xmm, xmm, xmm/m32, imm8

CompareScalar(Vector128<Single>, Vector128<Single>, FloatComparisonMode)

__m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8)

VCMPSD xmm, xmm, xmm/m64, imm8

CompareUnordered(Vector256<Double>, Vector256<Double>)

__m256d _mm256_cmpunord_pd (__m256d a, __m256d b) CMPPD ymm, ymm/m256, imm8(3)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

CompareUnordered(Vector256<Single>, Vector256<Single>)

__m256 _mm256_cmpunord_ps (__m256 a, __m256 b) CMPPS ymm, ymm/m256, imm8(3)

Výše uvedený nativní podpis neexistuje. Toto dodatečné přetížení poskytujeme pro úplnost.

ConvertToVector128Int32(Vector256<Double>)

__m128i _mm256_cvtpd_epi32 (__m256d a)

VCVTPD2DQ xmm, ymm/m256

ConvertToVector128Int32WithTruncation(Vector256<Double>)

__m128i _mm256_cvttpd_epi32 (__m256d a)

VCVTTPD2DQ xmm, ymm/m256

ConvertToVector128Single(Vector256<Double>)

__m128 _mm256_cvtpd_ps (__m256d a)

VCVTPD2PS xmm, ymm/m256

ConvertToVector256Double(Vector128<Int32>)

__m256d _mm256_cvtepi32_pd (__m128i a)

VCVTDQ2PD ymm, xmm/m128

ConvertToVector256Double(Vector128<Single>)

__m256d _mm256_cvtps_pd (__m128 a)

VCVTPS2PD ymm, xmm/m128

ConvertToVector256Int32(Vector256<Single>)

__m256i _mm256_cvtps_epi32 (__m256 a)

VCVTPS2DQ ymm, ymm/m256

ConvertToVector256Int32WithTruncation(Vector256<Single>)

__m256i _mm256_cvttps_epi32 (__m256 a)

VCVTTPS2DQ ymm, ymm/m256

ConvertToVector256Single(Vector256<Int32>)

__m256 _mm256_cvtepi32_ps (__m256i a)

VCVTDQ2PS ymm, ymm/m256

Divide(Vector256<Double>, Vector256<Double>)

__m256d _mm256_div_pd (__m256d a, __m256d b)

VDIVPD ymm, ymm, ymm/m256

Divide(Vector256<Single>, Vector256<Single>)

__m256 _mm256_div_ps (__m256 a, __m256 b)

VDIVPS ymm, ymm, ymm/m256

DotProduct(Vector256<Single>, Vector256<Single>, Byte)

__m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8)

VDPPS ymm, ymm, ymm/m256, imm8

DuplicateEvenIndexed(Vector256<Double>)

__m256d _mm256_movedup_pd (__m256d a)

VMOVDDUP ymm, ymm/m256

DuplicateEvenIndexed(Vector256<Single>)

__m256 _mm256_moveldup_ps (__m256 a)

VMOVSLDUP ymm, ymm/m256

DuplicateOddIndexed(Vector256<Single>)

__m256 _mm256_movehdup_ps (__m256 a)

VMOVSHDUP ymm, ymm/m256

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
ExtractVector128(Vector256<Byte>, Byte)

__m128i _mm256_extractf128_si256 (__m256i a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

ExtractVector128(Vector256<Double>, Byte)

__m128d _mm256_extractf128_pd (__m256d a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

ExtractVector128(Vector256<Int16>, Byte)

__m128i _mm256_extractf128_si256 (__m256i a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

ExtractVector128(Vector256<Int32>, Byte)

__m128i _mm256_extractf128_si256 (__m256i a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

ExtractVector128(Vector256<Int64>, Byte)

__m128i _mm256_extractf128_si256 (__m256i a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

ExtractVector128(Vector256<SByte>, Byte)

__m128i _mm256_extractf128_si256 (__m256i a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

ExtractVector128(Vector256<Single>, Byte)

__m128 _mm256_extractf128_ps (__m256 a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

ExtractVector128(Vector256<UInt16>, Byte)

__m128i _mm256_extractf128_si256 (__m256i a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

ExtractVector128(Vector256<UInt32>, Byte)

__m128i _mm256_extractf128_si256 (__m256i a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

ExtractVector128(Vector256<UInt64>, Byte)

__m128i _mm256_extractf128_si256 (__m256i a, const int imm8)

VEXTRACTF128 xmm/m128, ymm, imm8

Floor(Vector256<Double>)

__m256d _mm256_floor_pd (__m256d a)

VROUNDPS ymm, ymm/m256, imm8(9)

Floor(Vector256<Single>)

__m256 _mm256_floor_ps (__m256 a)

VROUNDPS ymm, ymm/m256, imm8(9)

GetHashCode()

Slouží jako výchozí hashovací funkce.

(Zděděno od Object)
GetType()

Type Získá z aktuální instance.

(Zděděno od Object)
HorizontalAdd(Vector256<Double>, Vector256<Double>)

__m256d _mm256_hadd_pd (__m256d a, __m256d b)

VHADDPD ymm, ymm, ymm/m256

HorizontalAdd(Vector256<Single>, Vector256<Single>)

__m256 _mm256_hadd_ps (__m256 a, __m256 b)

VHADDPS ymm, ymm, ymm/m256

HorizontalSubtract(Vector256<Double>, Vector256<Double>)

__m256d _mm256_hsub_pd (__m256d a, __m256d b)

VHSUBPD ymm, ymm, ymm/m256

HorizontalSubtract(Vector256<Single>, Vector256<Single>)

__m256 _mm256_hsub_ps (__m256 a, __m256 b)

VHSUBPS ymm, ymm, ymm/m256

InsertVector128(Vector256<Byte>, Vector128<Byte>, Byte)

__m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

InsertVector128(Vector256<Double>, Vector128<Double>, Byte)

__m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

InsertVector128(Vector256<Int16>, Vector128<Int16>, Byte)

__m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

InsertVector128(Vector256<Int32>, Vector128<Int32>, Byte)

__m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

InsertVector128(Vector256<Int64>, Vector128<Int64>, Byte)

__m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

InsertVector128(Vector256<SByte>, Vector128<SByte>, Byte)

__m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

InsertVector128(Vector256<Single>, Vector128<Single>, Byte)

__m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

InsertVector128(Vector256<UInt16>, Vector128<UInt16>, Byte)

__m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

InsertVector128(Vector256<UInt32>, Vector128<UInt32>, Byte)

__m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

InsertVector128(Vector256<UInt64>, Vector128<UInt64>, Byte)

__m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)

VINSERTF128 ymm, ymm, xmm/m128, imm8

LoadAlignedVector256(Byte*)

__m256i _mm256_load_si256 (__m256i const * mem_addr)

VMOVDQA ymm, m256

LoadAlignedVector256(Double*)

__m256d _mm256_load_pd (double const * mem_addr)

VMOVAPD ymm, ymm/m256

LoadAlignedVector256(Int16*)

__m256i _mm256_load_si256 (__m256i const * mem_addr)

VMOVDQA ymm, m256

LoadAlignedVector256(Int32*)

__m256i _mm256_load_si256 (__m256i const * mem_addr)

VMOVDQA ymm, m256

LoadAlignedVector256(Int64*)

__m256i _mm256_load_si256 (__m256i const * mem_addr)

VMOVDQA ymm, m256

LoadAlignedVector256(SByte*)

__m256i _mm256_load_si256 (__m256i const * mem_addr)

VMOVDQA ymm, m256

LoadAlignedVector256(Single*)

__m256 _mm256_load_ps (float const * mem_addr)

VMOVAPS ymm, ymm/m256

LoadAlignedVector256(UInt16*)

__m256i _mm256_load_si256 (__m256i const * mem_addr)

VMOVDQA ymm, m256

LoadAlignedVector256(UInt32*)

__m256i _mm256_load_si256 (__m256i const * mem_addr)

VMOVDQA ymm, m256

LoadAlignedVector256(UInt64*)

__m256i _mm256_load_si256 (__m256i const * mem_addr)

VMOVDQA ymm, m256

LoadDquVector256(Byte*)

__m256i _mm256_lddqu_si256 (__m256i const * mem_addr)

VLDDQU ymm, m256

LoadDquVector256(Int16*)

__m256i _mm256_lddqu_si256 (__m256i const * mem_addr)

VLDDQU ymm, m256

LoadDquVector256(Int32*)

__m256i _mm256_lddqu_si256 (__m256i const * mem_addr)

VLDDQU ymm, m256

LoadDquVector256(Int64*)

__m256i _mm256_lddqu_si256 (__m256i const * mem_addr)

VLDDQU ymm, m256

LoadDquVector256(SByte*)

__m256i _mm256_lddqu_si256 (__m256i const * mem_addr)

VLDDQU ymm, m256

LoadDquVector256(UInt16*)

__m256i _mm256_lddqu_si256 (__m256i const * mem_addr)

VLDDQU ymm, m256

LoadDquVector256(UInt32*)

__m256i _mm256_lddqu_si256 (__m256i const * mem_addr)

VLDDQU ymm, m256

LoadDquVector256(UInt64*)

__m256i _mm256_lddqu_si256 (__m256i const * mem_addr)

VLDDQU ymm, m256

LoadVector256(Byte*)

__m256i _mm256_loadu_si256 (__m256i const * mem_addr)

VMOVDQU ymm, m256

LoadVector256(Double*)

__m256d _mm256_loadu_pd (double const * mem_addr)

VMOVUPD ymm, ymm/m256

LoadVector256(Int16*)

__m256i _mm256_loadu_si256 (__m256i const * mem_addr)

VMOVDQU ymm, m256

LoadVector256(Int32*)

__m256i _mm256_loadu_si256 (__m256i const * mem_addr)

VMOVDQU ymm, m256

LoadVector256(Int64*)

__m256i _mm256_loadu_si256 (__m256i const * mem_addr)

VMOVDQU ymm, m256

LoadVector256(SByte*)

__m256i _mm256_loadu_si256 (__m256i const * mem_addr)

VMOVDQU ymm, m256

LoadVector256(Single*)

__m256 _mm256_loadu_ps (float const * mem_addr)

VMOVUPS ymm, ymm/m256

LoadVector256(UInt16*)

__m256i _mm256_loadu_si256 (__m256i const * mem_addr)

VMOVDQU ymm, m256

LoadVector256(UInt32*)

__m256i _mm256_loadu_si256 (__m256i const * mem_addr)

VMOVDQU ymm, m256

LoadVector256(UInt64*)

__m256i _mm256_loadu_si256 (__m256i const * mem_addr)

VMOVDQU ymm, m256

MaskLoad(Double*, Vector128<Double>)

__m128d _mm_maskload_pd (double const * mem_addr, __m128i maska)

VMASKMOVPD xmm, xmm, m128

MaskLoad(Double*, Vector256<Double>)

__m256d _mm256_maskload_pd (double const * mem_addr, __m256i maska)

VMASKMOVPD ymm, ymm, m256

MaskLoad(Single*, Vector128<Single>)

__m128 _mm_maskload_ps (float const * mem_addr, __m128i maska)

VMASKMOVPS xmm, xmm, m128

MaskLoad(Single*, Vector256<Single>)

__m256 _mm256_maskload_ps (float const * mem_addr, __m256i maska)

VMASKMOVPS ymm, ymm, m256

MaskStore(Double*, Vector128<Double>, Vector128<Double>)

void _mm_maskstore_pd (dvojitá * mem_addr, __m128i maska, __m128d a)

VMASKMOVPD m128, xmm, xmm

MaskStore(Double*, Vector256<Double>, Vector256<Double>)

void _mm256_maskstore_pd (dvojitá * mem_addr, __m256i maska __m256d a)

VMASKMOVPD m256, ymm, ymm

MaskStore(Single*, Vector128<Single>, Vector128<Single>)

void _mm_maskstore_ps (float * mem_addr, __m128i maska __m128 a)

VMASKMOVPS m128, xmm, xmm

MaskStore(Single*, Vector256<Single>, Vector256<Single>)

void _mm256_maskstore_ps (float * mem_addr, __m256i maska __m256 a)

VMASKMOVPS m256, ymm, ymm

Max(Vector256<Double>, Vector256<Double>)

__m256d _mm256_max_pd (__m256d a, __m256d b)

VMAXPD ymm, ymm, ymm/m256

Max(Vector256<Single>, Vector256<Single>)

__m256 _mm256_max_ps (__m256 a, __m256 b)

VMAXPS ymm, ymm, ymm/m256

MemberwiseClone()

Vytvoří mělkou kopii aktuálního Objectsouboru .

(Zděděno od Object)
Min(Vector256<Double>, Vector256<Double>)

__m256d _mm256_min_pd (__m256d a, __m256d b)

VMINPD ymm, ymm, ymm/m256

Min(Vector256<Single>, Vector256<Single>)

__m256 _mm256_min_ps (__m256 a, __m256 b)

VMINPS ymm, ymm, ymm/m256

MoveMask(Vector256<Double>)

int _mm256_movemask_pd (__m256d a)

VMOVMSKPD reg, ymm

MoveMask(Vector256<Single>)

int _mm256_movemask_ps (__m256 a)

VMOVMSKPS reg, ymm

Multiply(Vector256<Double>, Vector256<Double>)

__m256d _mm256_mul_pd (__m256d a, __m256d b)

VMULPD ymm, ymm, ymm/m256

Multiply(Vector256<Single>, Vector256<Single>)

__m256 _mm256_mul_ps (__m256 a, __m256 b)

VMULPS ymm, ymm, ymm/m256

Or(Vector256<Double>, Vector256<Double>)

__m256d _mm256_or_pd (__m256d a, __m256d b)

VORPD ymm, ymm, ymm/m256

Or(Vector256<Single>, Vector256<Single>)

__m256 _mm256_or_ps (__m256 a, __m256 b)

VORPS ymm, ymm, ymm/m256

Permute(Vector128<Double>, Byte)

__m128d _mm_permute_pd (__m128d a, int imm8)

VPERMILPD xmm, xmm, imm8

Permute(Vector128<Single>, Byte)

__m128 _mm_permute_ps (__m128 a, int imm8)

VPERMILPS xmm, xmm, imm8

Permute(Vector256<Double>, Byte)

__m256d _mm256_permute_pd (__m256d a, int imm8)

VPERMILPD ymm, ymm, imm8

Permute(Vector256<Single>, Byte)

__m256 _mm256_permute_ps (__m256 a, int imm8)

VPERMILPS ymm, ymm, imm8

Permute2x128(Vector256<Byte>, Vector256<Byte>, Byte)

__m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

Permute2x128(Vector256<Double>, Vector256<Double>, Byte)

__m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

Permute2x128(Vector256<Int16>, Vector256<Int16>, Byte)

__m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

Permute2x128(Vector256<Int32>, Vector256<Int32>, Byte)

__m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

Permute2x128(Vector256<Int64>, Vector256<Int64>, Byte)

__m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

Permute2x128(Vector256<SByte>, Vector256<SByte>, Byte)

__m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

Permute2x128(Vector256<Single>, Vector256<Single>, Byte)

__m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

Permute2x128(Vector256<UInt16>, Vector256<UInt16>, Byte)

__m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

Permute2x128(Vector256<UInt32>, Vector256<UInt32>, Byte)

__m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

Permute2x128(Vector256<UInt64>, Vector256<UInt64>, Byte)

__m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)

VPERM2F128 ymm, ymm, ymm/m256, imm8

PermuteVar(Vector128<Double>, Vector128<Int64>)

__m128d _mm_permutevar_pd (__m128d a, __m128i b)

VPERMILPD xmm, xmm, xmm/m128

PermuteVar(Vector128<Single>, Vector128<Int32>)

__m128 _mm_permutevar_ps (__m128 a, __m128i b)

VPERMILPS xmm, xmm, xmm/m128

PermuteVar(Vector256<Double>, Vector256<Int64>)

__m256d _mm256_permutevar_pd (__m256d a, __m256i b)

VPERMILPD ymm, ymm, ymm/m256

PermuteVar(Vector256<Single>, Vector256<Int32>)

__m256 _mm256_permutevar_ps (__m256 a, __m256i b)

VPERMILPS ymm, ymm, ymm/m256

Reciprocal(Vector256<Single>)

__m256 _mm256_rcp_ps (__m256 a)

VRCPPS ymm, ymm/m256

ReciprocalSqrt(Vector256<Single>)

__m256 _mm256_rsqrt_ps (__m256 a)

VRSQRTPS ymm, ymm/m256

RoundCurrentDirection(Vector256<Double>)

__m256d _mm256_round_pd (__m256d a, _MM_FROUND_CUR_DIRECTION)

VROUNDPD ymm, ymm/m256, imm8(4)

RoundCurrentDirection(Vector256<Single>)

__m256 _mm256_round_ps (__m256 a, _MM_FROUND_CUR_DIRECTION)

VROUNDPS ymm, ymm/m256, imm8(4)

RoundToNearestInteger(Vector256<Double>)

__m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)

VROUNDPD ymm, ymm/m256, imm8(8)

RoundToNearestInteger(Vector256<Single>)

__m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)

VROUNDPS ymm, ymm/m256, imm8(8)

RoundToNegativeInfinity(Vector256<Double>)

__m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)

VROUNDPD ymm, ymm/m256, imm8(9)

RoundToNegativeInfinity(Vector256<Single>)

__m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)

VROUNDPS ymm, ymm/m256, imm8(9)

RoundToPositiveInfinity(Vector256<Double>)

__m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)

VROUNDPD ymm, ymm/m256, imm8(10)

RoundToPositiveInfinity(Vector256<Single>)

__m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)

VROUNDPS ymm, ymm/m256, imm8(10)

RoundToZero(Vector256<Double>)

__m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)

VROUNDPD ymm, ymm/m256, imm8(11)

RoundToZero(Vector256<Single>)

__m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)

VROUNDPS ymm, ymm/m256, imm8(11)

Shuffle(Vector256<Double>, Vector256<Double>, Byte)

__m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8)

VSHUFPD ymm, ymm, ymm/m256, imm8

Shuffle(Vector256<Single>, Vector256<Single>, Byte)

__m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8)

VSHUFPS ymm, ymm, ymm/m256, imm8

Sqrt(Vector256<Double>)

__m256d _mm256_sqrt_pd (__m256d a)

VSQRTPD ymm, ymm/m256

Sqrt(Vector256<Single>)

__m256 _mm256_sqrt_ps (__m256 a)

VSQRTPS ymm, ymm/m256

Store(Byte*, Vector256<Byte>)

void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)

MOVDQU m256, ymm

Store(Double*, Vector256<Double>)

void _mm256_storeu_pd (double * mem_addr, __m256d a)

MOVUPD m256, ymm

Store(Int16*, Vector256<Int16>)

void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)

MOVDQU m256, ymm

Store(Int32*, Vector256<Int32>)

void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)

MOVDQU m256, ymm

Store(Int64*, Vector256<Int64>)

void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)

MOVDQU m256, ymm

Store(SByte*, Vector256<SByte>)

void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)

MOVDQU m256, ymm

Store(Single*, Vector256<Single>)

void _mm256_storeu_ps (float * mem_addr, __m256 a)

MOVUPS m256, ymm

Store(UInt16*, Vector256<UInt16>)

void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)

MOVDQU m256, ymm

Store(UInt32*, Vector256<UInt32>)

void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)

MOVDQU m256, ymm

Store(UInt64*, Vector256<UInt64>)

void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)

MOVDQU m256, ymm

StoreAligned(Byte*, Vector256<Byte>)

void _mm256_store_si256 (__m256i * mem_addr, __m256i a)

MOVDQA m256, ymm

StoreAligned(Double*, Vector256<Double>)

void _mm256_store_pd (double * mem_addr, __m256d a)

VMOVAPD m256, ymm

StoreAligned(Int16*, Vector256<Int16>)

void _mm256_store_si256 (__m256i * mem_addr, __m256i a)

MOVDQA m256, ymm

StoreAligned(Int32*, Vector256<Int32>)

void _mm256_store_si256 (__m256i * mem_addr, __m256i a)

MOVDQA m256, ymm

StoreAligned(Int64*, Vector256<Int64>)

void _mm256_store_si256 (__m256i * mem_addr, __m256i a)

MOVDQA m256, ymm

StoreAligned(SByte*, Vector256<SByte>)

void _mm256_store_si256 (__m256i * mem_addr, __m256i a)

MOVDQA m256, ymm

StoreAligned(Single*, Vector256<Single>)

void _mm256_store_ps (float * mem_addr, __m256 a)

VMOVAPS m256, ymm

StoreAligned(UInt16*, Vector256<UInt16>)

void _mm256_store_si256 (__m256i * mem_addr, __m256i a)

MOVDQA m256, ymm

StoreAligned(UInt32*, Vector256<UInt32>)

void _mm256_store_si256 (__m256i * mem_addr, __m256i a)

MOVDQA m256, ymm

StoreAligned(UInt64*, Vector256<UInt64>)

void _mm256_store_si256 (__m256i * mem_addr, __m256i a)

MOVDQA m256, ymm

StoreAlignedNonTemporal(Byte*, Vector256<Byte>)

void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)

VMOVNTDQ m256, ymm

StoreAlignedNonTemporal(Double*, Vector256<Double>)

void _mm256_stream_pd (double * mem_addr, __m256d a)

MOVNTPD m256, ymm

StoreAlignedNonTemporal(Int16*, Vector256<Int16>)

void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)

VMOVNTDQ m256, ymm

StoreAlignedNonTemporal(Int32*, Vector256<Int32>)

void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)

VMOVNTDQ m256, ymm

StoreAlignedNonTemporal(Int64*, Vector256<Int64>)

void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)

VMOVNTDQ m256, ymm

StoreAlignedNonTemporal(SByte*, Vector256<SByte>)

void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)

VMOVNTDQ m256, ymm

StoreAlignedNonTemporal(Single*, Vector256<Single>)

void _mm256_stream_ps (float * mem_addr, __m256 a)

MOVNTPS m256, ymm

StoreAlignedNonTemporal(UInt16*, Vector256<UInt16>)

void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)

VMOVNTDQ m256, ymm

StoreAlignedNonTemporal(UInt32*, Vector256<UInt32>)

void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)

VMOVNTDQ m256, ymm

StoreAlignedNonTemporal(UInt64*, Vector256<UInt64>)

void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)

VMOVNTDQ m256, ymm

Subtract(Vector256<Double>, Vector256<Double>)

__m256d _mm256_sub_pd (__m256d a, __m256d b)

VSUBPD ymm, ymm, ymm/m256

Subtract(Vector256<Single>, Vector256<Single>)

__m256 _mm256_sub_ps (__m256 a, __m256 b)

VSUBPS ymm, ymm, ymm/m256

TestC(Vector128<Double>, Vector128<Double>)

int _mm_testc_pd (__m128d a, __m128d b)

VTESTPD xmm, xmm/m128

TestC(Vector128<Single>, Vector128<Single>)

int _mm_testc_ps (__m128 a, __m128 b)

VTESTPS xmm, xmm/m128

TestC(Vector256<Byte>, Vector256<Byte>)

int _mm256_testc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestC(Vector256<Double>, Vector256<Double>)

int _mm256_testc_pd (__m256d a, __m256d b)

VTESTPS ymm, ymm/m256

TestC(Vector256<Int16>, Vector256<Int16>)

int _mm256_testc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestC(Vector256<Int32>, Vector256<Int32>)

int _mm256_testc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestC(Vector256<Int64>, Vector256<Int64>)

int _mm256_testc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestC(Vector256<SByte>, Vector256<SByte>)

int _mm256_testc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestC(Vector256<Single>, Vector256<Single>)

int _mm256_testc_ps (__m256 a, __m256 b)

VTESTPS ymm, ymm/m256

TestC(Vector256<UInt16>, Vector256<UInt16>)

int _mm256_testc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestC(Vector256<UInt32>, Vector256<UInt32>)

int _mm256_testc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestC(Vector256<UInt64>, Vector256<UInt64>)

int _mm256_testc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestNotZAndNotC(Vector128<Double>, Vector128<Double>)

int _mm_testnzc_pd (__m128d a, __m128d b)

VTESTPD xmm, xmm/m128

TestNotZAndNotC(Vector128<Single>, Vector128<Single>)

int _mm_testnzc_ps (__m128 a, __m128 b)

VTESTPS xmm, xmm/m128

TestNotZAndNotC(Vector256<Byte>, Vector256<Byte>)

int _mm256_testnzc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestNotZAndNotC(Vector256<Double>, Vector256<Double>)

int _mm256_testnzc_pd (__m256d a, __m256d b)

VTESTPD ymm, ymm/m256

TestNotZAndNotC(Vector256<Int16>, Vector256<Int16>)

int _mm256_testnzc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestNotZAndNotC(Vector256<Int32>, Vector256<Int32>)

int _mm256_testnzc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestNotZAndNotC(Vector256<Int64>, Vector256<Int64>)

int _mm256_testnzc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestNotZAndNotC(Vector256<SByte>, Vector256<SByte>)

int _mm256_testnzc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestNotZAndNotC(Vector256<Single>, Vector256<Single>)

int _mm256_testnzc_ps (__m256 a, __m256 b)

VTESTPS ymm, ymm/m256

TestNotZAndNotC(Vector256<UInt16>, Vector256<UInt16>)

int _mm256_testnzc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestNotZAndNotC(Vector256<UInt32>, Vector256<UInt32>)

int _mm256_testnzc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestNotZAndNotC(Vector256<UInt64>, Vector256<UInt64>)

int _mm256_testnzc_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestZ(Vector128<Double>, Vector128<Double>)

int _mm_testz_pd (__m128d a, __m128d b)

VTESTPD xmm, xmm/m128

TestZ(Vector128<Single>, Vector128<Single>)

int _mm_testz_ps (__m128 a, __m128 b)

VTESTPS xmm, xmm/m128

TestZ(Vector256<Byte>, Vector256<Byte>)

int _mm256_testz_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestZ(Vector256<Double>, Vector256<Double>)

int _mm256_testz_pd (__m256d a, __m256d b)

VTESTPD ymm, ymm/m256

TestZ(Vector256<Int16>, Vector256<Int16>)

int _mm256_testz_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestZ(Vector256<Int32>, Vector256<Int32>)

int _mm256_testz_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestZ(Vector256<Int64>, Vector256<Int64>)

int _mm256_testz_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestZ(Vector256<SByte>, Vector256<SByte>)

int _mm256_testz_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestZ(Vector256<Single>, Vector256<Single>)

int _mm256_testz_ps (__m256 a, __m256 b)

VTESTPS ymm, ymm/m256

TestZ(Vector256<UInt16>, Vector256<UInt16>)

int _mm256_testz_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestZ(Vector256<UInt32>, Vector256<UInt32>)

int _mm256_testz_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

TestZ(Vector256<UInt64>, Vector256<UInt64>)

int _mm256_testz_si256 (__m256i a, __m256i b)

VPTEST ymm, ymm/m256

ToString()

Vrátí řetězec, který představuje aktuální objekt.

(Zděděno od Object)
UnpackHigh(Vector256<Double>, Vector256<Double>)

__m256d _mm256_unpackhi_pd (__m256d a, __m256d b)

VUNPCKHPD ymm, ymm, ymm/m256

UnpackHigh(Vector256<Single>, Vector256<Single>)

__m256 _mm256_unpackhi_ps (__m256 a, __m256 b)

VUNPCKHPS ymm, ymm, ymm/m256

UnpackLow(Vector256<Double>, Vector256<Double>)

__m256d _mm256_unpacklo_pd (__m256d a, __m256d b)

VUNPCKLPD ymm, ymm, ymm/m256

UnpackLow(Vector256<Single>, Vector256<Single>)

__m256 _mm256_unpacklo_ps (__m256 a, __m256 b)

VUNPCKLPS ymm, ymm, ymm/m256

Xor(Vector256<Double>, Vector256<Double>)

__m256d _mm256_xor_pd (__m256d a, __m256d b)

VXORPS ymm, ymm, ymm/m256

Xor(Vector256<Single>, Vector256<Single>)

__m256 _mm256_xor_ps (__m256 a, __m256 b)

VXORPS ymm, ymm, ymm/m256

Platí pro