Sve.StoreAndZip Method

Reference

Definition

Namespace:: System.Runtime.Intrinsics.Arm

Assembly:: System.Runtime.Intrinsics.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Overloads

StoreAndZip(Vector<UInt64>, UInt64*, ValueTuple<Vector<UInt64>,Vector<UInt64>>)	void svst2[_u64](svbool_t pg, uint64_t *base, svuint64x2_t data) ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<SByte>, SByte*, ValueTuple<Vector<SByte>,Vector<SByte>>)	void svst2[_s8](svbool_t pg, int8_t *base, svint8x2_t data) ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Single>, Single*, Vector<Single>)	void svst1[_f32](svbool_t pg, float32_t *base, svfloat32_t data) ST1W Zdata.S, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Single>, Single*, ValueTuple<Vector<Single>,Vector<Single>,Vector<Single>,Vector<Single>>)	void svst4[_f32](svbool_t pg, float32_t *base, svfloat32x4_t data) ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Single>, Single*, ValueTuple<Vector<Single>,Vector<Single>,Vector<Single>>)	void svst3[_f32](svbool_t pg, float32_t *base, svfloat32x3_t data) ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Single>, Single*, ValueTuple<Vector<Single>,Vector<Single>>)	void svst2[_f32](svbool_t pg, float32_t *base, svfloat32x2_t data) ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt16>, UInt16*, Vector<UInt16>)	void svst1[_u16](svbool_t pg, uint16_t *base, svuint16_t data) ST1H Zdata.H, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt16>, UInt16*, ValueTuple<Vector<UInt16>,Vector<UInt16>,Vector<UInt16>,Vector<UInt16>>)	void svst4[_u16](svbool_t pg, uint16_t *base, svuint16x4_t data) ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt32>, UInt32*, ValueTuple<Vector<UInt32>,Vector<UInt32>,Vector<UInt32>,Vector<UInt32>>)	void svst4[_u32](svbool_t pg, uint32_t *base, svuint32x4_t data) ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt16>, UInt16*, ValueTuple<Vector<UInt16>,Vector<UInt16>>)	void svst2[_u16](svbool_t pg, uint16_t *base, svuint16x2_t data) ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt32>, UInt32*, Vector<UInt32>)	void svst1[_u32](svbool_t pg, uint32_t *base, svuint32_t data) ST1W Zdata.S, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt32>, UInt32*, ValueTuple<Vector<UInt32>,Vector<UInt32>,Vector<UInt32>>)	void svst3[_u32](svbool_t pg, uint32_t *base, svuint32x3_t data) ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt32>, UInt32*, ValueTuple<Vector<UInt32>,Vector<UInt32>>)	void svst2[_u32](svbool_t pg, uint32_t *base, svuint32x2_t data) ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt64>, UInt64*, Vector<UInt64>)	void svst1[_u64](svbool_t pg, uint64_t *base, svuint64_t data) ST1D Zdata.D, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt64>, UInt64*, ValueTuple<Vector<UInt64>,Vector<UInt64>,Vector<UInt64>,Vector<UInt64>>)	void svst4[_u64](svbool_t pg, uint64_t *base, svuint64x4_t data) ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt64>, UInt64*, ValueTuple<Vector<UInt64>,Vector<UInt64>,Vector<UInt64>>)	void svst3[_u64](svbool_t pg, uint64_t *base, svuint64x3_t data) ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<SByte>, SByte*, ValueTuple<Vector<SByte>,Vector<SByte>,Vector<SByte>,Vector<SByte>>)	void svst4[_s8](svbool_t pg, int8_t *base, svint8x4_t data) ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<UInt16>, UInt16*, ValueTuple<Vector<UInt16>,Vector<UInt16>,Vector<UInt16>>)	void svst3[_u16](svbool_t pg, uint16_t *base, svuint16x3_t data) ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<SByte>, SByte*, Vector<SByte>)	void svst1[_s8](svbool_t pg, int8_t *base, svint8_t data) ST1B Zdata.B, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<SByte>, SByte*, ValueTuple<Vector<SByte>,Vector<SByte>,Vector<SByte>>)	void svst3[_s8](svbool_t pg, int8_t *base, svint8x3_t data) ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int64>, Int64*, ValueTuple<Vector<Int64>,Vector<Int64>,Vector<Int64>>)	void svst3[_s64](svbool_t pg, int64_t *base, svint64x3_t data) ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int64>, Int64*, ValueTuple<Vector<Int64>,Vector<Int64>>)	void svst2[_s64](svbool_t pg, int64_t *base, svint64x2_t data) ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Byte>, Byte*, Vector<Byte>)	void svst1[_u8](svbool_t pg, uint8_t *base, svuint8_t data) ST1B Zdata.B, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Byte>, Byte*, ValueTuple<Vector<Byte>,Vector<Byte>,Vector<Byte>,Vector<Byte>>)	void svst4[_u8](svbool_t pg, uint8_t *base, svuint8x4_t data) ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Byte>, Byte*, ValueTuple<Vector<Byte>,Vector<Byte>,Vector<Byte>>)	void svst3[_u8](svbool_t pg, uint8_t *base, svuint8x3_t data) ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Byte>, Byte*, ValueTuple<Vector<Byte>,Vector<Byte>>)	void svst2[_u8](svbool_t pg, uint8_t *base, svuint8x2_t data) ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Double>, Double*, Vector<Double>)	void svst1[_f64](svbool_t pg, float64_t *base, svfloat64_t data) ST1D Zdata.D, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Double>, Double*, ValueTuple<Vector<Double>,Vector<Double>,Vector<Double>,Vector<Double>>)	void svst4[_f64](svbool_t pg, float64_t *base, svfloat64x4_t data) ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Double>, Double*, ValueTuple<Vector<Double>,Vector<Double>>)	void svst2[_f64](svbool_t pg, float64_t *base, svfloat64x2_t data) ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int16>, Int16*, Vector<Int16>)	void svst1[_s16](svbool_t pg, int16_t *base, svint16_t data) ST1H Zdata.H, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Double>, Double*, ValueTuple<Vector<Double>,Vector<Double>,Vector<Double>>)	void svst3[_f64](svbool_t pg, float64_t *base, svfloat64x3_t data) ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int16>, Int16*, ValueTuple<Vector<Int16>,Vector<Int16>,Vector<Int16>>)	void svst3[_s16](svbool_t pg, int16_t *base, svint16x3_t data) ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int16>, Int16*, ValueTuple<Vector<Int16>,Vector<Int16>>)	void svst2[_s16](svbool_t pg, int16_t *base, svint16x2_t data) ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int32>, Int32*, Vector<Int32>)	void svst1[_s32](svbool_t pg, int32_t *base, svint32_t data) ST1W Zdata.S, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int32>, Int32*, ValueTuple<Vector<Int32>,Vector<Int32>,Vector<Int32>,Vector<Int32>>)	void svst4[_s32](svbool_t pg, int32_t *base, svint32x4_t data) ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int32>, Int32*, ValueTuple<Vector<Int32>,Vector<Int32>,Vector<Int32>>)	void svst3[_s32](svbool_t pg, int32_t *base, svint32x3_t data) ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int32>, Int32*, ValueTuple<Vector<Int32>,Vector<Int32>>)	void svst2[_s32](svbool_t pg, int32_t *base, svint32x2_t data) ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int64>, Int64*, Vector<Int64>)	void svst1[_s64](svbool_t pg, int64_t *base, svint64_t data) ST1D Zdata.D, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int64>, Int64*, ValueTuple<Vector<Int64>,Vector<Int64>,Vector<Int64>,Vector<Int64>>)	void svst4[_s64](svbool_t pg, int64_t *base, svint64x4_t data) ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL]
StoreAndZip(Vector<Int16>, Int16*, ValueTuple<Vector<Int16>,Vector<Int16>,Vector<Int16>,Vector<Int16>>)	void svst4[_s16](svbool_t pg, int16_t *base, svint16x4_t data) ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL]

