Flyology_SIMD.Backends.Scalar

Search API names

Description

Authoritative scalar implementation of the complete primitive operation contract.

Add

function Add (Left, Right : F32x4) return F32x4

Add corresponding floating-point lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add

function Add (Left, Right : F64x2) return F64x2

Add corresponding floating-point lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I16x8) return I16x8

Add corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I32x4) return I32x4

Add corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I64x2) return I64x2

Add corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I8x16) return I8x16

Add corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U16x8) return U16x8

Add corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U32x4) return U32x4

Add corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U64x2) return U64x2

Add corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U8x16) return U8x16

Add corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I16x8) return I16x8

Add corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I32x4) return I32x4

Add corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I64x2) return I64x2

Add corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I8x16) return I8x16

Add corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U16x8) return U16x8

Add corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U32x4) return U32x4

Add corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U64x2) return U64x2

Add corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U8x16) return U8x16

Add corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

All_True

function All_True (Mask : Mask_16x8) return Boolean

Return true when every mask lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

All_True

function All_True (Mask : Mask_32x4) return Boolean

Return true when every mask lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

All_True

function All_True (Mask : Mask_64x2) return Boolean

Return true when every mask lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

All_True

function All_True (Mask : Mask_8x16) return Boolean

Return true when every mask lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_16x8) return Boolean

Return true when at least one mask lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_32x4) return Boolean

Return true when at least one mask lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_64x2) return Boolean

Return true when at least one mask lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_8x16) return Boolean

Return true when at least one mask lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F32x4) return I32x4

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F32x4) return U32x4

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F64x2) return I64x2

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F64x2) return U64x2

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I16x8) return U16x8

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I32x4) return F32x4

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I32x4) return U32x4

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I64x2) return F64x2

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I64x2) return U64x2

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I8x16) return U8x16

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U16x8) return I16x8

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U32x4) return F32x4

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U32x4) return I32x4

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U64x2) return F64x2

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U64x2) return I64x2

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U8x16) return I8x16

Reinterpret every lane's bits without changing its lane position. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I16x8) return I16x8

Apply bitwise AND to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I32x4) return I32x4

Apply bitwise AND to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I64x2) return I64x2

Apply bitwise AND to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I8x16) return I8x16

Apply bitwise AND to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U16x8) return U16x8

Apply bitwise AND to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U32x4) return U32x4

Apply bitwise AND to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U64x2) return U64x2

Apply bitwise AND to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U8x16) return U8x16

Apply bitwise AND to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I16x8) return I16x8

Complement every bit in every integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I32x4) return I32x4

Complement every bit in every integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I64x2) return I64x2

Complement every bit in every integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I8x16) return I8x16

Complement every bit in every integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U16x8) return U16x8

Complement every bit in every integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U32x4) return U32x4

Complement every bit in every integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U64x2) return U64x2

Complement every bit in every integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U8x16) return U8x16

Complement every bit in every integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I16x8) return I16x8

Apply bitwise OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I32x4) return I32x4

Apply bitwise OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I64x2) return I64x2

Apply bitwise OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I8x16) return I8x16

Apply bitwise OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U16x8) return U16x8

Apply bitwise OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U32x4) return U32x4

Apply bitwise OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U64x2) return U64x2

Apply bitwise OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U8x16) return U8x16

Apply bitwise OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I16x8) return I16x8

Apply bitwise exclusive OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I32x4) return I32x4

Apply bitwise exclusive OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I64x2) return I64x2

Apply bitwise exclusive OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I8x16) return I8x16

Apply bitwise exclusive OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U16x8) return U16x8

Apply bitwise exclusive OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U32x4) return U32x4

Apply bitwise exclusive OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U64x2) return U64x2

Apply bitwise exclusive OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U8x16) return U8x16

Apply bitwise exclusive OR to corresponding integer lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Compress

function Compress (Value : F32x4; Mask : Mask_32x4) return F32x4

