Flyology_SIMD.Wide

Search API names

Description

Portable 256-bit values. Representations stay private and are not an ABI.

Add

function Add (Left, Right : F32x8) return F32x8

Apply Add independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit vaddps operation and vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Add

function Add (Left, Right : F64x4) return F64x4

Apply Add independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit vaddpd operation and vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I16x16) return I16x16

Apply Add_Saturate independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends call the selected 128-bit Add_Saturate operation for both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I8x32) return I8x32

Apply Add_Saturate independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Add_Saturate operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpaddsb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U8x32) return U8x32

Apply Add_Saturate independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Add_Saturate operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpaddusb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I16x16) return I16x16

Apply Add_Wrap independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends call the selected 128-bit Add_Wrap operation for both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I8x32) return I8x32

Apply Add_Wrap independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Add_Wrap operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpaddb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U8x32) return U8x32

Apply Add_Wrap independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Add_Wrap operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpaddb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

All_True

function All_True (Mask : Mask_16x16) return Boolean

Return the All_True mask reduction. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit All_True operation to both private parts and combine the results with and then. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Mask: The mask input.

Return value

The operation result.

All_True

function All_True (Mask : Mask_32x8) return Boolean

Parameters

Mask: The mask input.

Return value

The operation result.

All_True

function All_True (Mask : Mask_64x4) return Boolean

Parameters

Mask: The mask input.

Return value

The operation result.

All_True

function All_True (Mask : Mask_8x32) return Boolean

Parameters

Mask: The mask input.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_16x16) return Boolean

Return the Any_True mask reduction. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Any_True operation to both private parts and combine the results with or else. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Mask: The mask input.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_32x8) return Boolean

Parameters

Mask: The mask input.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_64x4) return Boolean

Parameters

Mask: The mask input.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_8x32) return Boolean

Parameters

Mask: The mask input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F32x8) return I32x8

Reinterpret every lane bit pattern without changing lane position. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F32x8) return U32x8

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F64x4) return I64x4

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F64x4) return U64x4

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I16x16) return U16x16

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I32x8) return F32x8

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I32x8) return U32x8

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I64x4) return F64x4

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I64x4) return U64x4

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I8x32) return U8x32

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U16x16) return I16x16

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U32x8) return F32x8

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U32x8) return I32x8

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U64x4) return F64x4

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U64x4) return I64x4

Parameters

Value: The value input.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U8x32) return I8x32

Parameters

Value: The value input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I16x16) return I16x16

Apply Bitwise_And independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Bitwise_And operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I8x32) return I8x32

Apply Bitwise_And independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends apply the selected 128-bit Bitwise_And operation to both private parts. The optional AVX2 backend calls an isolated 256-bit vpand leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U8x32) return U8x32

Apply Bitwise_And independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends apply the selected 128-bit Bitwise_And operation to both private parts. The optional AVX2 backend calls an isolated 256-bit vpand leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I16x16) return I16x16

Complement every bit in every lane. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Bitwise_Not operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I32x8) return I32x8

Parameters

Value: The value input.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I64x4) return I64x4

Parameters

Value: The value input.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I8x32) return I8x32

Complement every bit in every lane. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends apply the selected 128-bit Bitwise_Not operation to both private parts. The optional AVX2 backend calls an isolated 256-bit leaf that constructs an all-one mask with vpcmpeqd and complements with vpxor and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U16x16) return U16x16

Parameters

Value: The value input.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U32x8) return U32x8

Parameters

Value: The value input.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U64x4) return U64x4

Parameters

Value: The value input.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U8x32) return U8x32

Complement every bit in every lane. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends apply the selected 128-bit Bitwise_Not operation to both private parts. The optional AVX2 backend calls an isolated 256-bit leaf that constructs an all-one mask with vpcmpeqd and complements with vpxor and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I16x16) return I16x16

Apply Bitwise_Or independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Bitwise_Or operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I8x32) return I8x32

Apply Bitwise_Or independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends apply the selected 128-bit Bitwise_Or operation to both private parts. The optional AVX2 backend calls an isolated 256-bit vpor leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U8x32) return U8x32

Apply Bitwise_Or independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends apply the selected 128-bit Bitwise_Or operation to both private parts. The optional AVX2 backend calls an isolated 256-bit vpor leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I16x16) return I16x16

Apply Bitwise_Xor independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Bitwise_Xor operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I8x32) return I8x32

Apply Bitwise_Xor independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends apply the selected 128-bit Bitwise_Xor operation to both private parts. The optional AVX2 backend calls an isolated 256-bit vpxor leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U8x32) return U8x32

Apply Bitwise_Xor independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends apply the selected 128-bit Bitwise_Xor operation to both private parts. The optional AVX2 backend calls an isolated 256-bit vpxor leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : F32x8; Mask : Mask_32x8) return F32x8

Stably pack true-mask lanes toward lane zero and zero-fill the remainder. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend applies the selected 128-bit To_Bit_Mask operation to each private mask part. It combines the two results and derives one 32-byte compression map. An isolated assembly subprogram runs one two-register NEON tbl operation for each result half. The x86-64 composed and optional AVX2 backends derive two selected-128-bit compression maps. They run one SSE2 two-source permutation for each result half and apply the selected 128-bit mask and zero operations for defined zero fill. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : F64x4; Mask : Mask_64x4) return F64x4

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : I16x16; Mask : Mask_16x16) return I16x16

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : I32x8; Mask : Mask_32x8) return I32x8

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : I64x4; Mask : Mask_64x4) return I64x4

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : I8x32; Mask : Mask_8x32) return I8x32

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : U16x16; Mask : Mask_16x16) return U16x16

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : U32x8; Mask : Mask_32x8) return U32x8

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : U64x4; Mask : Mask_64x4) return U64x4

Parameters

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

Return value

The operation result.

Compress

function Compress (Value : U8x32; Mask : Mask_8x32) return U8x32

Parameters

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

Return value

The operation result.

Convert_Round

function Convert_Round (Value : I32x8) return F32x8

With the default round-to-nearest, ties-to-even environment, convert corresponding integer lanes to finite floating lanes. Do not change the rounding mode or exception-control settings. Floating-point exception-status flags can change. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : I64x4) return F64x4

Parameters

Value: The value input.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : U32x8) return F32x8

Parameters

Value: The value input.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : U64x4) return F64x4

Parameters

Value: The value input.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I16x16) return U16x16

Convert signed lanes to unsigned, clamp negative values to zero, and preserve other values. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I32x8) return U32x8

Parameters

Value: The value input.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I64x4) return U64x4

Parameters

Value: The value input.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I8x32) return U8x32

Parameters

Value: The value input.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U16x16) return I16x16

Convert unsigned lanes to signed, clamp values above the signed maximum, and preserve other values. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U32x8) return I32x8

Parameters

Value: The value input.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U64x4) return I64x4

Parameters

Value: The value input.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U8x32) return I8x32

Parameters

Value: The value input.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F32x8) return I32x8

Truncate finite floating lanes toward zero and clamp to the integer result range. Map NaN to zero. Map positive infinity to the destination maximum. Map negative infinity to the signed minimum or unsigned zero. Do not depend on or modify the floating-point rounding mode. Floating-point exception-status flags can change. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F32x8) return U32x8

Parameters

Value: The value input.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F64x4) return I64x4

Parameters

Value: The value input.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F64x4) return U64x4

Parameters

Value: The value input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : F32x8) return F32x8