StoreAndZip(Vector<UInt64>, UInt64*, ValueTuple<Vector<UInt64>,Vector<UInt64>>)

void svst2[_u64](svbool_t pg, uint64_t *base, svuint64x2_t data)

ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt64> mask, System::UInt64* address, ValueTuple<System::Numerics::Vector<System::UInt64>, System::Numerics::Vector<System::UInt64>> data);

public static void StoreAndZip (System.Numerics.Vector<ulong> mask, ulong* address, (System.Numerics.Vector<ulong> Value1, System.Numerics.Vector<ulong> Value2) data);

static member StoreAndZip : System.Numerics.Vector<uint64> * nativeptr<uint64> * ValueTuple<System.Numerics.Vector<uint64>, System.Numerics.Vector<uint64>> -> unit

Parameters

mask: Vector<UInt64>

address: UInt64*

data: ValueTuple<Vector<UInt64>,Vector<UInt64>>

Applies to

StoreAndZip(Vector<SByte>, SByte*, ValueTuple<Vector<SByte>,Vector<SByte>>)

void svst2[_s8](svbool_t pg, int8_t *base, svint8x2_t data)

ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::SByte> mask, System::SByte* address, ValueTuple<System::Numerics::Vector<System::SByte>, System::Numerics::Vector<System::SByte>> data);

public static void StoreAndZip (System.Numerics.Vector<sbyte> mask, sbyte* address, (System.Numerics.Vector<sbyte> Value1, System.Numerics.Vector<sbyte> Value2) data);

static member StoreAndZip : System.Numerics.Vector<sbyte> * nativeptr<sbyte> * ValueTuple<System.Numerics.Vector<sbyte>, System.Numerics.Vector<sbyte>> -> unit

Parameters

mask: Vector<SByte>

address: SByte*

data: ValueTuple<Vector<SByte>,Vector<SByte>>

Applies to

StoreAndZip(Vector<Single>, Single*, Vector<Single>)

void svst1[_f32](svbool_t pg, float32_t *base, svfloat32_t data)

ST1W Zdata.S, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<float> mask, float* address, System::Numerics::Vector<float> data);

public static void StoreAndZip (System.Numerics.Vector<float> mask, float* address, System.Numerics.Vector<float> data);

static member StoreAndZip : System.Numerics.Vector<single> * nativeptr<single> * System.Numerics.Vector<single> -> unit

Parameters

mask: Vector<Single>

address: Single*

data: Vector<Single>

Applies to

StoreAndZip(Vector<Single>, Single*, ValueTuple<Vector<Single>,Vector<Single>,Vector<Single>,Vector<Single>>)

void svst4[_f32](svbool_t pg, float32_t *base, svfloat32x4_t data)

ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<float> mask, float* address, ValueTuple<System::Numerics::Vector<float>, System::Numerics::Vector<float>, System::Numerics::Vector<float>, System::Numerics::Vector<float>> data);

public static void StoreAndZip (System.Numerics.Vector<float> mask, float* address, (System.Numerics.Vector<float> Value1, System.Numerics.Vector<float> Value2, System.Numerics.Vector<float> Value3, System.Numerics.Vector<float> Value4) data);

static member StoreAndZip : System.Numerics.Vector<single> * nativeptr<single> * ValueTuple<System.Numerics.Vector<single>, System.Numerics.Vector<single>, System.Numerics.Vector<single>, System.Numerics.Vector<single>> -> unit

Parameters

mask: Vector<Single>

address: Single*

data: ValueTuple<Vector<Single>,Vector<Single>,Vector<Single>,Vector<Single>>

Applies to

StoreAndZip(Vector<Single>, Single*, ValueTuple<Vector<Single>,Vector<Single>,Vector<Single>>)

void svst3[_f32](svbool_t pg, float32_t *base, svfloat32x3_t data)

ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<float> mask, float* address, ValueTuple<System::Numerics::Vector<float>, System::Numerics::Vector<float>, System::Numerics::Vector<float>> data);

public static void StoreAndZip (System.Numerics.Vector<float> mask, float* address, (System.Numerics.Vector<float> Value1, System.Numerics.Vector<float> Value2, System.Numerics.Vector<float> Value3) data);

static member StoreAndZip : System.Numerics.Vector<single> * nativeptr<single> * ValueTuple<System.Numerics.Vector<single>, System.Numerics.Vector<single>, System.Numerics.Vector<single>> -> unit

Parameters

mask: Vector<Single>

address: Single*