Stably pack lanes whose mask lane is true toward lane zero. Preserve their complete bit encodings and fill the remaining lanes with zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : F64x2; Mask : Mask_64x2) return F64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : I16x8; Mask : Mask_16x8) return I16x8

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : I32x4; Mask : Mask_32x4) return I32x4

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : I64x2; Mask : Mask_64x2) return I64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : I8x16; Mask : Mask_8x16) return I8x16

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : U16x8; Mask : Mask_16x8) return U16x8

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : U32x4; Mask : Mask_32x4) return U32x4

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : U64x2; Mask : Mask_64x2) return U64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : U8x16; Mask : Mask_8x16) return U8x16

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : I32x4) return F32x4

With the default round-to-nearest, ties-to-even environment, convert each integer lane to the corresponding floating-point lane. The operation does not change the rounding mode or exception-control settings. It can update floating-point exception-status flags. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : I64x2) return F64x2

Parameters

Value: The input value.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : U32x4) return F32x4

Parameters

Value: The input value.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : U64x2) return F64x2

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I16x8) return U16x8

Convert each signed lane to the same-width unsigned lane. A negative input becomes zero. Other values and all lane positions are preserved. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I32x4) return U32x4

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I64x2) return U64x2

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I8x16) return U8x16

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U16x8) return I16x8

Convert each unsigned lane to the same-width signed lane. An input above the signed maximum becomes that maximum. Other values and all lane positions are preserved. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U32x4) return I32x4

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U64x2) return I64x2

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U8x16) return I8x16

Parameters

Value: The input value.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F32x4) return I32x4

Truncate each floating-point lane toward zero, then clamp it to the integer result range. A NaN becomes zero. The operation does not depend on or modify the floating-point rounding mode. It can update floating-point exception-status flags. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F32x4) return U32x4

Parameters

Value: The input value.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F64x2) return I64x2

Parameters

Value: The input value.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F64x2) return U64x2

Parameters

Value: The input value.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : F32x4) return F32x4

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : F64x2) return F64x2

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I16x8) return I16x8

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I32x4) return I32x4

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I64x2) return I64x2

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I8x16) return I8x16

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U16x8) return U16x8

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U32x4) return U32x4

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U64x2) return U64x2

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U8x16) return U8x16

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : F32x4) return F32x4

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : F64x2) return F64x2

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I16x8) return I16x8

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I32x4) return I32x4

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I64x2) return I64x2

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I8x16) return I8x16

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U16x8) return U16x8

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U32x4) return U32x4

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U64x2) return U64x2

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U8x16) return U8x16

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Divide

function Divide (Left, Right : F32x4) return F32x4

Divide corresponding floating-point lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Divide

function Divide (Left, Right : F64x2) return F64x2

Divide corresponding floating-point lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes for equality. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Expand

function Expand (Value : F32x4; Mask : Mask_32x4) return F32x4

Place consecutive low input lanes into result lanes whose mask lane is true. Preserve their complete bit encodings and fill false lanes with zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : F64x2; Mask : Mask_64x2) return F64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : I16x8; Mask : Mask_16x8) return I16x8

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : I32x4; Mask : Mask_32x4) return I32x4

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : I64x2; Mask : Mask_64x2) return I64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : I8x16; Mask : Mask_8x16) return I8x16

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : U16x8; Mask : Mask_16x8) return U16x8

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : U32x4; Mask : Mask_32x4) return U32x4

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : U64x2; Mask : Mask_64x2) return U64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : U8x16; Mask : Mask_8x16) return U8x16

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Extract

function Extract (Value : F32x4; Lane : Lane_Index_32x4) return F32

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : F64x2; Lane : Lane_Index_64x2) return F64

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : I16x8; Lane : Lane_Index_16x8) return I16

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : I32x4; Lane : Lane_Index_32x4) return I32

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : I64x2; Lane : Lane_Index_64x2) return I64

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : I8x16; Lane : Lane_Index_8x16) return I8

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : U16x8; Lane : Lane_Index_16x8) return U16

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : U32x4; Lane : Lane_Index_32x4) return U32

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : U64x2; Lane : Lane_Index_64x2) return U64

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : U8x16; Lane : Lane_Index_8x16) return U8

Return one logical lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

First_True

function First_True (Mask : Mask_16x8) return Lane_Count_16x8

Return the first true lane, or the lane-count value when no lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

First_True

function First_True (Mask : Mask_32x4) return Lane_Count_32x4

Return the first true lane, or the lane-count value when no lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

First_True

function First_True (Mask : Mask_64x2) return Lane_Count_64x2