Return the even-index lanes of Left followed by the even-index lanes of Right. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend derives a 32-byte index map and runs one four-register NEON tbl operation for each result half. The composed x86-64 backend uses four selected 128-bit two-source Permute_Lanes operations and two selected Select_Value operations. The optional AVX2 backend derives a 32-byte index map and uses four vpshufb instructions, two vperm2i128 instructions, mask selection, and vzeroupper. In a scalar build, the matching Wide.Native overload uses the same four permutations and two selections through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : F64x4) return F64x4

Parameters

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

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I16x16) return I16x16

Parameters

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

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I8x32) return I8x32

Parameters

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

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U8x32) return U8x32

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : F32x8) return F32x8

Return the odd-index lanes of Left followed by the odd-index lanes of Right. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend derives a 32-byte index map and runs one four-register NEON tbl operation for each result half. The composed x86-64 backend uses four selected 128-bit two-source Permute_Lanes operations and two selected Select_Value operations. The optional AVX2 backend derives a 32-byte index map and uses four vpshufb instructions, two vperm2i128 instructions, mask selection, and vzeroupper. In a scalar build, the matching Wide.Native overload uses the same four permutations and two selections through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : F64x4) return F64x4

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I16x16) return I16x16

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I8x32) return I8x32

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U8x32) return U8x32

Parameters

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

Return value

The operation result.

Divide

function Divide (Left, Right : F32x8) return F32x8

Apply Divide independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit vdivps operation and vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Divide

function Divide (Left, Right : F64x4) return F64x4

Apply Divide independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit vdivpd operation and vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : F32x8) return Mask_32x8

Apply Equal independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit Equal operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : F64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : I16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : I32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : I64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : I8x32) return Mask_8x32

Apply Equal independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend runs the selected 128-bit Equal operation on both private parts. The x86-64 backend does the same by default, and the optional AVX2 build uses an isolated relation-specific 256-bit Equal leaf. A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : U16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : U32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : U64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Equal

function Equal (Left, Right : U8x32) return Mask_8x32

Apply Equal independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend runs the selected 128-bit Equal operation on both private parts. The x86-64 backend does the same by default, and the optional AVX2 build uses an isolated relation-specific 256-bit Equal leaf. A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : F32x8; Mask : Mask_32x8) return F32x8

Place consecutive low input lanes into true-mask positions and zero-fill false positions. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend applies the selected 128-bit To_Bit_Mask operation to each private mask part. It combines the two results and derives one 32-byte expansion map. An isolated assembly subprogram runs one two-register NEON tbl operation for each result half. The x86-64 composed and optional AVX2 backends derive two selected-128-bit expansion maps. They run one SSE2 two-source permutation for each result half and apply the selected 128-bit mask and zero operations for defined zero fill. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : F64x4; Mask : Mask_64x4) return F64x4

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : I16x16; Mask : Mask_16x16) return I16x16

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : I32x8; Mask : Mask_32x8) return I32x8

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : I64x4; Mask : Mask_64x4) return I64x4

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : I8x32; Mask : Mask_8x32) return I8x32

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : U16x16; Mask : Mask_16x16) return U16x16

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : U32x8; Mask : Mask_32x8) return U32x8

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : U64x4; Mask : Mask_64x4) return U64x4

Parameters

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

Return value

The operation result.

Expand

function Expand (Value : U8x32; Mask : Mask_8x32) return U8x32

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : F32x8; Lane : Lane_Index_32x8) return F32

Return one logical lane. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the matching selected 128-bit Extract operation only on the private part that contains the requested lane. In a scalar build, the matching Wide.Native overload uses the same selected-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : F64x4; Lane : Lane_Index_64x4) return F64

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : I16x16; Lane : Lane_Index_16x16) return I16

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : I32x8; Lane : Lane_Index_32x8) return I32

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : I64x4; Lane : Lane_Index_64x4) return I64

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : I8x32; Lane : Lane_Index_8x32) return I8

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : U16x16; Lane : Lane_Index_16x16) return U16

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : U32x8; Lane : Lane_Index_32x8) return U32

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : U64x4; Lane : Lane_Index_64x4) return U64

Parameters

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

Return value

The operation result.

Extract

function Extract (Value : U8x32; Lane : Lane_Index_8x32) return U8

Parameters

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

Return value

The operation result.

F32x8

type F32x8 is private;

A private 256-bit vector containing 8 F32 lanes.

F64x4

type F64x4 is private;

A private 256-bit vector containing 4 F64 lanes.

First_True

function First_True (Mask : Mask_16x16) return Lane_Count_16x16

Return the lowest true lane, or the lane-count value when no lane is true. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit First_True operation to both private parts. They return a valid low-part result first, otherwise a valid high-part result plus the private lane count, or the Wide lane count when neither part is true. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Mask: The mask input.

Return value

The operation result.

First_True

function First_True (Mask : Mask_32x8) return Lane_Count_32x8

Parameters

Mask: The mask input.

Return value

The operation result.

First_True

function First_True (Mask : Mask_64x4) return Lane_Count_64x4

Parameters

Mask: The mask input.

Return value

The operation result.

First_True

function First_True (Mask : Mask_8x32) return Lane_Count_8x32

Parameters

Mask: The mask input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_F32x8) return F32x8

Construct a vector in logical lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends split the logical lane array into low and high private parts. They call the matching selected 128-bit From_Lanes operation for each part. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Values: The values input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_F64x4) return F64x4

Parameters

Values: The values input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I16x16) return I16x16

Parameters

Values: The values input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I32x8) return I32x8

Parameters

Values: The values input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I64x4) return I64x4

Parameters

Values: The values input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I8x32) return I8x32

Parameters

Values: The values input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U16x16) return U16x16

Parameters

Values: The values input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U32x8) return U32x8

Parameters

Values: The values input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U64x4) return U64x4

Parameters

Values: The values input.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U8x32) return U8x32

Parameters

Values: The values input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : F32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : F64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I8x32) return Mask_8x32

Apply Greater_Equal independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend runs the selected 128-bit Greater_Equal operation on both private parts. The x86-64 backend does the same by default, and the optional AVX2 build uses an isolated relation-specific 256-bit Greater_Equal leaf. The leaf complements the result of Greater_Than (Right, Left). A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U8x32) return Mask_8x32

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : F32x8) return Mask_32x8

Apply Greater_Than independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit Greater_Than operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : F64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I8x32) return Mask_8x32

Apply Greater_Than independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend runs the selected 128-bit Greater_Than operation on both private parts. The x86-64 backend does the same by default, and the optional AVX2 build uses an isolated relation-specific 256-bit Greater_Than leaf. A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U8x32) return Mask_8x32

Apply Greater_Than independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend runs the selected 128-bit Greater_Than operation on both private parts. The x86-64 backend does the same by default, and the optional AVX2 build uses an isolated relation-specific 256-bit Greater_Than leaf. A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Horizontal_Sum

function Horizontal_Sum (Value : U8x32) return Natural

Return the exact sum of all 32 unsigned byte lanes as Natural. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

I16x16

type I16x16 is private;

A private 256-bit vector containing 16 I16 lanes.

I32x8

type I32x8 is private;

A private 256-bit vector containing 8 I32 lanes.

I64x4

type I64x4 is private;

A private 256-bit vector containing 4 I64 lanes.

I8x32

type I8x32 is private;

A private 256-bit vector containing 32 I8 lanes.

Interleave_High

function Interleave_High (Left, Right : F32x8) return F32x8

Alternate lanes from the high half of Left and Right, starting with Left. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend derives a 32-byte index map and runs one four-register NEON tbl operation for each result half. The composed x86-64 backend uses four selected 128-bit two-source Permute_Lanes operations and two selected Select_Value operations. The optional AVX2 backend derives a 32-byte index map and uses four vpshufb instructions, two vperm2i128 instructions, mask selection, and vzeroupper. In a scalar build, the matching Wide.Native overload uses the same four permutations and two selections through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : F64x4) return F64x4