data: ValueTuple<Vector<Single>,Vector<Single>,Vector<Single>>

Applies to

StoreAndZip(Vector<Single>, Single*, ValueTuple<Vector<Single>,Vector<Single>>)

void svst2[_f32](svbool_t pg, float32_t *base, svfloat32x2_t data)

ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<float> mask, float* address, ValueTuple<System::Numerics::Vector<float>, System::Numerics::Vector<float>> data);

public static void StoreAndZip (System.Numerics.Vector<float> mask, float* address, (System.Numerics.Vector<float> Value1, System.Numerics.Vector<float> Value2) data);

static member StoreAndZip : System.Numerics.Vector<single> * nativeptr<single> * ValueTuple<System.Numerics.Vector<single>, System.Numerics.Vector<single>> -> unit

Parameters

mask: Vector<Single>

address: Single*

data: ValueTuple<Vector<Single>,Vector<Single>>

Applies to

StoreAndZip(Vector<UInt16>, UInt16*, Vector<UInt16>)

void svst1[_u16](svbool_t pg, uint16_t *base, svuint16_t data)

ST1H Zdata.H, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt16> mask, System::UInt16* address, System::Numerics::Vector<System::UInt16> data);

public static void StoreAndZip (System.Numerics.Vector<ushort> mask, ushort* address, System.Numerics.Vector<ushort> data);

static member StoreAndZip : System.Numerics.Vector<uint16> * nativeptr<uint16> * System.Numerics.Vector<uint16> -> unit

Parameters

mask: Vector<UInt16>

address: UInt16*

data: Vector<UInt16>

Applies to

StoreAndZip(Vector<UInt16>, UInt16*, ValueTuple<Vector<UInt16>,Vector<UInt16>,Vector<UInt16>,Vector<UInt16>>)

void svst4[_u16](svbool_t pg, uint16_t *base, svuint16x4_t data)

ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt16> mask, System::UInt16* address, ValueTuple<System::Numerics::Vector<System::UInt16>, System::Numerics::Vector<System::UInt16>, System::Numerics::Vector<System::UInt16>, System::Numerics::Vector<System::UInt16>> data);

public static void StoreAndZip (System.Numerics.Vector<ushort> mask, ushort* address, (System.Numerics.Vector<ushort> Value1, System.Numerics.Vector<ushort> Value2, System.Numerics.Vector<ushort> Value3, System.Numerics.Vector<ushort> Value4) data);

static member StoreAndZip : System.Numerics.Vector<uint16> * nativeptr<uint16> * ValueTuple<System.Numerics.Vector<uint16>, System.Numerics.Vector<uint16>, System.Numerics.Vector<uint16>, System.Numerics.Vector<uint16>> -> unit

Parameters

mask: Vector<UInt16>

address: UInt16*

data: ValueTuple<Vector<UInt16>,Vector<UInt16>,Vector<UInt16>,Vector<UInt16>>

Applies to

StoreAndZip(Vector<UInt32>, UInt32*, ValueTuple<Vector<UInt32>,Vector<UInt32>,Vector<UInt32>,Vector<UInt32>>)

void svst4[_u32](svbool_t pg, uint32_t *base, svuint32x4_t data)

ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt32> mask, System::UInt32* address, ValueTuple<System::Numerics::Vector<System::UInt32>, System::Numerics::Vector<System::UInt32>, System::Numerics::Vector<System::UInt32>, System::Numerics::Vector<System::UInt32>> data);

public static void StoreAndZip (System.Numerics.Vector<uint> mask, uint* address, (System.Numerics.Vector<uint> Value1, System.Numerics.Vector<uint> Value2, System.Numerics.Vector<uint> Value3, System.Numerics.Vector<uint> Value4) data);

static member StoreAndZip : System.Numerics.Vector<uint32> * nativeptr<uint32> * ValueTuple<System.Numerics.Vector<uint32>, System.Numerics.Vector<uint32>, System.Numerics.Vector<uint32>, System.Numerics.Vector<uint32>> -> unit

Parameters

mask: Vector<UInt32>

address: UInt32*

data: ValueTuple<Vector<UInt32>,Vector<UInt32>,Vector<UInt32>,Vector<UInt32>>

Applies to

StoreAndZip(Vector<UInt16>, UInt16*, ValueTuple<Vector<UInt16>,Vector<UInt16>>)

void svst2[_u16](svbool_t pg, uint16_t *base, svuint16x2_t data)

ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt16> mask, System::UInt16* address, ValueTuple<System::Numerics::Vector<System::UInt16>, System::Numerics::Vector<System::UInt16>> data);

public static void StoreAndZip (System.Numerics.Vector<ushort> mask, ushort* address, (System.Numerics.Vector<ushort> Value1, System.Numerics.Vector<ushort> Value2) data);

static member StoreAndZip : System.Numerics.Vector<uint16> * nativeptr<uint16> * ValueTuple<System.Numerics.Vector<uint16>, System.Numerics.Vector<uint16>> -> unit

Parameters

mask: Vector<UInt16>

address: UInt16*

data: ValueTuple<Vector<UInt16>,Vector<UInt16>>

Applies to

StoreAndZip(Vector<UInt32>, UInt32*, Vector<UInt32>)

void svst1[_u32](svbool_t pg, uint32_t *base, svuint32_t data)

ST1W Zdata.S, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt32> mask, System::UInt32* address, System::Numerics::Vector<System::UInt32> data);

public static void StoreAndZip (System.Numerics.Vector<uint> mask, uint* address, System.Numerics.Vector<uint> data);

static member StoreAndZip : System.Numerics.Vector<uint32> * nativeptr<uint32> * System.Numerics.Vector<uint32> -> unit

Parameters

mask: Vector<UInt32>

address: UInt32*

data: Vector<UInt32>

Applies to

StoreAndZip(Vector<UInt32>, UInt32*, ValueTuple<Vector<UInt32>,Vector<UInt32>,Vector<UInt32>>)

void svst3[_u32](svbool_t pg, uint32_t *base, svuint32x3_t data)

ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt32> mask, System::UInt32* address, ValueTuple<System::Numerics::Vector<System::UInt32>, System::Numerics::Vector<System::UInt32>, System::Numerics::Vector<System::UInt32>> data);