Return the first true lane, or the lane-count value when no lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

First_True

function First_True (Mask : Mask_8x16) return Lane_Count_8x16

Return the first true lane, or the lane-count value when no lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_8x16) return U8x16

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_F32x4) return F32x4

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_F64x2) return F64x2

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I16x8) return I16x8

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I32x4) return I32x4

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I64x2) return I64x2

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I8x16) return I8x16

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U16x8) return U16x8

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U32x4) return U32x4

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U64x2) return U64x2

Construct a vector from lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Horizontal_Sum

function Horizontal_Sum (Value : U8x16) return Natural

Return the exact sum of all unsigned byte lanes as Natural. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : F32x4) return F32x4

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : F64x2) return F64x2

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I16x8) return I16x8

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I32x4) return I32x4

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I64x2) return I64x2

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I8x16) return I8x16

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U16x8) return U16x8

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U32x4) return U32x4

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U64x2) return U64x2

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U8x16) return U8x16

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : F32x4) return F32x4

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : F64x2) return F64x2

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I16x8) return I16x8

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I32x4) return I32x4

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I64x2) return I64x2

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I8x16) return I8x16

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U16x8) return U16x8

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U32x4) return U32x4

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U64x2) return U64x2

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U8x16) return U8x16

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : Byte_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : F32_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : F64_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : I16_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : I32_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : I64_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : I8_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : U16_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : U32_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : U64_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Last_True

function Last_True (Mask : Mask_16x8) return Lane_Count_16x8

Return the last true lane, or the lane-count value when no lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Last_True

function Last_True (Mask : Mask_32x4) return Lane_Count_32x4

Return the last true lane, or the lane-count value when no lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Last_True

function Last_True (Mask : Mask_64x2) return Lane_Count_64x2

Return the last true lane, or the lane-count value when no lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Last_True

function Last_True (Mask : Mask_8x16) return Lane_Count_8x16

Return the last true lane, or the lane-count value when no lane is true. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Load

function Load (Data : Byte_Array; Start : Natural) return U8x16

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : F32_Array; Start : Natural) return F32x4

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : F64_Array; Start : Natural) return F64x2

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : I16_Array; Start : Natural) return I16x8

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : I32_Array; Start : Natural) return I32x4

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : I64_Array; Start : Natural) return I64x2

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : I8_Array; Start : Natural) return I8x16

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : U16_Array; Start : Natural) return U16x8

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : U32_Array; Start : Natural) return U32x4

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : U64_Array; Start : Natural) return U64x2

Load one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : Byte_Array; Start : Natural) return U8x16

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : F32_Array; Start : Natural) return F32x4

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : F64_Array; Start : Natural) return F64x2

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : I16_Array; Start : Natural) return I16x8

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : I32_Array; Start : Natural) return I32x4

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : I64_Array; Start : Natural) return I64x2

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : I8_Array; Start : Natural) return I8x16

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : U16_Array; Start : Natural) return U16x8

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : U32_Array; Start : Natural) return U32x4

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : U64_Array; Start : Natural) return U64x2

Load one complete vector from a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : Byte_Array; Start : Natural; Count : Lane_Count_8x16) return U8x16

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : F32_Array; Start : Natural; Count : Lane_Count_32x4) return F32x4

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : F64_Array; Start : Natural; Count : Lane_Count_64x2) return F64x2

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I16_Array; Start : Natural; Count : Lane_Count_16x8) return I16x8

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I32_Array; Start : Natural; Count : Lane_Count_32x4) return I32x4

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I64_Array; Start : Natural; Count : Lane_Count_64x2) return I64x2

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I8_Array; Start : Natural; Count : Lane_Count_8x16) return I8x16

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : U16_Array; Start : Natural; Count : Lane_Count_16x8) return U16x8

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : U32_Array; Start : Natural; Count : Lane_Count_32x4) return U32x4

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : U64_Array; Start : Natural; Count : Lane_Count_64x2) return U64x2

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : Byte_Array; Start : Natural) return U8x16

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : F32_Array; Start : Natural) return F32x4

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : F64_Array; Start : Natural) return F64x2

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : I16_Array; Start : Natural) return I16x8

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : I32_Array; Start : Natural) return I32x4

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : I64_Array; Start : Natural) return I64x2

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : I8_Array; Start : Natural) return I8x16

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : U16_Array; Start : Natural) return U16x8

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : U32_Array; Start : Natural) return U32x4

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : U64_Array; Start : Natural) return U64x2