Parameters

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

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I16x16) return I16x16

Parameters

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

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I8x32) return I8x32

Parameters

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

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U8x32) return U8x32

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : F32x8) return F32x8

Alternate lanes from the low half of Left and Right, starting with Left. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend derives a 32-byte index map and runs one four-register NEON tbl operation for each result half. The composed x86-64 backend uses four selected 128-bit two-source Permute_Lanes operations and two selected Select_Value operations. The optional AVX2 backend derives a 32-byte index map and uses four vpshufb instructions, two vperm2i128 instructions, mask selection, and vzeroupper. In a scalar build, the matching Wide.Native overload uses the same four permutations and two selections through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : F64x4) return F64x4

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I16x16) return I16x16

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I8x32) return I8x32

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U8x32) return U8x32

Parameters

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

Return value

The operation result.

Is_Aligned_32

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

Report whether the selected first element has a 32-byte-aligned address. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends first check that Start is in the array range. For a valid Start, they test the selected element address modulo 32 directly with fixed-width Ada code. A scalar build uses the portable Wide implementation.

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Is_Aligned_32

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Is_Aligned_32

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Is_Aligned_32

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Is_Aligned_32

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Is_Aligned_32

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Is_Aligned_32

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Is_Aligned_32

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Is_Aligned_32

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Is_Aligned_32

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Lane_Count_16x16

subtype Lane_Count_16x16 is Natural range 0 .. 16;

Counts from zero through the complete 16-lane width.

Lane_Count_32x8

subtype Lane_Count_32x8 is Natural range 0 .. 8;

Counts from zero through the complete 8-lane width.

Lane_Count_64x4

subtype Lane_Count_64x4 is Natural range 0 .. 4;

Counts from zero through the complete 4-lane width.

Lane_Count_8x32

subtype Lane_Count_8x32 is Natural range 0 .. 32;

Counts from zero through the complete 32-lane width.

Lane_Index_16x16

subtype Lane_Index_16x16 is Natural range 0 .. 15;

Logical lane indexes for 16-lane vectors.

Lane_Index_32x8

subtype Lane_Index_32x8 is Natural range 0 .. 7;

Logical lane indexes for 8-lane vectors.

Lane_Index_64x4

subtype Lane_Index_64x4 is Natural range 0 .. 3;

Logical lane indexes for 4-lane vectors.

Lane_Index_8x32

subtype Lane_Index_8x32 is Natural range 0 .. 31;

Logical lane indexes for 32-lane vectors.

Lane_Map_16x16

type Lane_Map_16x16 is private;

A reusable, validated mapping from result lanes to source lanes.

Lane_Map_32x8

type Lane_Map_32x8 is private;

A reusable, validated mapping from result lanes to source lanes.

Lane_Map_64x4

type Lane_Map_64x4 is private;

A reusable, validated mapping from result lanes to source lanes.

Lane_Map_8x32

type Lane_Map_8x32 is private;

A reusable, validated mapping from result lanes to source lanes.

Lane_Selectors_16x16

type Lane_Selectors_16x16 is array (Lane_Index_16x16) of Lane_Index_16x16;

One source-lane selector for each result lane.

Lane_Selectors_32x8

type Lane_Selectors_32x8 is array (Lane_Index_32x8) of Lane_Index_32x8;

One source-lane selector for each result lane.

Lane_Selectors_64x4

type Lane_Selectors_64x4 is array (Lane_Index_64x4) of Lane_Index_64x4;

One source-lane selector for each result lane.

Lane_Selectors_8x32

type Lane_Selectors_8x32 is array (Lane_Index_8x32) of Lane_Index_8x32;

One source-lane selector for each result lane.

Lane_Values_F32x8

type Lane_Values_F32x8 is array (Lane_Index_32x8) of F32;

F32 lane values in logical lane order.

Lane_Values_F64x4

type Lane_Values_F64x4 is array (Lane_Index_64x4) of F64;

F64 lane values in logical lane order.

Lane_Values_I16x16

type Lane_Values_I16x16 is array (Lane_Index_16x16) of I16;

I16 lane values in logical lane order.

Lane_Values_I32x8

type Lane_Values_I32x8 is array (Lane_Index_32x8) of I32;

I32 lane values in logical lane order.

Lane_Values_I64x4

type Lane_Values_I64x4 is array (Lane_Index_64x4) of I64;

I64 lane values in logical lane order.

Lane_Values_I8x32

type Lane_Values_I8x32 is array (Lane_Index_8x32) of I8;

I8 lane values in logical lane order.

Lane_Values_U16x16

type Lane_Values_U16x16 is array (Lane_Index_16x16) of U16;

U16 lane values in logical lane order.

Lane_Values_U32x8

type Lane_Values_U32x8 is array (Lane_Index_32x8) of U32;

U32 lane values in logical lane order.

Lane_Values_U64x4

type Lane_Values_U64x4 is array (Lane_Index_64x4) of U64;

U64 lane values in logical lane order.

Lane_Values_U8x32

type Lane_Values_U8x32 is array (Lane_Index_8x32) of U8;

U8 lane values in logical lane order.

Last_True

function Last_True (Mask : Mask_16x16) return Lane_Count_16x16

Return the highest true lane, or the lane-count value when no lane is true. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Last_True operation to both private parts. They return a valid high-part result plus the private lane count first, otherwise a valid low-part result, or the Wide lane count when neither part is true. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Mask: The mask input.

Return value

The operation result.

Last_True

function Last_True (Mask : Mask_32x8) return Lane_Count_32x8

Parameters

Mask: The mask input.

Return value

The operation result.

Last_True

function Last_True (Mask : Mask_64x4) return Lane_Count_64x4

Parameters

Mask: The mask input.

Return value

The operation result.

Last_True

function Last_True (Mask : Mask_8x32) return Lane_Count_8x32

Parameters

Mask: The mask input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : F32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : F64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I8x32) return Mask_8x32

Apply Less_Equal independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend runs the selected 128-bit Less_Equal operation on both private parts. The x86-64 backend does the same by default, and the optional AVX2 build uses an isolated relation-specific 256-bit Less_Equal leaf. The leaf complements the result of Greater_Than (Left, Right). A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U8x32) return Mask_8x32

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : F32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : F64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I8x32) return Mask_8x32

Apply Less_Than independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend runs the selected 128-bit Less_Than operation on both private parts. The x86-64 backend does the same by default, and the optional AVX2 build uses an isolated relation-specific 256-bit Less_Than leaf. The leaf reverses the operands within its Greater_Than comparison. A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U16x16) return Mask_16x16

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U8x32) return Mask_8x32

Parameters

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

Return value

The operation result.

Load

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

Load one complete vector without an alignment requirement. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the selected 128-bit Load operation at Start and Start plus the private lane count. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Load one complete vector from a 32-byte-aligned address. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the selected 128-bit Load_Aligned operation at Start and Start plus the private lane count. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Aligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : Byte_Array; Start : Natural; Count : Lane_Count_8x32) return U8x32

Read exactly Count elements and zero-fill remaining lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, when Count does not exceed the private lane count, the AArch64 and x86-64 backends call the selected 128-bit Load_Partial operation for the low result part and the selected Zero operation for the high result part. When Count exceeds the private lane count, they call the selected Load operation for the low result part and the selected Load_Partial operation for the remaining high lanes. A zero count does not evaluate an element address. In a scalar build, the matching Wide.Native overload uses the same conditional composition through the portable 128-bit implementation.

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : F32_Array; Start : Natural; Count : Lane_Count_32x8) return F32x8

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : F64_Array; Start : Natural; Count : Lane_Count_64x4) return F64x4

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I16_Array; Start : Natural; Count : Lane_Count_16x16) return I16x16

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I32_Array; Start : Natural; Count : Lane_Count_32x8) return I32x8

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I64_Array; Start : Natural; Count : Lane_Count_64x4) return I64x4

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I8_Array; Start : Natural; Count : Lane_Count_8x32) return I8x32

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : U16_Array; Start : Natural; Count : Lane_Count_16x16) return U16x16

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : U32_Array; Start : Natural; Count : Lane_Count_32x8) return U32x8

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : U64_Array; Start : Natural; Count : Lane_Count_64x4) return U64x4