public static void StoreAndZip (System.Numerics.Vector<uint> mask, uint* address, (System.Numerics.Vector<uint> Value1, System.Numerics.Vector<uint> Value2, System.Numerics.Vector<uint> Value3) data);

static member StoreAndZip : System.Numerics.Vector<uint32> * nativeptr<uint32> * ValueTuple<System.Numerics.Vector<uint32>, System.Numerics.Vector<uint32>, System.Numerics.Vector<uint32>> -> unit

Parameters

mask: Vector<UInt32>

address: UInt32*

data: ValueTuple<Vector<UInt32>,Vector<UInt32>,Vector<UInt32>>

Applies to

StoreAndZip(Vector<UInt32>, UInt32*, ValueTuple<Vector<UInt32>,Vector<UInt32>>)

void svst2[_u32](svbool_t pg, uint32_t *base, svuint32x2_t data)

ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt32> mask, System::UInt32* address, ValueTuple<System::Numerics::Vector<System::UInt32>, System::Numerics::Vector<System::UInt32>> data);

public static void StoreAndZip (System.Numerics.Vector<uint> mask, uint* address, (System.Numerics.Vector<uint> Value1, System.Numerics.Vector<uint> Value2) data);

static member StoreAndZip : System.Numerics.Vector<uint32> * nativeptr<uint32> * ValueTuple<System.Numerics.Vector<uint32>, System.Numerics.Vector<uint32>> -> unit

Parameters

mask: Vector<UInt32>

address: UInt32*

data: ValueTuple<Vector<UInt32>,Vector<UInt32>>

Applies to

StoreAndZip(Vector<UInt64>, UInt64*, Vector<UInt64>)

void svst1[_u64](svbool_t pg, uint64_t *base, svuint64_t data)

ST1D Zdata.D, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt64> mask, System::UInt64* address, System::Numerics::Vector<System::UInt64> data);

public static void StoreAndZip (System.Numerics.Vector<ulong> mask, ulong* address, System.Numerics.Vector<ulong> data);

static member StoreAndZip : System.Numerics.Vector<uint64> * nativeptr<uint64> * System.Numerics.Vector<uint64> -> unit

Parameters

mask: Vector<UInt64>

address: UInt64*

data: Vector<UInt64>

Applies to

StoreAndZip(Vector<UInt64>, UInt64*, ValueTuple<Vector<UInt64>,Vector<UInt64>,Vector<UInt64>,Vector<UInt64>>)

void svst4[_u64](svbool_t pg, uint64_t *base, svuint64x4_t data)

ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt64> mask, System::UInt64* address, ValueTuple<System::Numerics::Vector<System::UInt64>, System::Numerics::Vector<System::UInt64>, System::Numerics::Vector<System::UInt64>, System::Numerics::Vector<System::UInt64>> data);

public static void StoreAndZip (System.Numerics.Vector<ulong> mask, ulong* address, (System.Numerics.Vector<ulong> Value1, System.Numerics.Vector<ulong> Value2, System.Numerics.Vector<ulong> Value3, System.Numerics.Vector<ulong> Value4) data);

static member StoreAndZip : System.Numerics.Vector<uint64> * nativeptr<uint64> * ValueTuple<System.Numerics.Vector<uint64>, System.Numerics.Vector<uint64>, System.Numerics.Vector<uint64>, System.Numerics.Vector<uint64>> -> unit

Parameters

mask: Vector<UInt64>

address: UInt64*

data: ValueTuple<Vector<UInt64>,Vector<UInt64>,Vector<UInt64>,Vector<UInt64>>

Applies to

StoreAndZip(Vector<UInt64>, UInt64*, ValueTuple<Vector<UInt64>,Vector<UInt64>,Vector<UInt64>>)

void svst3[_u64](svbool_t pg, uint64_t *base, svuint64x3_t data)

ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt64> mask, System::UInt64* address, ValueTuple<System::Numerics::Vector<System::UInt64>, System::Numerics::Vector<System::UInt64>, System::Numerics::Vector<System::UInt64>> data);

public static void StoreAndZip (System.Numerics.Vector<ulong> mask, ulong* address, (System.Numerics.Vector<ulong> Value1, System.Numerics.Vector<ulong> Value2, System.Numerics.Vector<ulong> Value3) data);

static member StoreAndZip : System.Numerics.Vector<uint64> * nativeptr<uint64> * ValueTuple<System.Numerics.Vector<uint64>, System.Numerics.Vector<uint64>, System.Numerics.Vector<uint64>> -> unit

Parameters

mask: Vector<UInt64>

address: UInt64*

data: ValueTuple<Vector<UInt64>,Vector<UInt64>,Vector<UInt64>>

Applies to

StoreAndZip(Vector<SByte>, SByte*, ValueTuple<Vector<SByte>,Vector<SByte>,Vector<SByte>,Vector<SByte>>)

void svst4[_s8](svbool_t pg, int8_t *base, svint8x4_t data)

ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::SByte> mask, System::SByte* address, ValueTuple<System::Numerics::Vector<System::SByte>, System::Numerics::Vector<System::SByte>, System::Numerics::Vector<System::SByte>, System::Numerics::Vector<System::SByte>> data);

public static void StoreAndZip (System.Numerics.Vector<sbyte> mask, sbyte* address, (System.Numerics.Vector<sbyte> Value1, System.Numerics.Vector<sbyte> Value2, System.Numerics.Vector<sbyte> Value3, System.Numerics.Vector<sbyte> Value4) data);

static member StoreAndZip : System.Numerics.Vector<sbyte> * nativeptr<sbyte> * ValueTuple<System.Numerics.Vector<sbyte>, System.Numerics.Vector<sbyte>, System.Numerics.Vector<sbyte>, System.Numerics.Vector<sbyte>> -> unit

Parameters

mask: Vector<SByte>

address: SByte*

data: ValueTuple<Vector<SByte>,Vector<SByte>,Vector<SByte>,Vector<SByte>>

Applies to

StoreAndZip(Vector<UInt16>, UInt16*, ValueTuple<Vector<UInt16>,Vector<UInt16>,Vector<UInt16>>)