Load one complete vector from an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_16x8) return Mask_16x8

Apply Boolean AND to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_32x4) return Mask_32x4

Apply Boolean AND to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_64x2) return Mask_64x2

Apply Boolean AND to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_8x16) return Mask_8x16

Apply Boolean AND to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Interfaces.Unsigned_16) return Mask_8x16

Construct lane truths from compact bits. Bit zero represents lane zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Bits: Compact lane bits. Bit zero represents lane zero.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Interfaces.Unsigned_8) return Mask_16x8

Construct lane truths from compact bits. Bit zero represents lane zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Bits: Compact lane bits. Bit zero represents lane zero.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Interfaces.Unsigned_8) return Mask_32x4

Construct lane truths from compact bits. Bit zero represents lane zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Bits: Compact lane bits. Bit zero represents lane zero.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Interfaces.Unsigned_8) return Mask_64x2

Construct lane truths from compact bits. Bit zero represents lane zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Bits: Compact lane bits. Bit zero represents lane zero.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_16x8) return Mask_16x8

Complement every mask lane truth. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_32x4) return Mask_32x4

Complement every mask lane truth. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_64x2) return Mask_64x2

Complement every mask lane truth. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_8x16) return Mask_8x16

Complement every mask lane truth. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_16x8) return Mask_16x8

Apply Boolean OR to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_32x4) return Mask_32x4

Apply Boolean OR to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_64x2) return Mask_64x2

Apply Boolean OR to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_8x16) return Mask_8x16

Apply Boolean OR to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_16x8) return Mask_16x8

Apply Boolean exclusive OR to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_32x4) return Mask_32x4

Apply Boolean exclusive OR to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_64x2) return Mask_64x2

Apply Boolean exclusive OR to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_8x16) return Mask_8x16

Apply Boolean exclusive OR to corresponding mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : I16x8) return I16x8

Return the larger integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : I32x4) return I32x4

Return the larger integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : I64x2) return I64x2

Return the larger integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : I8x16) return I8x16

Return the larger integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : U16x8) return U16x8

Return the larger integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : U32x4) return U32x4

Return the larger integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : U64x2) return U64x2

Return the larger integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : U8x16) return U8x16

Return the larger integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max_Number

function Max_Number (Left, Right : F32x4) return F32x4

Return the floating number maximum with the documented NaN and signed-zero rules. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max_Number

function Max_Number (Left, Right : F64x2) return F64x2

Return the floating number maximum with the documented NaN and signed-zero rules. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : I16x8) return I16x8

Return the smaller integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : I32x4) return I32x4

Return the smaller integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : I64x2) return I64x2

Return the smaller integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : I8x16) return I8x16

Return the smaller integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : U16x8) return U16x8

Return the smaller integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : U32x4) return U32x4

Return the smaller integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : U64x2) return U64x2

Return the smaller integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : U8x16) return U8x16

Return the smaller integer in each lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min_Number

function Min_Number (Left, Right : F32x4) return F32x4

Return the floating number minimum with the documented NaN and signed-zero rules. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min_Number

function Min_Number (Left, Right : F64x2) return F64x2

Return the floating number minimum with the documented NaN and signed-zero rules. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply

function Multiply (Left, Right : F32x4) return F32x4

Multiply corresponding floating-point lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply

function Multiply (Left, Right : F64x2) return F64x2

Multiply corresponding floating-point lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I16x8) return I16x8

Multiply corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I32x4) return I32x4

Multiply corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I64x2) return I64x2

Multiply corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I8x16) return I8x16

Multiply corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U16x8) return U16x8

Multiply corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U32x4) return U32x4

Multiply corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U64x2) return U64x2

Multiply corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U8x16) return U8x16

Multiply corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Narrow_Round

function Narrow_Round (Low, High : F64x2) return F32x4