Parameters

Data: The data input.
Start: The start input.
Count: The count input.

Return value

The operation result.

Load_Unaligned

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

Load one complete vector from an address with any alignment. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the selected 128-bit Load_Unaligned operation at Start and Start plus the private lane count. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Unaligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Unaligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Unaligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Unaligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Unaligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Unaligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Unaligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Unaligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Load_Unaligned

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

Parameters

Data: The data input.
Start: The start input.

Return value

The operation result.

Make_Lane_Map

function Make_Lane_Map (Selectors : Lane_Selectors_16x16) return Lane_Map_16x16

Build a reusable map from result lanes to source lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends use portable Ada code. A scalar build uses the portable Wide implementation.

Parameters

Selectors: The selectors input.

Return value

The operation result.

Make_Lane_Map

function Make_Lane_Map (Selectors : Lane_Selectors_32x8) return Lane_Map_32x8

Parameters

Selectors: The selectors input.

Return value

The operation result.

Make_Lane_Map

function Make_Lane_Map (Selectors : Lane_Selectors_64x4) return Lane_Map_64x4

Parameters

Selectors: The selectors input.

Return value

The operation result.

Make_Lane_Map

function Make_Lane_Map (Selectors : Lane_Selectors_8x32) return Lane_Map_8x32

Parameters

Selectors: The selectors input.

Return value

The operation result.

Make_Two_Source_Lane_Map

function Make_Two_Source_Lane_Map (Selectors : Two_Source_Lane_Selectors_16x16) return Two_Source_Lane_Map_16x16

Build a reusable map from result lanes to lanes of two inputs. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends use portable Ada code. A scalar build uses the portable Wide implementation.

Parameters

Selectors: The selectors input.

Return value

The operation result.

Make_Two_Source_Lane_Map

function Make_Two_Source_Lane_Map (Selectors : Two_Source_Lane_Selectors_32x8) return Two_Source_Lane_Map_32x8

Parameters

Selectors: The selectors input.

Return value

The operation result.

Make_Two_Source_Lane_Map

function Make_Two_Source_Lane_Map (Selectors : Two_Source_Lane_Selectors_64x4) return Two_Source_Lane_Map_64x4

Parameters

Selectors: The selectors input.

Return value

The operation result.

Make_Two_Source_Lane_Map

function Make_Two_Source_Lane_Map (Selectors : Two_Source_Lane_Selectors_8x32) return Two_Source_Lane_Map_8x32

Parameters

Selectors: The selectors input.

Return value

The operation result.

Mask_16x16

type Mask_16x16 is private;

One semantic Boolean truth for each of 16 lanes.

Mask_32x8

type Mask_32x8 is private;

One semantic Boolean truth for each of 8 lanes.

Mask_64x4

type Mask_64x4 is private;

One semantic Boolean truth for each of 4 lanes.

Mask_8x32

type Mask_8x32 is private;

One semantic Boolean truth for each of 32 lanes.

Mask_And

function Mask_And (Left, Right : Mask_16x16) return Mask_16x16

Apply Mask_And to corresponding mask truths. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Mask_And operation to the corresponding private parts and build the two-part mask result. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_8x32) return Mask_8x32

Parameters

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

Return value

The operation result.

Mask_Bits_16x16

subtype Mask_Bits_16x16 is Interfaces.Unsigned_16 range 0 .. 65535;

Compact bits for exactly 16 mask lanes.

Mask_Bits_32x8

subtype Mask_Bits_32x8 is Interfaces.Unsigned_8 range 0 .. 255;

Compact bits for exactly 8 mask lanes.

Mask_Bits_64x4

subtype Mask_Bits_64x4 is Interfaces.Unsigned_8 range 0 .. 15;

Compact bits for exactly 4 mask lanes.

Mask_Bits_8x32

subtype Mask_Bits_8x32 is Interfaces.Unsigned_32 range 0 .. 4294967295;

Compact bits for exactly 32 mask lanes.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Mask_Bits_16x16) return Mask_16x16

Construct lane truths from compact bits. Bit zero represents lane zero. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Mask_From_Bit_Mask operation to the low and high compact-bit halves and build the two-part mask result. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Bits: The bits input.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Mask_Bits_32x8) return Mask_32x8

Parameters

Bits: The bits input.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Mask_Bits_64x4) return Mask_64x4

Parameters

Bits: The bits input.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Mask_Bits_8x32) return Mask_8x32

Parameters

Bits: The bits input.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_16x16) return Mask_16x16

Complement every mask truth. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Mask_Not operation to the corresponding private parts and build the two-part mask result. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_32x8) return Mask_32x8

Parameters

Value: The value input.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_64x4) return Mask_64x4

Parameters

Value: The value input.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_8x32) return Mask_8x32

Parameters

Value: The value input.

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_16x16) return Mask_16x16

Apply Mask_Or to corresponding mask truths. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Mask_Or operation to the corresponding private parts and build the two-part mask result. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_8x32) return Mask_8x32

Parameters

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

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_16x16) return Mask_16x16

Apply Mask_Xor to corresponding mask truths. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Mask_Xor operation to the corresponding private parts and build the two-part mask result. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_32x8) return Mask_32x8

Parameters

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

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_8x32) return Mask_8x32

Parameters

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

Return value

The operation result.

Max

function Max (Left, Right : I16x16) return I16x16

Apply Max independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends call the selected 128-bit Max operation for both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Max

function Max (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Max

function Max (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Max

function Max (Left, Right : I8x32) return I8x32

Apply Max independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Max operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpmaxsb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Max

function Max (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Max

function Max (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Max

function Max (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Max

function Max (Left, Right : U8x32) return U8x32

Apply Max independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Max operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpmaxub leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Max_Number

function Max_Number (Left, Right : F32x8) return F32x8

Apply Max_Number independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit integer-classification and bit-selection sequence. The sequence preserves the documented NaN and signed-zero rules. Each leaf ends with vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Max_Number

function Max_Number (Left, Right : F64x4) return F64x4

Parameters

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

Return value

The operation result.

Min

function Min (Left, Right : I16x16) return I16x16

Apply Min independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends call the selected 128-bit Min operation for both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Min

function Min (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Min

function Min (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Min

function Min (Left, Right : I8x32) return I8x32

Apply Min independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Min operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpminsb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Min

function Min (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Min

function Min (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Min

function Min (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Min

function Min (Left, Right : U8x32) return U8x32

Apply Min independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Min operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpminub leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Min_Number

function Min_Number (Left, Right : F32x8) return F32x8

Apply Min_Number independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit integer-classification and bit-selection sequence. The sequence preserves the documented NaN and signed-zero rules. Each leaf ends with vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Min_Number

function Min_Number (Left, Right : F64x4) return F64x4

Parameters

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

Return value

The operation result.

Multiply

function Multiply (Left, Right : F32x8) return F32x8

Apply Multiply independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit vmulps operation and vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Multiply

function Multiply (Left, Right : F64x4) return F64x4

Apply Multiply independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit vmulpd operation and vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I16x16) return I16x16

Apply Multiply_Wrap independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends call the selected 128-bit Multiply_Wrap operation for both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I8x32) return I8x32

Apply Multiply_Wrap independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Multiply_Wrap operation for both private parts. The optional AVX2 backend calls an isolated 256-bit byte-multiplication leaf that uses vpmullw, vpand, vpsrlw, vpsllw, and vpor and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U8x32) return U8x32

Apply Multiply_Wrap independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Multiply_Wrap operation for both private parts. The optional AVX2 backend calls an isolated 256-bit byte-multiplication leaf that uses vpmullw, vpand, vpsrlw, vpsllw, and vpor and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Narrow_Round

function Narrow_Round (Low, High : F64x4) return F32x8

With the default round-to-nearest, ties-to-even and gradual-underflow environment, round binary64 lanes to binary32 and concatenate Low before High. Preserve signed zero and infinity. Use gradual underflow and signed overflow to infinity. A NaN remains a NaN with unspecified payload and signaling state. Do not change the rounding mode or exception-control settings. Floating-point exception-status flags can change. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I16x16) return I8x32

Clamp every source lane to the result range and concatenate Low before High. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I16x16) return U8x32

Clamp signed lanes to the unsigned result range and concatenate Low before High. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I32x8) return I16x16

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I32x8) return U16x16

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I64x4) return I32x8

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I64x4) return U32x8

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : U16x16) return U8x32

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : U32x8) return U16x16

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : U64x4) return U32x8

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : I16x16) return I8x32