void svst3[_u16](svbool_t pg, uint16_t *base, svuint16x3_t data)

ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::UInt16> mask, System::UInt16* address, ValueTuple<System::Numerics::Vector<System::UInt16>, System::Numerics::Vector<System::UInt16>, System::Numerics::Vector<System::UInt16>> data);

public static void StoreAndZip (System.Numerics.Vector<ushort> mask, ushort* address, (System.Numerics.Vector<ushort> Value1, System.Numerics.Vector<ushort> Value2, System.Numerics.Vector<ushort> Value3) data);

static member StoreAndZip : System.Numerics.Vector<uint16> * nativeptr<uint16> * ValueTuple<System.Numerics.Vector<uint16>, System.Numerics.Vector<uint16>, System.Numerics.Vector<uint16>> -> unit

Parameters

mask: Vector<UInt16>

address: UInt16*

data: ValueTuple<Vector<UInt16>,Vector<UInt16>,Vector<UInt16>>

Applies to

StoreAndZip(Vector<SByte>, SByte*, Vector<SByte>)

void svst1[_s8](svbool_t pg, int8_t *base, svint8_t data)

ST1B Zdata.B, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::SByte> mask, System::SByte* address, System::Numerics::Vector<System::SByte> data);

public static void StoreAndZip (System.Numerics.Vector<sbyte> mask, sbyte* address, System.Numerics.Vector<sbyte> data);

static member StoreAndZip : System.Numerics.Vector<sbyte> * nativeptr<sbyte> * System.Numerics.Vector<sbyte> -> unit

Parameters

mask: Vector<SByte>

address: SByte*

data: Vector<SByte>

Applies to

StoreAndZip(Vector<SByte>, SByte*, ValueTuple<Vector<SByte>,Vector<SByte>,Vector<SByte>>)

void svst3[_s8](svbool_t pg, int8_t *base, svint8x3_t data)

ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::SByte> mask, System::SByte* address, ValueTuple<System::Numerics::Vector<System::SByte>, System::Numerics::Vector<System::SByte>, System::Numerics::Vector<System::SByte>> data);

public static void StoreAndZip (System.Numerics.Vector<sbyte> mask, sbyte* address, (System.Numerics.Vector<sbyte> Value1, System.Numerics.Vector<sbyte> Value2, System.Numerics.Vector<sbyte> Value3) data);

static member StoreAndZip : System.Numerics.Vector<sbyte> * nativeptr<sbyte> * ValueTuple<System.Numerics.Vector<sbyte>, System.Numerics.Vector<sbyte>, System.Numerics.Vector<sbyte>> -> unit

Parameters

mask: Vector<SByte>

address: SByte*

data: ValueTuple<Vector<SByte>,Vector<SByte>,Vector<SByte>>

Applies to

StoreAndZip(Vector<Int64>, Int64*, ValueTuple<Vector<Int64>,Vector<Int64>,Vector<Int64>>)

void svst3[_s64](svbool_t pg, int64_t *base, svint64x3_t data)

ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<long> mask, long* address, ValueTuple<System::Numerics::Vector<long>, System::Numerics::Vector<long>, System::Numerics::Vector<long>> data);

public static void StoreAndZip (System.Numerics.Vector<long> mask, long* address, (System.Numerics.Vector<long> Value1, System.Numerics.Vector<long> Value2, System.Numerics.Vector<long> Value3) data);

static member StoreAndZip : System.Numerics.Vector<int64> * nativeptr<int64> * ValueTuple<System.Numerics.Vector<int64>, System.Numerics.Vector<int64>, System.Numerics.Vector<int64>> -> unit

Parameters

mask: Vector<Int64>

address: Int64*

data: ValueTuple<Vector<Int64>,Vector<Int64>,Vector<Int64>>

Applies to

StoreAndZip(Vector<Int64>, Int64*, ValueTuple<Vector<Int64>,Vector<Int64>>)

void svst2[_s64](svbool_t pg, int64_t *base, svint64x2_t data)

ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<long> mask, long* address, ValueTuple<System::Numerics::Vector<long>, System::Numerics::Vector<long>> data);

public static void StoreAndZip (System.Numerics.Vector<long> mask, long* address, (System.Numerics.Vector<long> Value1, System.Numerics.Vector<long> Value2) data);

static member StoreAndZip : System.Numerics.Vector<int64> * nativeptr<int64> * ValueTuple<System.Numerics.Vector<int64>, System.Numerics.Vector<int64>> -> unit

Parameters

mask: Vector<Int64>

address: Int64*

data: ValueTuple<Vector<Int64>,Vector<Int64>>

Applies to

StoreAndZip(Vector<Byte>, Byte*, Vector<Byte>)

void svst1[_u8](svbool_t pg, uint8_t *base, svuint8_t data)

ST1B Zdata.B, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::Byte> mask, System::Byte* address, System::Numerics::Vector<System::Byte> data);

public static void StoreAndZip (System.Numerics.Vector<byte> mask, byte* address, System.Numerics.Vector<byte> data);

static member StoreAndZip : System.Numerics.Vector<byte> * nativeptr<byte> * System.Numerics.Vector<byte> -> unit

Parameters

mask: Vector<Byte>

address: Byte*

data: Vector<Byte>

Applies to

StoreAndZip(Vector<Byte>, Byte*, ValueTuple<Vector<Byte>,Vector<Byte>,Vector<Byte>,Vector<Byte>>)

void svst4[_u8](svbool_t pg, uint8_t *base, svuint8x4_t data)

ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::Byte> mask, System::Byte* address, ValueTuple<System::Numerics::Vector<System::Byte>, System::Numerics::Vector<System::Byte>, System::Numerics::Vector<System::Byte>, System::Numerics::Vector<System::Byte>> data);

public static void StoreAndZip (System.Numerics.Vector<byte> mask, byte* address, (System.Numerics.Vector<byte> Value1, System.Numerics.Vector<byte> Value2, System.Numerics.Vector<byte> Value3, System.Numerics.Vector<byte> Value4) data);

static member StoreAndZip : System.Numerics.Vector<byte> * nativeptr<byte> * ValueTuple<System.Numerics.Vector<byte>, System.Numerics.Vector<byte>, System.Numerics.Vector<byte>, System.Numerics.Vector<byte>> -> unit

Parameters

mask: Vector<Byte>

address: Byte*