With the default round-to-nearest, ties-to-even and gradual-underflow environment, round Low into result lanes zero and one and High into lanes two and three. Signed zero and infinity are preserved. Overflow after rounding produces infinity. Gradual underflow can produce a subnormal, and a sufficiently small magnitude rounds to signed zero. A NaN remains a NaN, but its payload and signaling state are unspecified. The operation does not change the rounding mode or exception-control settings. It can update floating-point exception-status flags. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I16x8) return I8x16

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I16x8) return U8x16

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I32x4) return I16x8

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I32x4) return U16x8

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I64x2) return I32x4

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I64x2) return U32x4

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : U16x8) return U8x16

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : U32x4) return U16x8

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : U64x2) return U32x4

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : I16x8) return I8x16

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : I32x4) return I16x8

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : I64x2) return I32x4

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : U16x8) return U8x16

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : U32x4) return U16x8

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : U64x2) return U32x4

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

None_True

function None_True (Mask : Mask_16x8) return Boolean

Return true when every mask lane is false. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

None_True

function None_True (Mask : Mask_32x4) return Boolean

Return true when every mask lane is false. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

None_True

function None_True (Mask : Mask_64x2) return Boolean

Return true when every mask lane is false. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

None_True

function None_True (Mask : Mask_8x16) return Boolean

Return true when every mask lane is false. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : F32x4; Map : Two_Source_Lane_Map_32x4) return F32x4

Select each result lane from the left or right vector through a reusable two-source lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : F32x4; Map : Lane_Map_32x4) return F32x4

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : F64x2; Map : Two_Source_Lane_Map_64x2) return F64x2

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : F64x2; Map : Lane_Map_64x2) return F64x2

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I16x8; Map : Two_Source_Lane_Map_16x8) return I16x8

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I16x8; Map : Lane_Map_16x8) return I16x8

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I32x4; Map : Two_Source_Lane_Map_32x4) return I32x4

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I32x4; Map : Lane_Map_32x4) return I32x4

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I64x2; Map : Two_Source_Lane_Map_64x2) return I64x2

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I64x2; Map : Lane_Map_64x2) return I64x2

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I8x16; Map : Two_Source_Lane_Map_8x16) return I8x16

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I8x16; Map : Lane_Map_8x16) return I8x16

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U16x8; Map : Lane_Map_16x8) return U16x8

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U16x8; Map : Two_Source_Lane_Map_16x8) return U16x8

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U32x4; Map : Lane_Map_32x4) return U32x4

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U32x4; Map : Two_Source_Lane_Map_32x4) return U32x4

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U64x2; Map : Lane_Map_64x2) return U64x2

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U64x2; Map : Two_Source_Lane_Map_64x2) return U64x2

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U8x16; Map : Lane_Map_8x16) return U8x16

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U8x16; Map : Two_Source_Lane_Map_8x16) return U8x16

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_16x8) return Lane_Count_16x8

Return the number of true mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_32x4) return Lane_Count_32x4

Return the number of true mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_64x2) return Lane_Count_64x2

Return the number of true mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_8x16) return Lane_Count_8x16

Return the number of true mask lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

Reduce_Add

function Reduce_Add (Value : F32x4) return F32

Add all floating lanes in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add

function Reduce_Add (Value : F64x2) return F64

Add all floating lanes in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I16x8) return I16

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I32x4) return I32

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I64x2) return I64

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I8x16) return I8

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U16x8) return U16

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U32x4) return U32

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U64x2) return U64

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U8x16) return U8

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I16x8) return I16

Return the largest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I32x4) return I32

Return the largest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I64x2) return I64

Return the largest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I8x16) return I8

Return the largest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U16x8) return U16

Return the largest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U32x4) return U32

Return the largest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U64x2) return U64

Return the largest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U8x16) return U8

Return the largest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max_Number

function Reduce_Max_Number (Value : F32x4) return F32

Use lane zero as the initial result. Apply Max_Number to each remaining lane in ascending order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max_Number

function Reduce_Max_Number (Value : F64x2) return F64

Use lane zero as the initial result. Apply Max_Number to each remaining lane in ascending order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I16x8) return I16

Return the smallest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I32x4) return I32

Return the smallest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I64x2) return I64

Return the smallest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I8x16) return I8

Return the smallest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U16x8) return U16

Return the smallest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U32x4) return U32

Return the smallest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U64x2) return U64

Return the smallest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U8x16) return U8

Return the smallest integer lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min_Number

function Reduce_Min_Number (Value : F32x4) return F32