Keep the low bits of every source lane and concatenate Low before High. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : I32x8) return I16x16

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : I64x4) return I32x8

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : U16x16) return U8x32

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : U32x8) return U16x16

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : U64x4) return U32x8

Parameters

Low: The low input.
High: The high input.

Return value

The operation result.

None_True

function None_True (Mask : Mask_16x16) return Boolean

Return the None_True mask reduction. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit None_True operation to both private parts and combine the results with and then. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Mask: The mask input.

Return value

The operation result.

None_True

function None_True (Mask : Mask_32x8) return Boolean

Parameters

Mask: The mask input.

Return value

The operation result.

None_True

function None_True (Mask : Mask_64x4) return Boolean

Parameters

Mask: The mask input.

Return value

The operation result.

None_True

function None_True (Mask : Mask_8x32) return Boolean

Parameters

Mask: The mask input.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : F32x8; Map : Two_Source_Lane_Map_32x8) return F32x8

Select each result lane from one lane of either input. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend derives a 32-byte index map and runs one four-register NEON tbl operation for each result half. The composed x86-64 backend uses four selected 128-bit two-source Permute_Lanes operations and two selected Select_Value operations. The optional AVX2 backend derives a 32-byte index map and uses four vpshufb instructions, two vperm2i128 instructions, mask selection, and vzeroupper. In a scalar build, the matching Wide.Native overload uses the same four permutations and two selections through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : F32x8; Map : Lane_Map_32x8) return F32x8

Select each result lane through a reusable lane map. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend derives a 32-byte index map and runs one two-register NEON tbl operation for each result half. The composed x86-64 backend uses two selected 128-bit two-source Permute_Lanes operations. The optional AVX2 backend derives a 32-byte index map and uses two vpshufb instructions, one vperm2i128 instruction, mask selection, and vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two Permute_Lanes operations through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : F64x4; Map : Two_Source_Lane_Map_64x4) return F64x4

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : F64x4; Map : Lane_Map_64x4) return F64x4

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I16x16; Map : Two_Source_Lane_Map_16x16) return I16x16

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I16x16; Map : Lane_Map_16x16) return I16x16

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I32x8; Map : Two_Source_Lane_Map_32x8) return I32x8

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I32x8; Map : Lane_Map_32x8) return I32x8

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I64x4; Map : Two_Source_Lane_Map_64x4) return I64x4

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I64x4; Map : Lane_Map_64x4) return I64x4

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I8x32; Map : Two_Source_Lane_Map_8x32) return I8x32

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I8x32; Map : Lane_Map_8x32) return I8x32

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U16x16; Map : Lane_Map_16x16) return U16x16

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U16x16; Map : Two_Source_Lane_Map_16x16) return U16x16

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U32x8; Map : Lane_Map_32x8) return U32x8

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U32x8; Map : Two_Source_Lane_Map_32x8) return U32x8

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U64x4; Map : Lane_Map_64x4) return U64x4

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U64x4; Map : Two_Source_Lane_Map_64x4) return U64x4

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U8x32; Map : Lane_Map_8x32) return U8x32

Parameters

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

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U8x32; Map : Two_Source_Lane_Map_8x32) return U8x32

Parameters

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

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_16x16) return Lane_Count_16x16

Return the number of true lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Population_Count operation to both private parts and add the two counts. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Mask: The mask input.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_32x8) return Lane_Count_32x8

Parameters

Mask: The mask input.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_64x4) return Lane_Count_64x4

Parameters

Mask: The mask input.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_8x32) return Lane_Count_8x32

Parameters

Mask: The mask input.

Return value

The operation result.

Reduce_Add

function Reduce_Add (Value : F32x8) return F32

Apply Reduce_Add in ascending lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend uses a dedicated Advanced SIMD sequence that starts from positive zero and adds one lane at a time in ascending order. The x86-64 backend uses a dedicated SSE2 sequence with the same start value and lane order. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Add

function Reduce_Add (Value : F64x4) return F64

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I16x16) return I16

Apply Reduce_Add_Wrap in ascending lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends reduce each private part with the selected 128-bit Reduce_Add_Wrap operation, combine the two results with the selected 128-bit Add_Wrap operation, and extract lane zero. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I32x8) return I32

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I64x4) return I64

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I8x32) return I8

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U16x16) return U16

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U32x8) return U32

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U64x4) return U64

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U8x32) return U8

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I16x16) return I16

Apply Reduce_Max in ascending lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends reduce each private part with the selected 128-bit Reduce_Max operation, combine the two results with the selected 128-bit Max operation, and extract lane zero. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I32x8) return I32

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I64x4) return I64

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I8x32) return I8

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U16x16) return U16

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U32x8) return U32

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U64x4) return U64

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U8x32) return U8

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max_Number

function Reduce_Max_Number (Value : F32x8) return F32

Apply Reduce_Max_Number in ascending lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend uses a dedicated Advanced SIMD sequence that applies fmaxnm to one lane at a time in ascending order. The x86-64 backend uses a dedicated integer-only SSE2 classification and bit-selection sequence that applies maximum-number in the same order. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Max_Number

function Reduce_Max_Number (Value : F64x4) return F64

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I16x16) return I16

Apply Reduce_Min in ascending lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends reduce each private part with the selected 128-bit Reduce_Min operation, combine the two results with the selected 128-bit Min operation, and extract lane zero. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I32x8) return I32

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I64x4) return I64

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I8x32) return I8

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U16x16) return U16

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U32x8) return U32

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U64x4) return U64

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U8x32) return U8

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min_Number

function Reduce_Min_Number (Value : F32x8) return F32

Apply Reduce_Min_Number in ascending lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend uses a dedicated Advanced SIMD sequence that applies fminnm to one lane at a time in ascending order. The x86-64 backend uses a dedicated integer-only SSE2 classification and bit-selection sequence that applies minimum-number in the same order. A scalar build uses the portable Wide implementation.

Parameters

Value: The value input.

Return value

The operation result.

Reduce_Min_Number

function Reduce_Min_Number (Value : F64x4) return F64

Parameters

Value: The value input.

Return value

The operation result.

Replace

function Replace (Value : F32x8; Lane : Lane_Index_32x8; With_Value : F32) return F32x8

Return a copy with one lane replaced. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the matching selected 128-bit Replace operation only on the private part that contains the requested lane and preserve the other part. In a scalar build, the matching Wide.Native overload uses the same selected-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Replace