data: ValueTuple<Vector<Byte>,Vector<Byte>,Vector<Byte>,Vector<Byte>>

Applies to

StoreAndZip(Vector<Byte>, Byte*, ValueTuple<Vector<Byte>,Vector<Byte>,Vector<Byte>>)

void svst3[_u8](svbool_t pg, uint8_t *base, svuint8x3_t data)

ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::Byte> mask, System::Byte* address, ValueTuple<System::Numerics::Vector<System::Byte>, System::Numerics::Vector<System::Byte>, System::Numerics::Vector<System::Byte>> data);

public static void StoreAndZip (System.Numerics.Vector<byte> mask, byte* address, (System.Numerics.Vector<byte> Value1, System.Numerics.Vector<byte> Value2, System.Numerics.Vector<byte> Value3) data);

static member StoreAndZip : System.Numerics.Vector<byte> * nativeptr<byte> * ValueTuple<System.Numerics.Vector<byte>, System.Numerics.Vector<byte>, System.Numerics.Vector<byte>> -> unit

Parameters

mask: Vector<Byte>

address: Byte*

data: ValueTuple<Vector<Byte>,Vector<Byte>,Vector<Byte>>

Applies to

StoreAndZip(Vector<Byte>, Byte*, ValueTuple<Vector<Byte>,Vector<Byte>>)

void svst2[_u8](svbool_t pg, uint8_t *base, svuint8x2_t data)

ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<System::Byte> mask, System::Byte* address, ValueTuple<System::Numerics::Vector<System::Byte>, System::Numerics::Vector<System::Byte>> data);

public static void StoreAndZip (System.Numerics.Vector<byte> mask, byte* address, (System.Numerics.Vector<byte> Value1, System.Numerics.Vector<byte> Value2) data);

static member StoreAndZip : System.Numerics.Vector<byte> * nativeptr<byte> * ValueTuple<System.Numerics.Vector<byte>, System.Numerics.Vector<byte>> -> unit

Parameters

mask: Vector<Byte>

address: Byte*

data: ValueTuple<Vector<Byte>,Vector<Byte>>

Applies to

StoreAndZip(Vector<Double>, Double*, Vector<Double>)

void svst1[_f64](svbool_t pg, float64_t *base, svfloat64_t data)

ST1D Zdata.D, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<double> mask, double* address, System::Numerics::Vector<double> data);

public static void StoreAndZip (System.Numerics.Vector<double> mask, double* address, System.Numerics.Vector<double> data);

static member StoreAndZip : System.Numerics.Vector<double> * nativeptr<double> * System.Numerics.Vector<double> -> unit

Parameters

mask: Vector<Double>

address: Double*

data: Vector<Double>

Applies to

StoreAndZip(Vector<Double>, Double*, ValueTuple<Vector<Double>,Vector<Double>,Vector<Double>,Vector<Double>>)

void svst4[_f64](svbool_t pg, float64_t *base, svfloat64x4_t data)

ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<double> mask, double* address, ValueTuple<System::Numerics::Vector<double>, System::Numerics::Vector<double>, System::Numerics::Vector<double>, System::Numerics::Vector<double>> data);

public static void StoreAndZip (System.Numerics.Vector<double> mask, double* address, (System.Numerics.Vector<double> Value1, System.Numerics.Vector<double> Value2, System.Numerics.Vector<double> Value3, System.Numerics.Vector<double> Value4) data);

static member StoreAndZip : System.Numerics.Vector<double> * nativeptr<double> * ValueTuple<System.Numerics.Vector<double>, System.Numerics.Vector<double>, System.Numerics.Vector<double>, System.Numerics.Vector<double>> -> unit

Parameters

mask: Vector<Double>

address: Double*

data: ValueTuple<Vector<Double>,Vector<Double>,Vector<Double>,Vector<Double>>

Applies to

StoreAndZip(Vector<Double>, Double*, ValueTuple<Vector<Double>,Vector<Double>>)

void svst2[_f64](svbool_t pg, float64_t *base, svfloat64x2_t data)

ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<double> mask, double* address, ValueTuple<System::Numerics::Vector<double>, System::Numerics::Vector<double>> data);

public static void StoreAndZip (System.Numerics.Vector<double> mask, double* address, (System.Numerics.Vector<double> Value1, System.Numerics.Vector<double> Value2) data);

static member StoreAndZip : System.Numerics.Vector<double> * nativeptr<double> * ValueTuple<System.Numerics.Vector<double>, System.Numerics.Vector<double>> -> unit

Parameters

mask: Vector<Double>

address: Double*

data: ValueTuple<Vector<Double>,Vector<Double>>

Applies to

StoreAndZip(Vector<Int16>, Int16*, Vector<Int16>)

void svst1[_s16](svbool_t pg, int16_t *base, svint16_t data)

ST1H Zdata.H, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<short> mask, short* address, System::Numerics::Vector<short> data);

public static void StoreAndZip (System.Numerics.Vector<short> mask, short* address, System.Numerics.Vector<short> data);

static member StoreAndZip : System.Numerics.Vector<int16> * nativeptr<int16> * System.Numerics.Vector<int16> -> unit

Parameters

mask: Vector<Int16>

address: Int16*

data: Vector<Int16>

Applies to

StoreAndZip(Vector<Double>, Double*, ValueTuple<Vector<Double>,Vector<Double>,Vector<Double>>)

void svst3[_f64](svbool_t pg, float64_t *base, svfloat64x3_t data)

ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<double> mask, double* address, ValueTuple<System::Numerics::Vector<double>, System::Numerics::Vector<double>, System::Numerics::Vector<double>> data);

public static void StoreAndZip (System.Numerics.Vector<double> mask, double* address, (System.Numerics.Vector<double> Value1, System.Numerics.Vector<double> Value2, System.Numerics.Vector<double> Value3) data);

static member StoreAndZip : System.Numerics.Vector<double> * nativeptr<double> * ValueTuple<System.Numerics.Vector<double>, System.Numerics.Vector<double>, System.Numerics.Vector<double>> -> unit

Parameters

mask: Vector<Double>

address: Double*

data: ValueTuple<Vector<Double>,Vector<Double>,Vector<Double>>

Applies to

StoreAndZip(Vector<Int16>, Int16*, ValueTuple<Vector<Int16>,Vector<Int16>,Vector<Int16>>)