Use lane zero as the initial result. Apply Min_Number to each remaining lane in ascending order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min_Number

function Reduce_Min_Number (Value : F64x2) return F64

Use lane zero as the initial result. Apply Min_Number to each remaining lane in ascending order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Replace

function Replace (Value : F32x4; Lane : Lane_Index_32x4; With_Value : F32) return F32x4

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : F64x2; Lane : Lane_Index_64x2; With_Value : F64) return F64x2

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : I16x8; Lane : Lane_Index_16x8; With_Value : I16) return I16x8

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : I32x4; Lane : Lane_Index_32x4; With_Value : I32) return I32x4

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : I64x2; Lane : Lane_Index_64x2; With_Value : I64) return I64x2

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : I8x16; Lane : Lane_Index_8x16; With_Value : I8) return I8x16

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : U16x8; Lane : Lane_Index_16x8; With_Value : U16) return U16x8

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : U32x4; Lane : Lane_Index_32x4; With_Value : U32) return U32x4

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : U64x2; Lane : Lane_Index_64x2; With_Value : U64) return U64x2

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : U8x16; Lane : Lane_Index_8x16; With_Value : U8) return U8x16

Return a copy with one logical lane replaced. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Reverse_Bytes

function Reverse_Bytes (Value : U8x16) return U8x16

Reverse logical byte-lane order. This is the compatibility name for Reverse_Lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : F32x4) return F32x4

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : F64x2) return F64x2

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I16x8) return I16x8

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I32x4) return I32x4

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I64x2) return I64x2

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I8x16) return I8x16

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U16x8) return U16x8

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U32x4) return U32x4

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U64x2) return U64x2

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U8x16) return U8x16

Reverse logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_16x8; If_True, If_False : I16x8) return I16x8

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_16x8; If_True, If_False : U16x8) return U16x8

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_32x4; If_True, If_False : F32x4) return F32x4

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_32x4; If_True, If_False : I32x4) return I32x4

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_32x4; If_True, If_False : U32x4) return U32x4

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_64x2; If_True, If_False : F64x2) return F64x2

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_64x2; If_True, If_False : I64x2) return I64x2

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_64x2; If_True, If_False : U64x2) return U64x2

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_8x16; If_True, If_False : I8x16) return I8x16

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_8x16; If_True, If_False : U8x16) return U8x16

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I16x8; Count : Natural) return I16x8

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I32x4; Count : Natural) return I32x4

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I64x2; Count : Natural) return I64x2

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I8x16; Count : Natural) return I8x16

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U16x8; Count : Natural) return U16x8

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U32x4; Count : Natural) return U32x4

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U64x2; Count : Natural) return U64x2

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U8x16; Count : Natural) return U8x16

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I16x8; Count : Natural) return I16x8

Shift each signed lane right with sign fill. Use full sign fill when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I32x4; Count : Natural) return I32x4

Shift each signed lane right with sign fill. Use full sign fill when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I64x2; Count : Natural) return I64x2

Shift each signed lane right with sign fill. Use full sign fill when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I8x16; Count : Natural) return I8x16

Shift each signed lane right with sign fill. Use full sign fill when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I16x8; Count : Natural) return I16x8

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I32x4; Count : Natural) return I32x4

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I64x2; Count : Natural) return I64x2

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I8x16; Count : Natural) return I8x16

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U16x8; Count : Natural) return U16x8

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U32x4; Count : Natural) return U32x4

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U64x2; Count : Natural) return U64x2

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U8x16; Count : Natural) return U8x16

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : F32x4; Count : Natural) return F32x4

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward higher lane indexes and fill vacated low-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: this scalar implementation is available on every supported GNAT target. Vacated floating lanes contain positive zero.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : F64x2; Count : Natural) return F64x2

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I16x8; Count : Natural) return I16x8

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I32x4; Count : Natural) return I32x4

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I64x2; Count : Natural) return I64x2

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I8x16; Count : Natural) return I8x16

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U16x8; Count : Natural) return U16x8

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U32x4; Count : Natural) return U32x4

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U64x2; Count : Natural) return U64x2

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U8x16; Count : Natural) return U8x16

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : F32x4; Count : Natural) return F32x4

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward lower lane indexes and fill vacated high-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: this scalar implementation is available on every supported GNAT target. Vacated floating lanes contain positive zero.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : F64x2; Count : Natural) return F64x2

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I16x8; Count : Natural) return I16x8

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I32x4; Count : Natural) return I32x4

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I64x2; Count : Natural) return I64x2

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I8x16; Count : Natural) return I8x16

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U16x8; Count : Natural) return U16x8

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U32x4; Count : Natural) return U32x4

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U64x2; Count : Natural) return U64x2

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U8x16; Count : Natural) return U8x16

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Splat