function Replace (Value : F64x4; Lane : Lane_Index_64x4; With_Value : F64) return F64x4

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Replace

function Replace (Value : I16x16; Lane : Lane_Index_16x16; With_Value : I16) return I16x16

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Replace

function Replace (Value : I32x8; Lane : Lane_Index_32x8; With_Value : I32) return I32x8

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Replace

function Replace (Value : I64x4; Lane : Lane_Index_64x4; With_Value : I64) return I64x4

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Replace

function Replace (Value : I8x32; Lane : Lane_Index_8x32; With_Value : I8) return I8x32

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Replace

function Replace (Value : U16x16; Lane : Lane_Index_16x16; With_Value : U16) return U16x16

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Replace

function Replace (Value : U32x8; Lane : Lane_Index_32x8; With_Value : U32) return U32x8

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Replace

function Replace (Value : U64x4; Lane : Lane_Index_64x4; With_Value : U64) return U64x4

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Replace

function Replace (Value : U8x32; Lane : Lane_Index_8x32; With_Value : U8) return U8x32

Parameters

Value: The value input.
Lane: The lane input.
With_Value: The with value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : F32x8) return F32x8

Reverse logical lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend derives a 32-byte index map and runs one two-register NEON tbl operation for each result half. The composed x86-64 backend uses two selected 128-bit two-source Permute_Lanes operations. The optional AVX2 backend derives a 32-byte index map and uses two vpshufb instructions, one vperm2i128 instruction, mask selection, and vzeroupper. In a scalar build, the matching Wide.Native overload uses two selected 128-bit two-source Permute_Lanes operations through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : F64x4) return F64x4

Parameters

Value: The value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I16x16) return I16x16

Parameters

Value: The value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I32x8) return I32x8

Parameters

Value: The value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I64x4) return I64x4

Parameters

Value: The value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I8x32) return I8x32

Parameters

Value: The value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U16x16) return U16x16

Parameters

Value: The value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U32x8) return U32x8

Parameters

Value: The value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U64x4) return U64x4

Parameters

Value: The value input.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U8x32) return U8x32

Parameters

Value: The value input.

Return value

The operation result.

Select_Left_Lane

function Select_Left_Lane (Lane : Lane_Index_16x16) return Two_Source_Lane_Selector_16x16

Construct a selector for one lane of the left input. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends use portable Ada code. A scalar build uses the portable Wide implementation.

Parameters

Lane: The lane input.

Return value

The operation result.

Select_Left_Lane

function Select_Left_Lane (Lane : Lane_Index_32x8) return Two_Source_Lane_Selector_32x8

Parameters

Lane: The lane input.

Return value

The operation result.

Select_Left_Lane

function Select_Left_Lane (Lane : Lane_Index_64x4) return Two_Source_Lane_Selector_64x4

Parameters

Lane: The lane input.

Return value

The operation result.

Select_Left_Lane

function Select_Left_Lane (Lane : Lane_Index_8x32) return Two_Source_Lane_Selector_8x32

Parameters

Lane: The lane input.

Return value

The operation result.

Select_Right_Lane

function Select_Right_Lane (Lane : Lane_Index_16x16) return Two_Source_Lane_Selector_16x16

Construct a selector for one lane of the right input. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends use portable Ada code. A scalar build uses the portable Wide implementation.

Parameters

Lane: The lane input.

Return value

The operation result.

Select_Right_Lane

function Select_Right_Lane (Lane : Lane_Index_32x8) return Two_Source_Lane_Selector_32x8

Parameters

Lane: The lane input.

Return value

The operation result.

Select_Right_Lane

function Select_Right_Lane (Lane : Lane_Index_64x4) return Two_Source_Lane_Selector_64x4

Parameters

Lane: The lane input.

Return value

The operation result.

Select_Right_Lane

function Select_Right_Lane (Lane : Lane_Index_8x32) return Two_Source_Lane_Selector_8x32

Parameters

Lane: The lane input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_16x16; If_True, If_False : I16x16) return I16x16

Select one input in each lane according to mask truth. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit Select_Value operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_16x16; If_True, If_False : U16x16) return U16x16

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_32x8; If_True, If_False : F32x8) return F32x8

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_32x8; If_True, If_False : I32x8) return I32x8

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_32x8; If_True, If_False : U32x8) return U32x8

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_64x4; If_True, If_False : F64x4) return F64x4

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_64x4; If_True, If_False : I64x4) return I64x4

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_64x4; If_True, If_False : U64x4) return U64x4

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_8x32; If_True, If_False : I8x32) return I8x32

Select one input in each lane according to mask truth. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend runs the selected 128-bit Select_Value operation on both private parts. The x86-64 backend does the same by default, and the optional AVX2 build uses an isolated relation-specific 256-bit Select_Value leaf. A scalar build uses the portable Wide implementation.

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_8x32; If_True, If_False : U8x32) return U8x32

Select one input in each lane according to mask truth. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend runs the selected 128-bit Select_Value operation on both private parts. The x86-64 backend does the same by default, and the optional AVX2 build uses an isolated relation-specific 256-bit Select_Value leaf. A scalar build uses the portable Wide implementation.

Parameters

Mask: The mask input.
If_True: The if true input.
If_False: The if false input.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I16x16; Count : Natural) return I16x16

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Left_Logical operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I32x8; Count : Natural) return I32x8

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I64x4; Count : Natural) return I64x4

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I8x32; Count : Natural) return I8x32

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U16x16; Count : Natural) return U16x16

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U32x8; Count : Natural) return U32x8

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U64x4; Count : Natural) return U64x4

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U8x32; Count : Natural) return U8x32

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I16x16; Count : Natural) return I16x16

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Arithmetic operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I32x8; Count : Natural) return I32x8

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Arithmetic operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I64x4; Count : Natural) return I64x4

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Arithmetic operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I8x32; Count : Natural) return I8x32

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Arithmetic operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I16x16; Count : Natural) return I16x16

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Logical operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I32x8; Count : Natural) return I32x8

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Logical operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I64x4; Count : Natural) return I64x4

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Logical operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I8x32; Count : Natural) return I8x32

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Logical operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U16x16; Count : Natural) return U16x16

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Logical operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U32x8; Count : Natural) return U32x8

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Logical operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U64x4; Count : Natural) return U64x4

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Logical operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U8x32; Count : Natural) return U8x32

Shift every lane with the documented oversized-count result. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Shift_Right_Logical operation to both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : F32x8; Count : Natural) return F32x8

Move retained lanes and zero-fill vacated lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend derives a 32-byte index map and runs one two-register NEON tbl operation for each result half. The composed x86-64 backend uses two selected 128-bit two-source Permute_Lanes operations and two selected Select_Value operations against Zero. The optional AVX2 backend derives a 32-byte index map and uses two vpshufb instructions, one vperm2i128 instruction, mask selection, and vzeroupper. In a scalar build, the matching Wide.Native overload uses two selected 128-bit two-source Permute_Lanes operations and two selected Select_Value operations against Zero through the portable 128-bit implementation.

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : F64x4; Count : Natural) return F64x4

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I16x16; Count : Natural) return I16x16

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I32x8; Count : Natural) return I32x8

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I64x4; Count : Natural) return I64x4

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I8x32; Count : Natural) return I8x32

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U16x16; Count : Natural) return U16x16

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U32x8; Count : Natural) return U32x8

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U64x4; Count : Natural) return U64x4

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U8x32; Count : Natural) return U8x32

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : F32x8; Count : Natural) return F32x8

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : F64x4; Count : Natural) return F64x4

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I16x16; Count : Natural) return I16x16

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I32x8; Count : Natural) return I32x8

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I64x4; Count : Natural) return I64x4

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I8x32; Count : Natural) return I8x32

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U16x16; Count : Natural) return U16x16

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U32x8; Count : Natural) return U32x8

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U64x4; Count : Natural) return U64x4

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U8x32; Count : Natural) return U8x32