void svst3[_s16](svbool_t pg, int16_t *base, svint16x3_t data)

ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<short> mask, short* address, ValueTuple<System::Numerics::Vector<short>, System::Numerics::Vector<short>, System::Numerics::Vector<short>> data);

public static void StoreAndZip (System.Numerics.Vector<short> mask, short* address, (System.Numerics.Vector<short> Value1, System.Numerics.Vector<short> Value2, System.Numerics.Vector<short> Value3) data);

static member StoreAndZip : System.Numerics.Vector<int16> * nativeptr<int16> * ValueTuple<System.Numerics.Vector<int16>, System.Numerics.Vector<int16>, System.Numerics.Vector<int16>> -> unit

Parameters

mask: Vector<Int16>

address: Int16*

data: ValueTuple<Vector<Int16>,Vector<Int16>,Vector<Int16>>

Applies to

StoreAndZip(Vector<Int16>, Int16*, ValueTuple<Vector<Int16>,Vector<Int16>>)

void svst2[_s16](svbool_t pg, int16_t *base, svint16x2_t data)

ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<short> mask, short* address, ValueTuple<System::Numerics::Vector<short>, System::Numerics::Vector<short>> data);

public static void StoreAndZip (System.Numerics.Vector<short> mask, short* address, (System.Numerics.Vector<short> Value1, System.Numerics.Vector<short> Value2) data);

static member StoreAndZip : System.Numerics.Vector<int16> * nativeptr<int16> * ValueTuple<System.Numerics.Vector<int16>, System.Numerics.Vector<int16>> -> unit

Parameters

mask: Vector<Int16>

address: Int16*

data: ValueTuple<Vector<Int16>,Vector<Int16>>

Applies to

StoreAndZip(Vector<Int32>, Int32*, Vector<Int32>)

void svst1[_s32](svbool_t pg, int32_t *base, svint32_t data)

ST1W Zdata.S, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<int> mask, int* address, System::Numerics::Vector<int> data);

public static void StoreAndZip (System.Numerics.Vector<int> mask, int* address, System.Numerics.Vector<int> data);

static member StoreAndZip : System.Numerics.Vector<int> * nativeptr<int> * System.Numerics.Vector<int> -> unit

Parameters

mask: Vector<Int32>

address: Int32*

data: Vector<Int32>

Applies to

StoreAndZip(Vector<Int32>, Int32*, ValueTuple<Vector<Int32>,Vector<Int32>,Vector<Int32>,Vector<Int32>>)

void svst4[_s32](svbool_t pg, int32_t *base, svint32x4_t data)

ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<int> mask, int* address, ValueTuple<System::Numerics::Vector<int>, System::Numerics::Vector<int>, System::Numerics::Vector<int>, System::Numerics::Vector<int>> data);

public static void StoreAndZip (System.Numerics.Vector<int> mask, int* address, (System.Numerics.Vector<int> Value1, System.Numerics.Vector<int> Value2, System.Numerics.Vector<int> Value3, System.Numerics.Vector<int> Value4) data);

static member StoreAndZip : System.Numerics.Vector<int> * nativeptr<int> * ValueTuple<System.Numerics.Vector<int>, System.Numerics.Vector<int>, System.Numerics.Vector<int>, System.Numerics.Vector<int>> -> unit

Parameters

mask: Vector<Int32>

address: Int32*

data: ValueTuple<Vector<Int32>,Vector<Int32>,Vector<Int32>,Vector<Int32>>

Applies to

StoreAndZip(Vector<Int32>, Int32*, ValueTuple<Vector<Int32>,Vector<Int32>,Vector<Int32>>)

void svst3[_s32](svbool_t pg, int32_t *base, svint32x3_t data)

ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<int> mask, int* address, ValueTuple<System::Numerics::Vector<int>, System::Numerics::Vector<int>, System::Numerics::Vector<int>> data);

public static void StoreAndZip (System.Numerics.Vector<int> mask, int* address, (System.Numerics.Vector<int> Value1, System.Numerics.Vector<int> Value2, System.Numerics.Vector<int> Value3) data);

static member StoreAndZip : System.Numerics.Vector<int> * nativeptr<int> * ValueTuple<System.Numerics.Vector<int>, System.Numerics.Vector<int>, System.Numerics.Vector<int>> -> unit

Parameters

mask: Vector<Int32>

address: Int32*

data: ValueTuple<Vector<Int32>,Vector<Int32>,Vector<Int32>>

Applies to

StoreAndZip(Vector<Int32>, Int32*, ValueTuple<Vector<Int32>,Vector<Int32>>)

void svst2[_s32](svbool_t pg, int32_t *base, svint32x2_t data)

ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<int> mask, int* address, ValueTuple<System::Numerics::Vector<int>, System::Numerics::Vector<int>> data);

public static void StoreAndZip (System.Numerics.Vector<int> mask, int* address, (System.Numerics.Vector<int> Value1, System.Numerics.Vector<int> Value2) data);

static member StoreAndZip : System.Numerics.Vector<int> * nativeptr<int> * ValueTuple<System.Numerics.Vector<int>, System.Numerics.Vector<int>> -> unit

Parameters

mask: Vector<Int32>

address: Int32*

data: ValueTuple<Vector<Int32>,Vector<Int32>>

Applies to

StoreAndZip(Vector<Int64>, Int64*, Vector<Int64>)

void svst1[_s64](svbool_t pg, int64_t *base, svint64_t data)

ST1D Zdata.D, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<long> mask, long* address, System::Numerics::Vector<long> data);

public static void StoreAndZip (System.Numerics.Vector<long> mask, long* address, System.Numerics.Vector<long> data);

static member StoreAndZip : System.Numerics.Vector<int64> * nativeptr<int64> * System.Numerics.Vector<int64> -> unit

Parameters

mask: Vector<Int64>

address: Int64*

data: Vector<Int64>

Applies to

StoreAndZip(Vector<Int64>, Int64*, ValueTuple<Vector<Int64>,Vector<Int64>,Vector<Int64>,Vector<Int64>>)