function Splat (Value : F32) return F32x4

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : F64) return F64x2

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : I16) return I16x8

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : I32) return I32x4

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : I64) return I64x2

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : I8) return I8x16

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : U16) return U16x8

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : U32) return U32x4

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : U64) return U64x2

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : U8) return U8x16

Return a vector in which each lane has the same value. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Store

procedure Store (Data : in out Byte_Array; Start : Natural; Value : U8x16)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out F32_Array; Start : Natural; Value : F32x4)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out F64_Array; Start : Natural; Value : F64x2)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out I16_Array; Start : Natural; Value : I16x8)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out I32_Array; Start : Natural; Value : I32x4)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out I64_Array; Start : Natural; Value : I64x2)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out I8_Array; Start : Natural; Value : I8x16)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out U16_Array; Start : Natural; Value : U16x8)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out U32_Array; Start : Natural; Value : U32x4)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out U64_Array; Start : Natural; Value : U64x2)

Store one complete vector without an alignment requirement. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out Byte_Array; Start : Natural; Value : U8x16)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out F32_Array; Start : Natural; Value : F32x4)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out F64_Array; Start : Natural; Value : F64x2)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out I16_Array; Start : Natural; Value : I16x8)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out I32_Array; Start : Natural; Value : I32x4)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out I64_Array; Start : Natural; Value : I64x2)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out I8_Array; Start : Natural; Value : I8x16)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out U16_Array; Start : Natural; Value : U16x8)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out U32_Array; Start : Natural; Value : U32x4)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out U64_Array; Start : Natural; Value : U64x2)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out Byte_Array; Start : Natural; Count : Lane_Count_8x16; Value : U8x16)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out F32_Array; Start : Natural; Count : Lane_Count_32x4; Value : F32x4)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out F64_Array; Start : Natural; Count : Lane_Count_64x2; Value : F64x2)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out I16_Array; Start : Natural; Count : Lane_Count_16x8; Value : I16x8)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out I32_Array; Start : Natural; Count : Lane_Count_32x4; Value : I32x4)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out I64_Array; Start : Natural; Count : Lane_Count_64x2; Value : I64x2)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out I8_Array; Start : Natural; Count : Lane_Count_8x16; Value : I8x16)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out U16_Array; Start : Natural; Count : Lane_Count_16x8; Value : U16x8)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out U32_Array; Start : Natural; Count : Lane_Count_32x4; Value : U32x4)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out U64_Array; Start : Natural; Count : Lane_Count_64x2; Value : U64x2)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out Byte_Array; Start : Natural; Value : U8x16)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out F32_Array; Start : Natural; Value : F32x4)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out F64_Array; Start : Natural; Value : F64x2)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out I16_Array; Start : Natural; Value : I16x8)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out I32_Array; Start : Natural; Value : I32x4)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out I64_Array; Start : Natural; Value : I64x2)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out I8_Array; Start : Natural; Value : I8x16)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out U16_Array; Start : Natural; Value : U16x8)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out U32_Array; Start : Natural; Value : U32x4)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out U64_Array; Start : Natural; Value : U64x2)

Store one complete vector to an address with any alignment. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Subtract

function Subtract (Left, Right : F32x4) return F32x4

Subtract corresponding floating-point lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract

function Subtract (Left, Right : F64x2) return F64x2

Subtract corresponding floating-point lanes. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I16x8) return I16x8

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I32x4) return I32x4

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I64x2) return I64x2

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I8x16) return I8x16

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U16x8) return U16x8

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U32x4) return U32x4

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U64x2) return U64x2

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U8x16) return U8x16

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I16x8) return I16x8

Subtract corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I32x4) return I32x4

Subtract corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I64x2) return I64x2

Subtract corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I8x16) return I8x16