Parameters

Value: The value input.
Count: The count input.

Return value

The operation result.

Splat

function Splat (Value : F32) return F32x8

Return a vector whose lanes all contain Value. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the selected 128-bit Splat operation for both private parts and return the two-part result. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Splat

function Splat (Value : F64) return F64x4

Parameters

Value: The value input.

Return value

The operation result.

Splat

function Splat (Value : I16) return I16x16

Parameters

Value: The value input.

Return value

The operation result.

Splat

function Splat (Value : I32) return I32x8

Parameters

Value: The value input.

Return value

The operation result.

Splat

function Splat (Value : I64) return I64x4

Parameters

Value: The value input.

Return value

The operation result.

Splat

function Splat (Value : I8) return I8x32

Parameters

Value: The value input.

Return value

The operation result.

Splat

function Splat (Value : U16) return U16x16

Parameters

Value: The value input.

Return value

The operation result.

Splat

function Splat (Value : U32) return U32x8

Parameters

Value: The value input.

Return value

The operation result.

Splat

function Splat (Value : U64) return U64x4

Parameters

Value: The value input.

Return value

The operation result.

Splat

function Splat (Value : U8) return U8x32

Parameters

Value: The value input.

Return value

The operation result.

Store

procedure Store (Data : in out Byte_Array; Start : Natural; Value : U8x32)

Store one complete vector without an alignment requirement. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the selected 128-bit Store operation at Start and Start plus the private lane count. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store

procedure Store (Data : in out F32_Array; Start : Natural; Value : F32x8)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store

procedure Store (Data : in out F64_Array; Start : Natural; Value : F64x4)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store

procedure Store (Data : in out I16_Array; Start : Natural; Value : I16x16)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store

procedure Store (Data : in out I32_Array; Start : Natural; Value : I32x8)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store

procedure Store (Data : in out I64_Array; Start : Natural; Value : I64x4)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store

procedure Store (Data : in out I8_Array; Start : Natural; Value : I8x32)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store

procedure Store (Data : in out U16_Array; Start : Natural; Value : U16x16)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store

procedure Store (Data : in out U32_Array; Start : Natural; Value : U32x8)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store

procedure Store (Data : in out U64_Array; Start : Natural; Value : U64x4)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out Byte_Array; Start : Natural; Value : U8x32)

Store one complete vector to a 32-byte-aligned address. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the selected 128-bit Store_Aligned operation at Start and Start plus the private lane count. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out F32_Array; Start : Natural; Value : F32x8)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out F64_Array; Start : Natural; Value : F64x4)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out I16_Array; Start : Natural; Value : I16x16)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out I32_Array; Start : Natural; Value : I32x8)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out I64_Array; Start : Natural; Value : I64x4)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out I8_Array; Start : Natural; Value : I8x32)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out U16_Array; Start : Natural; Value : U16x16)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out U32_Array; Start : Natural; Value : U32x8)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Aligned

procedure Store_Aligned (Data : in out U64_Array; Start : Natural; Value : U64x4)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out Byte_Array; Start : Natural; Count : Lane_Count_8x32; Value : U8x32)

Write exactly Count elements and leave all others unchanged. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, when Count does not exceed the private lane count, the AArch64 and x86-64 backends call the selected 128-bit Store_Partial operation for the low value part. When Count exceeds the private lane count, they call the selected Store operation for the low value part and the selected Store_Partial operation for the remaining high lanes. A zero count does not evaluate an element address. In a scalar build, the matching Wide.Native overload uses the same conditional composition through the portable 128-bit implementation.

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out F32_Array; Start : Natural; Count : Lane_Count_32x8; Value : F32x8)

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out F64_Array; Start : Natural; Count : Lane_Count_64x4; Value : F64x4)

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out I16_Array; Start : Natural; Count : Lane_Count_16x16; Value : I16x16)

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out I32_Array; Start : Natural; Count : Lane_Count_32x8; Value : I32x8)

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out I64_Array; Start : Natural; Count : Lane_Count_64x4; Value : I64x4)

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out I8_Array; Start : Natural; Count : Lane_Count_8x32; Value : I8x32)

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out U16_Array; Start : Natural; Count : Lane_Count_16x16; Value : U16x16)

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out U32_Array; Start : Natural; Count : Lane_Count_32x8; Value : U32x8)

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Partial

procedure Store_Partial (Data : in out U64_Array; Start : Natural; Count : Lane_Count_64x4; Value : U64x4)

Parameters

Data: The data input.
Start: The start input.
Count: The count input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out Byte_Array; Start : Natural; Value : U8x32)

Store one complete vector to an address with any alignment. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the selected 128-bit Store_Unaligned operation at Start and Start plus the private lane count. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out F32_Array; Start : Natural; Value : F32x8)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out F64_Array; Start : Natural; Value : F64x4)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out I16_Array; Start : Natural; Value : I16x16)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out I32_Array; Start : Natural; Value : I32x8)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out I64_Array; Start : Natural; Value : I64x4)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out I8_Array; Start : Natural; Value : I8x32)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out U16_Array; Start : Natural; Value : U16x16)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out U32_Array; Start : Natural; Value : U32x8)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Store_Unaligned

procedure Store_Unaligned (Data : in out U64_Array; Start : Natural; Value : U64x4)

Parameters

Data: The data input.
Start: The start input.
Value: The value input.

Subtract

function Subtract (Left, Right : F32x8) return F32x8

Apply Subtract independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit vsubps operation and vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Subtract

function Subtract (Left, Right : F64x4) return F64x4

Apply Subtract independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend and the composed x86-64 backend run the selected 128-bit operation on both private parts. The optional AVX2 backend uses one isolated 256-bit vsubpd operation and vzeroupper. In a scalar build, the matching Wide.Native overload calls the portable Wide implementation.

Parameters

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

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I16x16) return I16x16

Apply Subtract_Saturate independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends call the selected 128-bit Subtract_Saturate operation for both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I8x32) return I8x32

Apply Subtract_Saturate independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Subtract_Saturate operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpsubsb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U8x32) return U8x32

Apply Subtract_Saturate independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Subtract_Saturate operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpsubusb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I16x16) return I16x16

Apply Subtract_Wrap independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends call the selected 128-bit Subtract_Wrap operation for both private parts. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I32x8) return I32x8

Parameters

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

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I64x4) return I64x4

Parameters

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

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I8x32) return I8x32

Apply Subtract_Wrap independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Subtract_Wrap operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpsubb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U16x16) return U16x16

Parameters

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

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U32x8) return U32x8

Parameters

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

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U64x4) return U64x4

Parameters

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

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U8x32) return U8x32

Apply Subtract_Wrap independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and composed x86-64 backends call the selected 128-bit Subtract_Wrap operation for both private parts. The optional AVX2 backend calls an isolated 256-bit vpsubb leaf and then runs vzeroupper. In a scalar build, the matching Wide.Native overload uses the same two-part composition through the portable 128-bit implementation.

Parameters

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

Return value

The operation result.

Table_Lookup

function Table_Lookup (Table, Indices : U8x32) return U8x32

Select each result byte from the corresponding unsigned index. Indexes from 0 through 31 select that table lane; larger indexes produce zero. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 backend uses one two-register NEON tbl operation for each result half. The composed x86-64 backend constructs one 16-filled vector with selected Splat. It uses four selected 128-bit Table_Lookup operations, two selected Subtract_Wrap operations, and two selected Bitwise_Or operations. The optional AVX2 backend uses a dedicated U8x32 implementation. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Table: The table input.
Indices: The indices input.

Return value

