AdvSimd.Store 方法

定义

命名空间:

System.Runtime.Intrinsics.Arm

程序集:

System.Runtime.Intrinsics.dll

重载

Store(Single*, Vector128<Single>)	void vst1q_f32 （float32_t * ptr， float32x4_t val） A32：VST1.32 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.4S }， [Xn]
Store(Single*, Vector64<Single>)	void vst1_f32 （float32_t * ptr， float32x2_t val） A32：VST1.32 { Dd }， [Rn] A64：ST1 { Vt.2S }， [Xn]
Store(UInt16*, Vector128<UInt16>)	void vst1q_u16 （uint16_t * ptr， uint16x8_t val） A32：VST1.16 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.8H }， [Xn]
Store(UInt16*, Vector64<UInt16>)	void vst1_u16 （uint16_t * ptr， uint16x4_t val） A32：VST1.16 { Dd }， [Rn] A64：ST1 { Vt.4H }， [Xn]
Store(Int16*, Vector64<Int16>)	void vst1_s16 （int16_t * ptr， int16x4_t val） A32：VST1.16 { Dd }， [Rn] A64：ST1 {Vt.4H }， [Xn]
Store(UInt32*, Vector128<UInt32>)	void vst1q_u32 （uint32_t * ptr， uint32x4_t val） A32：VST1.32 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.4S }， [Xn]
Store(UInt32*, Vector64<UInt32>)	void vst1_u32 （uint32_t * ptr， uint32x2_t val） A32：VST1.32 { Dd }， [Rn] A64：ST1 { Vt.2S }， [Xn]
Store(UInt64*, Vector128<UInt64>)	void vst1q_u64 （uint64_t * ptr， uint64x2_t val） A32：VST1.64 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.2D }， [Xn]
Store(UInt64*, Vector64<UInt64>)	void vst1_u64 （uint64_t * ptr， uint64x1_t val） A32：VST1.64 { Dd }， [Rn] A64：ST1 { Vt.1D }， [Xn]
Store(Int16*, Vector128<Int16>)	void vst1q_s16 （int16_t * ptr， int16x8_t val） A32：VST1.16 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.8H }， [Xn]
Store(SByte*, Vector128<SByte>)	void vst1q_s8 （int8_t * ptr， int8x16_t val） A32：VST1.8 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.16B }， [Xn]
Store(SByte*, Vector64<SByte>)	void vst1_s8 （int8_t * ptr， int8x8_t val） A32：VST1.8 { Dd }， [Rn] A64：ST1 { Vt.8B }， [Xn]
Store(Byte*, Vector64<Byte>)	void vst1_u8 （uint8_t * ptr， uint8x8_t val） A32：VST1.8 { Dd }， [Rn] A64：ST1 { Vt.8B }， [Xn]
Store(Double*, Vector128<Double>)	void vst1q_f64 （float64_t * ptr， float64x2_t val） A32：VST1.64 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.2D }， [Xn]
Store(Double*, Vector64<Double>)	void vst1_f64 （float64_t * ptr， float64x1_t val） A32：VST1.64 { Dd }， [Rn] A64：ST1 { Vt.1D }， [Xn]
Store(Byte*, Vector128<Byte>)	void vst1q_u8 （uint8_t * ptr， uint8x16_t val） A32：VST1.8 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.16B }， [Xn]
Store(Int64*, Vector128<Int64>)	void vst1q_s64 （int64_t * ptr， int64x2_t val） A32：VST1.64 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.2D }， [Xn]
Store(Int64*, Vector64<Int64>)	void vst1_s64 （int64_t * ptr， int64x1_t val） A32：VST1.64 { Dd }， [Rn] A64：ST1 { Vt.1D }， [Xn]
Store(Int32*, Vector64<Int32>)	void vst1_s32 （int32_t * ptr， int32x2_t val） A32：VST1.32 { Dd }， [Rn] A64：ST1 { Vt.2S }， [Xn]
Store(Int32*, Vector128<Int32>)	void vst1q_s32 （int32_t * ptr， int32x4_t val） A32：VST1.32 { Dd、Dd+1 }、[Rn] A64：ST1 { Vt.4S }， [Xn]

Store(Single*, Vector128<Single>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_f32 （float32_t * ptr， float32x4_t val）

A32：VST1.32 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.4S }， [Xn]

public:
 static void Store(float* address, System::Runtime::Intrinsics::Vector128<float> source);

public static void Store (float* address, System.Runtime.Intrinsics.Vector128<float> source);

static member Store : nativeptr<single> * System.Runtime.Intrinsics.Vector128<single> -> unit

参数

address

Single*

source

Vector128<Single>