void svst4[_s64](svbool_t pg, int64_t *base, svint64x4_t data)

ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<long> mask, long* address, ValueTuple<System::Numerics::Vector<long>, System::Numerics::Vector<long>, System::Numerics::Vector<long>, System::Numerics::Vector<long>> data);

public static void StoreAndZip (System.Numerics.Vector<long> mask, long* address, (System.Numerics.Vector<long> Value1, System.Numerics.Vector<long> Value2, System.Numerics.Vector<long> Value3, System.Numerics.Vector<long> Value4) data);

static member StoreAndZip : System.Numerics.Vector<int64> * nativeptr<int64> * ValueTuple<System.Numerics.Vector<int64>, System.Numerics.Vector<int64>, System.Numerics.Vector<int64>, System.Numerics.Vector<int64>> -> unit

Parameters

mask: Vector<Int64>

address: Int64*

data: ValueTuple<Vector<Int64>,Vector<Int64>,Vector<Int64>,Vector<Int64>>

Applies to

StoreAndZip(Vector<Int16>, Int16*, ValueTuple<Vector<Int16>,Vector<Int16>,Vector<Int16>,Vector<Int16>>)

void svst4[_s16](svbool_t pg, int16_t *base, svint16x4_t data)

ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL]

public:
 static void StoreAndZip(System::Numerics::Vector<short> mask, short* address, ValueTuple<System::Numerics::Vector<short>, System::Numerics::Vector<short>, System::Numerics::Vector<short>, System::Numerics::Vector<short>> data);

public static void StoreAndZip (System.Numerics.Vector<short> mask, short* address, (System.Numerics.Vector<short> Value1, System.Numerics.Vector<short> Value2, System.Numerics.Vector<short> Value3, System.Numerics.Vector<short> Value4) data);

static member StoreAndZip : System.Numerics.Vector<int16> * nativeptr<int16> * ValueTuple<System.Numerics.Vector<int16>, System.Numerics.Vector<int16>, System.Numerics.Vector<int16>, System.Numerics.Vector<int16>> -> unit

Parameters

mask: Vector<Int16>

address: Int16*

data: ValueTuple<Vector<Int16>,Vector<Int16>,Vector<Int16>,Vector<Int16>>

Applies to

Share via

Sve.StoreAndZip Method

Definition

Overloads

StoreAndZip(Vector<UInt64>, UInt64*, ValueTuple<Vector<UInt64>,Vector<UInt64>>)

Parameters

Applies to

StoreAndZip(Vector<SByte>, SByte*, ValueTuple<Vector<SByte>,Vector<SByte>>)

Parameters

Applies to

StoreAndZip(Vector<Single>, Single*, Vector<Single>)

Parameters

Applies to

StoreAndZip(Vector<Single>, Single*, ValueTuple<Vector<Single>,Vector<Single>,Vector<Single>,Vector<Single>>)

Parameters

Applies to

StoreAndZip(Vector<Single>, Single*, ValueTuple<Vector<Single>,Vector<Single>,Vector<Single>>)

Parameters

Applies to

StoreAndZip(Vector<Single>, Single*, ValueTuple<Vector<Single>,Vector<Single>>)

Parameters

Applies to

StoreAndZip(Vector<UInt16>, UInt16*, Vector<UInt16>)

Parameters

Applies to

StoreAndZip(Vector<UInt16>, UInt16*, ValueTuple<Vector<UInt16>,Vector<UInt16>,Vector<UInt16>,Vector<UInt16>>)

Parameters

Applies to

StoreAndZip(Vector<UInt32>, UInt32*, ValueTuple<Vector<UInt32>,Vector<UInt32>,Vector<UInt32>,Vector<UInt32>>)

Parameters

Applies to

StoreAndZip(Vector<UInt16>, UInt16*, ValueTuple<Vector<UInt16>,Vector<UInt16>>)

Parameters

Applies to

StoreAndZip(Vector<UInt32>, UInt32*, Vector<UInt32>)

Parameters

Applies to

StoreAndZip(Vector<UInt32>, UInt32*, ValueTuple<Vector<UInt32>,Vector<UInt32>,Vector<UInt32>>)

Parameters

Applies to

StoreAndZip(Vector<UInt32>, UInt32*, ValueTuple<Vector<UInt32>,Vector<UInt32>>)

Parameters

Applies to

StoreAndZip(Vector<UInt64>, UInt64*, Vector<UInt64>)

Parameters

Applies to

StoreAndZip(Vector<UInt64>, UInt64*, ValueTuple<Vector<UInt64>,Vector<UInt64>,Vector<UInt64>,Vector<UInt64>>)

Parameters

Applies to

StoreAndZip(Vector<UInt64>, UInt64*, ValueTuple<Vector<UInt64>,Vector<UInt64>,Vector<UInt64>>)

Parameters

Applies to

StoreAndZip(Vector<SByte>, SByte*, ValueTuple<Vector<SByte>,Vector<SByte>,Vector<SByte>,Vector<SByte>>)

Parameters

Applies to

StoreAndZip(Vector<UInt16>, UInt16*, ValueTuple<Vector<UInt16>,Vector<UInt16>,Vector<UInt16>>)

Parameters

Applies to

StoreAndZip(Vector<SByte>, SByte*, Vector<SByte>)

Parameters

Applies to

StoreAndZip(Vector<SByte>, SByte*, ValueTuple<Vector<SByte>,Vector<SByte>,Vector<SByte>>)

Parameters

Applies to

StoreAndZip(Vector<Int64>, Int64*, ValueTuple<Vector<Int64>,Vector<Int64>,Vector<Int64>>)

Parameters

Applies to

StoreAndZip(Vector<Int64>, Int64*, ValueTuple<Vector<Int64>,Vector<Int64>>)

Parameters

Applies to

StoreAndZip(Vector<Byte>, Byte*, Vector<Byte>)

Parameters

Applies to

StoreAndZip(Vector<Byte>, Byte*, ValueTuple<Vector<Byte>,Vector<Byte>,Vector<Byte>,Vector<Byte>>)

Parameters

Applies to

StoreAndZip(Vector<Byte>, Byte*, ValueTuple<Vector<Byte>,Vector<Byte>,Vector<Byte>>)

Parameters

Applies to

StoreAndZip(Vector<Byte>, Byte*, ValueTuple<Vector<Byte>,Vector<Byte>>)