The operation result.

Test

function Test (Mask : Mask_16x16; Lane : Lane_Index_16x16) return Boolean

Return one mask truth. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit Test operation only to the private part that contains the requested lane. They subtract the private lane count for a lane in the high part. In a scalar build, the matching Wide.Native overload uses the same selected-part composition through the portable 128-bit implementation.

Parameters

Mask: The mask input.
Lane: The lane input.

Return value

The operation result.

Test

function Test (Mask : Mask_32x8; Lane : Lane_Index_32x8) return Boolean

Parameters

Mask: The mask input.
Lane: The lane input.

Return value

The operation result.

Test

function Test (Mask : Mask_64x4; Lane : Lane_Index_64x4) return Boolean

Parameters

Mask: The mask input.
Lane: The lane input.

Return value

The operation result.

Test

function Test (Mask : Mask_8x32; Lane : Lane_Index_8x32) return Boolean

Parameters

Mask: The mask input.
Lane: The lane input.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_16x16) return Mask_Bits_16x16

Return compact lane truths. Bit zero represents lane zero. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64, composed x86-64, and optional AVX2 backends apply the selected 128-bit To_Bit_Mask operation to both private parts. They place the low-part bits first and shift the high-part bits by the private lane count. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Mask: The mask input.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_32x8) return Mask_Bits_32x8

Parameters

Mask: The mask input.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_64x4) return Mask_Bits_64x4

Parameters

Mask: The mask input.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_8x32) return Mask_Bits_8x32

Parameters

Mask: The mask input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : F32x8) return Lane_Values_F32x8

Return all lanes in logical lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends call the matching selected 128-bit To_Lanes operation for both private parts. They concatenate the low-part lanes followed by the high-part lanes in logical order. In a scalar build, the matching Wide.Native overload uses the same composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : F64x4) return Lane_Values_F64x4

Parameters

Value: The value input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I16x16) return Lane_Values_I16x16

Parameters

Value: The value input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I32x8) return Lane_Values_I32x8

Parameters

Value: The value input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I64x4) return Lane_Values_I64x4

Parameters

Value: The value input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I8x32) return Lane_Values_I8x32

Parameters

Value: The value input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U16x16) return Lane_Values_U16x16

Parameters

Value: The value input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U32x8) return Lane_Values_U32x8

Parameters

Value: The value input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U64x4) return Lane_Values_U64x4

Parameters

Value: The value input.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U8x32) return Lane_Values_U8x32

Parameters

Value: The value input.

Return value

The operation result.

Two_Source_Lane_Map_16x16

type Two_Source_Lane_Map_16x16 is private;

A private, reusable result-lane to two-source-lane map.

Two_Source_Lane_Map_32x8

type Two_Source_Lane_Map_32x8 is private;

A private, reusable result-lane to two-source-lane map.

Two_Source_Lane_Map_64x4

type Two_Source_Lane_Map_64x4 is private;

A private, reusable result-lane to two-source-lane map.

Two_Source_Lane_Map_8x32

type Two_Source_Lane_Map_8x32 is private;

A private, reusable result-lane to two-source-lane map.

Two_Source_Lane_Selector_16x16

type Two_Source_Lane_Selector_16x16 is private;

Select one lane from the left or right source vector.

Two_Source_Lane_Selector_32x8

type Two_Source_Lane_Selector_32x8 is private;

Select one lane from the left or right source vector.

Two_Source_Lane_Selector_64x4

type Two_Source_Lane_Selector_64x4 is private;

Select one lane from the left or right source vector.

Two_Source_Lane_Selector_8x32

type Two_Source_Lane_Selector_8x32 is private;

Select one lane from the left or right source vector.

Two_Source_Lane_Selectors_16x16

type Two_Source_Lane_Selectors_16x16 is array (Lane_Index_16x16) of Two_Source_Lane_Selector_16x16;

One two-source selector for each result lane.

Two_Source_Lane_Selectors_32x8

type Two_Source_Lane_Selectors_32x8 is array (Lane_Index_32x8) of Two_Source_Lane_Selector_32x8;

One two-source selector for each result lane.

Two_Source_Lane_Selectors_64x4

type Two_Source_Lane_Selectors_64x4 is array (Lane_Index_64x4) of Two_Source_Lane_Selector_64x4;

One two-source selector for each result lane.

Two_Source_Lane_Selectors_8x32

type Two_Source_Lane_Selectors_8x32 is array (Lane_Index_8x32) of Two_Source_Lane_Selector_8x32;

One two-source selector for each result lane.

U16x16

type U16x16 is private;

A private 256-bit vector containing 16 U16 lanes.

U32x8

type U32x8 is private;

A private 256-bit vector containing 8 U32 lanes.

U64x4

type U64x4 is private;

A private 256-bit vector containing 4 U64 lanes.

U8x32

type U8x32 is private;

A private 256-bit vector containing 32 U8 lanes.

Unordered

function Unordered (Left, Right : F32x8) return Mask_32x8

Apply Unordered independently to corresponding lanes. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends run the selected 128-bit Unordered operation on both private parts. A scalar build uses the portable Wide implementation.

Parameters

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

Return value

The operation result.

Unordered

function Unordered (Left, Right : F64x4) return Mask_64x4

Parameters

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

Return value

The operation result.

Widen_High

function Widen_High (Value : F32x8) return F64x4

With the platform's default gradual-underflow environment, widen the high binary32 source half exactly to binary64 and preserve lane order. 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 overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends select the high private source part. The selected 128-bit Widen_Low operation forms the low result part, and the selected 128-bit Widen_High operation forms the high result part. In a scalar build, the overload uses the same composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Widen_High

function Widen_High (Value : I16x16) return I32x8

Widen the high integer source half exactly, preserve signedness, and preserve lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends select the high private source part. The selected 128-bit Widen_Low operation forms the low result part, and the selected 128-bit Widen_High operation forms the high result part. In a scalar build, the overload uses the same composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Widen_High

function Widen_High (Value : I32x8) return I64x4

Parameters

Value: The value input.

Return value

The operation result.

Widen_High

function Widen_High (Value : I8x32) return I16x16

Parameters

Value: The value input.

Return value

The operation result.

Widen_High

function Widen_High (Value : U16x16) return U32x8

Parameters

Value: The value input.

Return value

The operation result.

Widen_High

function Widen_High (Value : U32x8) return U64x4

Parameters

Value: The value input.

Return value

The operation result.

Widen_High

function Widen_High (Value : U8x32) return U16x16

Parameters

Value: The value input.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : F32x8) return F64x4

With the platform's default gradual-underflow environment, widen the low binary32 source half exactly to binary64 and preserve lane order. 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 overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends select the low private source part. The selected 128-bit Widen_Low operation forms the low result part, and the selected 128-bit Widen_High operation forms the high result part. In a scalar build, the overload uses the same composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : I16x16) return I32x8

Widen the low integer source half exactly, preserve signedness, and preserve lane order. Cross-platform support: This overload uses the portable scalar Wide implementation on every supported GNAT target. For the matching Wide.Native overload, the AArch64 and x86-64 backends select the low private source part. The selected 128-bit Widen_Low operation forms the low result part, and the selected 128-bit Widen_High operation forms the high result part. In a scalar build, the overload uses the same composition through the portable 128-bit implementation.

Parameters

Value: The value input.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : I32x8) return I64x4

Parameters

Value: The value input.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : I8x32) return I16x16

Parameters

Value: The value input.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : U16x16) return U32x8

Parameters

Value: The value input.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : U32x8) return U64x4

Parameters

Value: The value input.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : U8x32) return U16x16

Parameters

Value: The value input.

Return value

The operation result.

Zero

function Zero return F32x8

function Zero return U8x32

Return value

The operation result.