Store(Single*, Vector64<Single>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_f32 （float32_t * ptr， float32x2_t val）

A32：VST1.32 { Dd }， [Rn]

A64：ST1 { Vt.2S }， [Xn]

public:
 static void Store(float* address, System::Runtime::Intrinsics::Vector64<float> source);

public static void Store (float* address, System.Runtime.Intrinsics.Vector64<float> source);

static member Store : nativeptr<single> * System.Runtime.Intrinsics.Vector64<single> -> unit

参数

address

Single*

source

Vector64<Single>

Store(UInt16*, Vector128<UInt16>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_u16 （uint16_t * ptr， uint16x8_t val）

A32：VST1.16 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.8H }， [Xn]

public:
 static void Store(System::UInt16* address, System::Runtime::Intrinsics::Vector128<System::UInt16> source);

public static void Store (ushort* address, System.Runtime.Intrinsics.Vector128<ushort> source);

static member Store : nativeptr<uint16> * System.Runtime.Intrinsics.Vector128<uint16> -> unit

参数

address

UInt16*

source

Vector128<UInt16>

Store(UInt16*, Vector64<UInt16>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_u16 （uint16_t * ptr， uint16x4_t val）

A32：VST1.16 { Dd }， [Rn]

A64：ST1 { Vt.4H }， [Xn]

public:
 static void Store(System::UInt16* address, System::Runtime::Intrinsics::Vector64<System::UInt16> source);

public static void Store (ushort* address, System.Runtime.Intrinsics.Vector64<ushort> source);

static member Store : nativeptr<uint16> * System.Runtime.Intrinsics.Vector64<uint16> -> unit

参数

address

UInt16*

source

Vector64<UInt16>

Store(Int16*, Vector64<Int16>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_s16 （int16_t * ptr， int16x4_t val）

A32：VST1.16 { Dd }， [Rn]

A64：ST1 {Vt.4H }， [Xn]

public:
 static void Store(short* address, System::Runtime::Intrinsics::Vector64<short> source);

public static void Store (short* address, System.Runtime.Intrinsics.Vector64<short> source);

static member Store : nativeptr<int16> * System.Runtime.Intrinsics.Vector64<int16> -> unit

参数

address

Int16*

source

Vector64<Int16>

Store(UInt32*, Vector128<UInt32>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_u32 （uint32_t * ptr， uint32x4_t val）

A32：VST1.32 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.4S }， [Xn]

public:
 static void Store(System::UInt32* address, System::Runtime::Intrinsics::Vector128<System::UInt32> source);

public static void Store (uint* address, System.Runtime.Intrinsics.Vector128<uint> source);

static member Store : nativeptr<uint32> * System.Runtime.Intrinsics.Vector128<uint32> -> unit

参数

address

UInt32*

source

Vector128<UInt32>

Store(UInt32*, Vector64<UInt32>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_u32 （uint32_t * ptr， uint32x2_t val）

A32：VST1.32 { Dd }， [Rn]

A64：ST1 { Vt.2S }， [Xn]

public:
 static void Store(System::UInt32* address, System::Runtime::Intrinsics::Vector64<System::UInt32> source);

public static void Store (uint* address, System.Runtime.Intrinsics.Vector64<uint> source);

static member Store : nativeptr<uint32> * System.Runtime.Intrinsics.Vector64<uint32> -> unit

参数

address

UInt32*

source

Vector64<UInt32>

Store(UInt64*, Vector128<UInt64>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_u64 （uint64_t * ptr， uint64x2_t val）

A32：VST1.64 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.2D }， [Xn]

public:
 static void Store(System::UInt64* address, System::Runtime::Intrinsics::Vector128<System::UInt64> source);

public static void Store (ulong* address, System.Runtime.Intrinsics.Vector128<ulong> source);

static member Store : nativeptr<uint64> * System.Runtime.Intrinsics.Vector128<uint64> -> unit

参数

address

UInt64*

source

Vector128<UInt64>

Store(UInt64*, Vector64<UInt64>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_u64 （uint64_t * ptr， uint64x1_t val）

A32：VST1.64 { Dd }， [Rn]

A64：ST1 { Vt.1D }， [Xn]

public:
 static void Store(System::UInt64* address, System::Runtime::Intrinsics::Vector64<System::UInt64> source);

public static void Store (ulong* address, System.Runtime.Intrinsics.Vector64<ulong> source);

static member Store : nativeptr<uint64> * System.Runtime.Intrinsics.Vector64<uint64> -> unit

参数

address

UInt64*

source

Vector64<UInt64>

Store(Int16*, Vector128<Int16>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_s16 （int16_t * ptr， int16x8_t val）

A32：VST1.16 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.8H }， [Xn]

public:
 static void Store(short* address, System::Runtime::Intrinsics::Vector128<short> source);

public static void Store (short* address, System.Runtime.Intrinsics.Vector128<short> source);

static member Store : nativeptr<int16> * System.Runtime.Intrinsics.Vector128<int16> -> unit

参数

address

Int16*

source

Vector128<Int16>

Store(SByte*, Vector128<SByte>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_s8 （int8_t * ptr， int8x16_t val）

A32：VST1.8 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.16B }， [Xn]

public:
 static void Store(System::SByte* address, System::Runtime::Intrinsics::Vector128<System::SByte> source);

public static void Store (sbyte* address, System.Runtime.Intrinsics.Vector128<sbyte> source);

static member Store : nativeptr<sbyte> * System.Runtime.Intrinsics.Vector128<sbyte> -> unit

参数

address

SByte*

source

Vector128<SByte>

Store(SByte*, Vector64<SByte>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_s8 （int8_t * ptr， int8x8_t val）

A32：VST1.8 { Dd }， [Rn]

A64：ST1 { Vt.8B }， [Xn]

public:
 static void Store(System::SByte* address, System::Runtime::Intrinsics::Vector64<System::SByte> source);

public static void Store (sbyte* address, System.Runtime.Intrinsics.Vector64<sbyte> source);

static member Store : nativeptr<sbyte> * System.Runtime.Intrinsics.Vector64<sbyte> -> unit

参数

address

SByte*

source

Vector64<SByte>

Store(Byte*, Vector64<Byte>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_u8 （uint8_t * ptr， uint8x8_t val）

A32：VST1.8 { Dd }， [Rn]

A64：ST1 { Vt.8B }， [Xn]

public:
 static void Store(System::Byte* address, System::Runtime::Intrinsics::Vector64<System::Byte> source);

public static void Store (byte* address, System.Runtime.Intrinsics.Vector64<byte> source);

static member Store : nativeptr<byte> * System.Runtime.Intrinsics.Vector64<byte> -> unit

参数

address

Byte*

source

Vector64<Byte>

Store(Double*, Vector128<Double>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_f64 （float64_t * ptr， float64x2_t val）

A32：VST1.64 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.2D }， [Xn]

public:
 static void Store(double* address, System::Runtime::Intrinsics::Vector128<double> source);

public static void Store (double* address, System.Runtime.Intrinsics.Vector128<double> source);

static member Store : nativeptr<double> * System.Runtime.Intrinsics.Vector128<double> -> unit

参数

address

Double*

source

Vector128<Double>

Store(Double*, Vector64<Double>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_f64 （float64_t * ptr， float64x1_t val）

A32：VST1.64 { Dd }， [Rn]

A64：ST1 { Vt.1D }， [Xn]

public:
 static void Store(double* address, System::Runtime::Intrinsics::Vector64<double> source);

public static void Store (double* address, System.Runtime.Intrinsics.Vector64<double> source);

static member Store : nativeptr<double> * System.Runtime.Intrinsics.Vector64<double> -> unit

参数

address

Double*

source

Vector64<Double>

Store(Byte*, Vector128<Byte>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_u8 （uint8_t * ptr， uint8x16_t val）

A32：VST1.8 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.16B }， [Xn]

public:
 static void Store(System::Byte* address, System::Runtime::Intrinsics::Vector128<System::Byte> source);

public static void Store (byte* address, System.Runtime.Intrinsics.Vector128<byte> source);

static member Store : nativeptr<byte> * System.Runtime.Intrinsics.Vector128<byte> -> unit

参数

address

Byte*

source

Vector128<Byte>

Store(Int64*, Vector128<Int64>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_s64 （int64_t * ptr， int64x2_t val）

A32：VST1.64 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.2D }， [Xn]

public:
 static void Store(long* address, System::Runtime::Intrinsics::Vector128<long> source);

public static void Store (long* address, System.Runtime.Intrinsics.Vector128<long> source);

static member Store : nativeptr<int64> * System.Runtime.Intrinsics.Vector128<int64> -> unit

参数

address

Int64*

source

Vector128<Int64>

Store(Int64*, Vector64<Int64>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_s64 （int64_t * ptr， int64x1_t val）

A32：VST1.64 { Dd }， [Rn]

A64：ST1 { Vt.1D }， [Xn]

public:
 static void Store(long* address, System::Runtime::Intrinsics::Vector64<long> source);

public static void Store (long* address, System.Runtime.Intrinsics.Vector64<long> source);

static member Store : nativeptr<int64> * System.Runtime.Intrinsics.Vector64<int64> -> unit

参数

address

Int64*

source

Vector64<Int64>

Store(Int32*, Vector64<Int32>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1_s32 （int32_t * ptr， int32x2_t val）

A32：VST1.32 { Dd }， [Rn]

A64：ST1 { Vt.2S }， [Xn]

public:
 static void Store(int* address, System::Runtime::Intrinsics::Vector64<int> source);

public static void Store (int* address, System.Runtime.Intrinsics.Vector64<int> source);

static member Store : nativeptr<int> * System.Runtime.Intrinsics.Vector64<int> -> unit

参数

address

Int32*

source

Vector64<Int32>

Store(Int32*, Vector128<Int32>)

Source:

AdvSimd.PlatformNotSupported.cs

void vst1q_s32 （int32_t * ptr， int32x4_t val）

A32：VST1.32 { Dd、Dd+1 }、[Rn]

A64：ST1 { Vt.4S }， [Xn]

public:
 static void Store(int* address, System::Runtime::Intrinsics::Vector128<int> source);

public static void Store (int* address, System.Runtime.Intrinsics.Vector128<int> source);

static member Store : nativeptr<int> * System.Runtime.Intrinsics.Vector128<int> -> unit

参数

address

Int32*

source

Vector128<Int32>