Subtract corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U16x8) return U16x8

Subtract corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U32x4) return U32x4

Subtract corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U64x2) return U64x2

Subtract corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U8x16) return U8x16

Subtract corresponding lanes modulo the lane width. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Table_Lookup

function Table_Lookup (Table, Indices : U8x16) return U8x16

Use the unsigned value in each index lane for the corresponding result lane. A value from zero through 15 selects the table lane with the same lane index. A larger value returns zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Table: The 16 selectable byte lanes.
Indices: One unsigned table index for each result lane.

Return value

The operation result.

Test

function Test (Mask : Mask_16x8; Lane : Lane_Index_16x8) return Boolean

Return the Boolean truth of one mask lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
Lane: The logical lane index.

Return value

The operation result.

Test

function Test (Mask : Mask_32x4; Lane : Lane_Index_32x4) return Boolean

Return the Boolean truth of one mask lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
Lane: The logical lane index.

Return value

The operation result.

Test

function Test (Mask : Mask_64x2; Lane : Lane_Index_64x2) return Boolean

Return the Boolean truth of one mask lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
Lane: The logical lane index.

Return value

The operation result.

Test

function Test (Mask : Mask_8x16; Lane : Lane_Index_8x16) return Boolean

Return the Boolean truth of one mask lane. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.
Lane: The logical lane index.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_16x8) return Interfaces.Unsigned_8

Return compact lane truths. Bit zero represents lane zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_32x4) return Interfaces.Unsigned_8

Return compact lane truths. Bit zero represents lane zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_64x2) return Interfaces.Unsigned_8

Return compact lane truths. Bit zero represents lane zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_8x16) return Interfaces.Unsigned_16

Return compact lane truths. Bit zero represents lane zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Mask: The input mask.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : F32x4) return Lane_Values_F32x4

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : F64x2) return Lane_Values_F64x2

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I16x8) return Lane_Values_I16x8

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I32x4) return Lane_Values_I32x4

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I64x2) return Lane_Values_I64x2

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I8x16) return Lane_Values_I8x16

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U16x8) return Lane_Values_U16x8

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U32x4) return Lane_Values_U32x4

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U64x2) return Lane_Values_U64x2

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U8x16) return Lane_Values_8x16

Return all lanes in logical lane order. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Unordered

function Unordered (Left, Right : F32x4) return Mask_32x4

Return true in lanes where either floating input is NaN. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Unordered

function Unordered (Left, Right : F64x2) return Mask_64x2

Return true in lanes where either floating input is NaN. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Widen_High

function Widen_High (Value : F32x4) return F64x2

With the platform's default gradual-underflow environment, convert the high binary32 source half exactly to binary64. Signed zero and infinity are preserved. A NaN produces a NaN with unspecified payload and signaling state. The operation can update floating-point exception-status flags. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : I16x8) return I32x4

Convert the high source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : I32x4) return I64x2

Convert the high source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : I8x16) return I16x8

Convert the high source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : U16x8) return U32x4

Convert the high source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : U32x4) return U64x2

Convert the high source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : U8x16) return U16x8

Convert the high source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : F32x4) return F64x2

With the platform's default gradual-underflow environment, convert the low binary32 source half exactly to binary64. Signed zero and infinity are preserved. A NaN produces a NaN with unspecified payload and signaling state. The operation can update floating-point exception-status flags. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : I16x8) return I32x4

Convert the low source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : I32x4) return I64x2

Convert the low source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : I8x16) return I16x8

Convert the low source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : U16x8) return U32x4

Convert the low source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : U32x4) return U64x2

Convert the low source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : U8x16) return U16x8

Convert the low source half according to the documented widening semantics. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Parameters

Value: The input value.

Return value

The operation result.

Zero

function Zero return F32x4

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.

Zero

function Zero return F64x2

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.

Zero

function Zero return I16x8

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.

Zero

function Zero return I32x4

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.

Zero

function Zero return I64x2

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.

Zero

function Zero return I8x16

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.

Zero

function Zero return U16x8

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.

Zero

function Zero return U32x4

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.

Zero

function Zero return U64x2

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.

Zero

function Zero return U8x16

Return a vector in which each lane is zero. Cross-platform support: this scalar implementation is available on every supported GNAT target.

Return value

The operation result.