# Class Simd

java.lang.Object
com.codename1.util.Simd

public class Simd extends Object
Portable SIMD API with Java fallback implementations.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `Simd()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `abs(byte[] src, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `abs(float[] src, float[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `abs(int[] src, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `add(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `add(float[] srcA, float[] srcB, float[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `add(int[] srcA, int[] srcB, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `add(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `addWrapping(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `addWrapping(byte[] src, byte value, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `byte[]`
  `allocaByte(int size)`
  `byte[]`
  `allocaByteFilled(int size, byte value)`
  Special scratch-allocation API that guarantees every byte starts with the same value while retaining the same method-local constraints as `allocaByte(int)`.
  `byte[]`
  `allocaByteZeroed(int size)`
  Special scratch-allocation API that guarantees a zero-initialized byte array while retaining the same method-local constraints as `allocaByte(int)`.
  `float[]`
  `allocaFloat(int size)`
  `float[]`
  `allocaFloatFilled(int size, float value)`
  Special scratch-allocation API that guarantees every float starts with the same value while retaining the same method-local constraints as `allocaFloat(int)`.
  `float[]`
  `allocaFloatZeroed(int size)`
  Special scratch-allocation API that guarantees a zero-initialized float array while retaining the same method-local constraints as `allocaFloat(int)`.
  `int[]`
  `allocaInt(int size)`
  `int[]`
  `allocaIntFilled(int size, int value)`
  Special scratch-allocation API that guarantees every int starts with the same value while retaining the same method-local constraints as `allocaInt(int)`.
  `int[]`
  `allocaIntZeroed(int size)`
  Special scratch-allocation API that guarantees a zero-initialized int array while retaining the same method-local constraints as `allocaInt(int)`.
  `byte[]`
  `allocByte(int size)`
  Allocates an aligned memory block for efficient SIMD operations.
  `float[]`
  `allocFloat(int size)`
  Allocates an aligned memory block for efficient SIMD operations.
  `int[]`
  `allocInt(int size)`
  Allocates an aligned memory block for efficient SIMD operations.
  `void`
  `and(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `and(byte[] srcA, int srcAOffset, byte[] srcB, int srcBOffset, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `and(int[] srcA, int[] srcB, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `and(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `and(int[] src, int srcOffset, int constant, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `blendByMaskTestNonzero(int[] src, int srcOffset, int testMask, int trueKeepMask, int trueOrValue, int[] dst, int dstOffset, int length)`
  Fused single-pass conditional bit-blend driven by a masked-non-zero test of `src` against `testMask`.
  `void`
  `blendByMaskTestNonzeroSubstituteOnKeepEq(int[] src, int srcOffset, int testMask, int trueKeepMask, int trueOrValue, int removeMatch, int removeValue, int[] dst, int dstOffset, int length)`
  Fused single-pass extension of `blendByMaskTestNonzero` that additionally substitutes `removeValue` whenever the post-mask result would equal `removeMatch`.
  `void`
  `clamp(byte[] src, byte[] dst, byte minValue, byte maxValue, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `clamp(float[] src, float[] dst, float minValue, float maxValue, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `clamp(int[] src, int[] dst, int minValue, int maxValue, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpEq(byte[] srcA, byte[] srcB, byte[] dstMask, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpEq(byte[] src, byte value, byte[] dstMask, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpEq(int[] srcA, int[] srcB, byte[] dstMask, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpEq(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, byte[] dstMask, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpEq(int[] src, int srcOffset, int constant, byte[] dstMask, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpGt(byte[] srcA, byte[] srcB, byte[] dstMask, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpGt(int[] srcA, int[] srcB, byte[] dstMask, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpGt(int[] src, int srcOffset, int constant, byte[] dstMask, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpLt(byte[] srcA, byte[] srcB, byte[] dstMask, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpLt(byte[] src, byte value, byte[] dstMask, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpLt(int[] srcA, int[] srcB, byte[] dstMask, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpLt(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, byte[] dstMask, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpLt(int[] src, int srcOffset, int constant, byte[] dstMask, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `cmpRange(byte[] src, byte minValue, byte maxValue, byte[] dstMask, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `float`
  `dot(float[] srcA, float[] srcB, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `int`
  `dot(int[] srcA, int[] srcB, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `static Simd`
  `get()`
  Returns the singleton instance of the Simd class.
  `boolean`
  `isByteShuffleAccelerated()`
  Returns true when chained, fine-grained byte shuffle/interleave pipelines (as the Base64 SIMD codec uses: unpack/pack interleaved, byte shifts, table lookups) are hardware-accelerated AND actually beat the compiler's autovectorized scalar code.
  `boolean`
  `isSupported()`
  Returns true if SIMD instructions are natively supported if this returns false the APIs in this class would still work using fallback loop code
  `void`
  `lookupBytes(byte[] table, byte[] indices, byte[] dst, int offset, int length)`
  Looks up values from a table using unsigned byte indices.
  `void`
  `lookupBytes(byte[] table, byte[] indices, int indicesOffset, byte[] dst, int dstOffset, int length)`
  Looks up values from a table using unsigned byte indices.
  `void`
  `max(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `max(float[] srcA, float[] srcB, float[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `max(int[] srcA, int[] srcB, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `min(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `min(float[] srcA, float[] srcB, float[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `min(int[] srcA, int[] srcB, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `mul(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `mul(float[] srcA, float[] srcB, float[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `mul(int[] srcA, int[] srcB, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `not(byte[] src, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `not(byte[] src, int srcOffset, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `not(int[] src, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `or(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `or(byte[] srcA, int srcAOffset, byte[] srcB, int srcBOffset, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `or(int[] srcA, int[] srcB, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `or(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `or(int[] src, int srcOffset, int constant, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `packBytesInterleaved3(byte[] src0, byte[] src1, byte[] src2, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `packBytesInterleaved3(byte[] src, int src0Offset, int src1Offset, int src2Offset, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `packBytesInterleaved4(byte[] src0, byte[] src1, byte[] src2, byte[] src3, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `packBytesInterleaved4(byte[] src, int src0Offset, int src1Offset, int src2Offset, int src3Offset, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `packIntToByteSaturating(int[] src, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `packIntToByteTruncate(int[] src, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `packIntToByteTruncate(int[] src, int srcOffset, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `packIntToByteTruncateInterleaved4(int[] src, int src0Offset, int src1Offset, int src2Offset, int src3Offset, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `permuteBytes(byte[] src, byte[] indices, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `replaceTopByteFromUnsignedBytes(int[] rgbSrc, int rgbSrcOffset, byte[] alphaSrc, int alphaSrcOffset, int[] dst, int dstOffset, int length)`
  Fused single-pass replacement of the top byte of every int in `rgbSrc` with the corresponding unsigned byte from `alphaSrc`.
  `void`
  `select(byte[] mask, byte[] trueValues, byte[] falseValues, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `select(byte[] mask, int[] trueValues, int[] falseValues, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `select(byte[] mask, int maskOffset, int[] trueValues, int trueOffset, int[] falseValues, int falseOffset, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `select(byte[] mask, int maskOffset, int[] trueValues, int trueOffset, int falseConstant, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `select(byte[] mask, int maskOffset, int trueConstant, int[] falseValues, int falseOffset, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `select(byte[] mask, int maskOffset, int trueConstant, int falseConstant, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `shl(byte[] src, int bits, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `shl(byte[] src, int srcOffset, int bits, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `shl(int[] src, int bits, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `shl(int[] src, int srcOffset, int bits, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `shrArithmetic(int[] src, int bits, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `shrLogical(byte[] src, int bits, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `shrLogical(byte[] src, int srcOffset, int bits, byte[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `shrLogical(int[] src, int bits, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `shrLogical(int[] src, int srcOffset, int bits, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `sub(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `sub(float[] srcA, float[] srcB, float[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `sub(int[] srcA, int[] srcB, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `subWrapping(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `subWrapping(byte[] src, byte value, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `float`
  `sum(float[] src, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `int`
  `sum(int[] src, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `unpackBytesInterleaved3(byte[] src, int srcOffset, byte[] dst0, byte[] dst1, byte[] dst2, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `unpackBytesInterleaved3(byte[] src, int srcOffset, byte[] dst, int dst0Offset, int dst1Offset, int dst2Offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `unpackBytesInterleaved4(byte[] src, int srcOffset, byte[] dst0, byte[] dst1, byte[] dst2, byte[] dst3, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `unpackBytesInterleaved4(byte[] src, int srcOffset, byte[] dst, int dst0Offset, int dst1Offset, int dst2Offset, int dst3Offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `int`
  `unpackLookupBytesInterleaved4(byte[] table, byte[] src, int srcOffset, byte[] dst0, byte[] dst1, byte[] dst2, byte[] dst3, int length)`
  Unpacks interleaved bytes, looks each byte up in the provided table, stores the looked-up values into separate lane arrays, and returns the bitwise OR of all written values.
  `int`
  `unpackLookupBytesInterleaved4(byte[] table, byte[] src, int srcOffset, byte[] dst, int dst0Offset, int dst1Offset, int dst2Offset, int dst3Offset, int length)`
  Unpacks interleaved bytes, looks each byte up in the provided table, stores the looked-up values into virtual lane ranges in a destination array, and returns the bitwise OR of all written values.
  `void`
  `unpackUnsignedByteToInt(byte[] src, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `unpackUnsignedByteToInt(byte[] src, int srcOffset, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `unpackUnsignedByteToIntInterleaved3(byte[] src, int srcOffset, int[] dst, int dst0Offset, int dst1Offset, int dst2Offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `protected final void`
  `validateBinaryByte(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateBinaryFloat(float[] srcA, float[] srcB, float[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateBinaryInt(int[] srcA, int[] srcB, int[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateByteToInt(byte[] src, int[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateDotFloat(float[] srcA, float[] srcB, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateDotInt(int[] srcA, int[] srcB, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateIntToByte(int[] src, byte[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateMaskBinaryByte(byte[] srcA, byte[] srcB, byte[] dstMask, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateMaskBinaryInt(int[] srcA, int[] srcB, byte[] dstMask, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateNotNull(Object o, String name)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validatePermuteByte(byte[] src, byte[] indices, byte[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateRange(int arrayLength, int offset, int length, String name)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateRangeMaskByte(byte[] src, byte[] dstMask, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateReductionFloat(float[] src, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateReductionInt(int[] src, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateSelectByte(byte[] mask, byte[] trueValues, byte[] falseValues, byte[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateSelectInt(byte[] mask, int[] trueValues, int[] falseValues, int[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateUnaryByte(byte[] src, byte[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateUnaryFloat(float[] src, float[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `protected final void`
  `validateUnaryInt(int[] src, int[] dst, int offset, int length)`
  This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.
  `void`
  `xor(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `xor(int[] srcA, int[] srcB, int[] dst, int offset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays
  `void`
  `xor(int[] src, int srcOffset, int constant, int[] dst, int dstOffset, int length)`
  Exposes SIMD APIs directly all arrays MUST be aligned arrays

  ### Methods inherited from class Object

  `clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### Simd

    public Simd()

- ## Method Details

  - ### get

    public static Simd get()
    Returns the singleton instance of the Simd class. Equivalent to `CN.getSimd();`

  - ### isSupported

    public boolean isSupported()
    Returns true if SIMD instructions are natively supported if this returns false the APIs in this class would still work using fallback loop code

  - ### isByteShuffleAccelerated

    public boolean isByteShuffleAccelerated()
    Returns true when chained, fine-grained byte shuffle/interleave pipelines (as the Base64 SIMD codec uses: unpack/pack interleaved, byte shifts, table lookups) are hardware-accelerated AND actually beat the compiler's autovectorized scalar code. NEON platforms (iOS, Windows-on-Arm) return true -- there the explicit codec is dramatically faster even at -O2. x86-64 returns false: its `/O2` autovectorizer already matches the scalar path and SSE2 has no 3-way interleave, so the codec should stay scalar there. This is distinct from `isSupported()` -- the fused whole-array image ops (alpha/mask blends) win on every platform and are gated on isSupported(), not on this flag. Defaults to false (the generic scalar Simd).

  - ### allocByte

    public byte[] allocByte(int size)
    Allocates an aligned memory block for efficient SIMD operations. All operations MUST be performed on aligned arrays and shouldn't use arrays created with `new`. Operations on unaligned arrays might produce undefined results.

  - ### allocInt

    public int[] allocInt(int size)
    Allocates an aligned memory block for efficient SIMD operations. All operations MUST be performed on aligned arrays and shouldn't use arrays created with `new`. Operations on unaligned arrays might produce undefined results.

  - ### allocFloat

    public float[] allocFloat(int size)
    Allocates an aligned memory block for efficient SIMD operations. All operations MUST be performed on aligned arrays and shouldn't use arrays created with `new`. Operations on unaligned arrays might produce undefined results.

  - ### allocaByte

    public byte[] allocaByte(int size)

  - ### allocaInt

    public int[] allocaInt(int size)

  - ### allocaFloat

    public float[] allocaFloat(int size)

  - ### allocaByteZeroed

    public byte[] allocaByteZeroed(int size)
    Special scratch-allocation API that guarantees a zero-initialized byte array while retaining the same method-local constraints as `allocaByte(int)`.

  - ### allocaIntZeroed

    public int[] allocaIntZeroed(int size)
    Special scratch-allocation API that guarantees a zero-initialized int array while retaining the same method-local constraints as `allocaInt(int)`.

  - ### allocaFloatZeroed

    public float[] allocaFloatZeroed(int size)
    Special scratch-allocation API that guarantees a zero-initialized float array while retaining the same method-local constraints as `allocaFloat(int)`.

  - ### allocaByteFilled

    public byte[] allocaByteFilled(int size, byte value)
    Special scratch-allocation API that guarantees every byte starts with the same value while retaining the same method-local constraints as `allocaByte(int)`.

  - ### allocaIntFilled

    public int[] allocaIntFilled(int size, int value)
    Special scratch-allocation API that guarantees every int starts with the same value while retaining the same method-local constraints as `allocaInt(int)`.

  - ### allocaFloatFilled

    public float[] allocaFloatFilled(int size, float value)
    Special scratch-allocation API that guarantees every float starts with the same value while retaining the same method-local constraints as `allocaFloat(int)`.

  - ### lookupBytes

    public void lookupBytes(byte[] table, byte[] indices, byte[] dst, int offset, int length)
    Looks up values from a table using unsigned byte indices.

  - ### lookupBytes

    public void lookupBytes(byte[] table, byte[] indices, int indicesOffset, byte[] dst, int dstOffset, int length)
    Looks up values from a table using unsigned byte indices.

  - ### and

    public void and(byte[] srcA, int srcAOffset, byte[] srcB, int srcBOffset, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### or

    public void or(byte[] srcA, int srcAOffset, byte[] srcB, int srcBOffset, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### shl

    public void shl(byte[] src, int srcOffset, int bits, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### shrLogical

    public void shrLogical(byte[] src, int srcOffset, int bits, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### unpackBytesInterleaved3

    public void unpackBytesInterleaved3(byte[] src, int srcOffset, byte[] dst, int dst0Offset, int dst1Offset, int dst2Offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### add

    public void add(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### sub

    public void sub(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### mul

    public void mul(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### min

    public void min(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### max

    public void max(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### abs

    public void abs(byte[] src, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### clamp

    public void clamp(byte[] src, byte[] dst, byte minValue, byte maxValue, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### and

    public void and(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### or

    public void or(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### xor

    public void xor(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### not

    public void not(byte[] src, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpEq

    public void cmpEq(byte[] srcA, byte[] srcB, byte[] dstMask, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpEq

    public void cmpEq(byte[] src, byte value, byte[] dstMask, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpLt

    public void cmpLt(byte[] srcA, byte[] srcB, byte[] dstMask, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpLt

    public void cmpLt(byte[] src, byte value, byte[] dstMask, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpGt

    public void cmpGt(byte[] srcA, byte[] srcB, byte[] dstMask, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpRange

    public void cmpRange(byte[] src, byte minValue, byte maxValue, byte[] dstMask, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### select

    public void select(byte[] mask, byte[] trueValues, byte[] falseValues, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### shl

    public void shl(byte[] src, int bits, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### shrLogical

    public void shrLogical(byte[] src, int bits, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### addWrapping

    public void addWrapping(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### addWrapping

    public void addWrapping(byte[] src, byte value, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### subWrapping

    public void subWrapping(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### subWrapping

    public void subWrapping(byte[] src, byte value, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### unpackUnsignedByteToInt

    public void unpackUnsignedByteToInt(byte[] src, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### unpackUnsignedByteToInt

    public void unpackUnsignedByteToInt(byte[] src, int srcOffset, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### unpackUnsignedByteToIntInterleaved3

    public void unpackUnsignedByteToIntInterleaved3(byte[] src, int srcOffset, int[] dst, int dst0Offset, int dst1Offset, int dst2Offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### unpackBytesInterleaved3

    public void unpackBytesInterleaved3(byte[] src, int srcOffset, byte[] dst0, byte[] dst1, byte[] dst2, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### unpackBytesInterleaved4

    public void unpackBytesInterleaved4(byte[] src, int srcOffset, byte[] dst0, byte[] dst1, byte[] dst2, byte[] dst3, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### unpackBytesInterleaved4

    public void unpackBytesInterleaved4(byte[] src, int srcOffset, byte[] dst, int dst0Offset, int dst1Offset, int dst2Offset, int dst3Offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### unpackLookupBytesInterleaved4

    public int unpackLookupBytesInterleaved4(byte[] table, byte[] src, int srcOffset, byte[] dst0, byte[] dst1, byte[] dst2, byte[] dst3, int length)
    Unpacks interleaved bytes, looks each byte up in the provided table, stores the looked-up values into separate lane arrays, and returns the bitwise OR of all written values.

  - ### unpackLookupBytesInterleaved4

    public int unpackLookupBytesInterleaved4(byte[] table, byte[] src, int srcOffset, byte[] dst, int dst0Offset, int dst1Offset, int dst2Offset, int dst3Offset, int length)
    Unpacks interleaved bytes, looks each byte up in the provided table, stores the looked-up values into virtual lane ranges in a destination array, and returns the bitwise OR of all written values.

  - ### packIntToByteSaturating

    public void packIntToByteSaturating(int[] src, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### packIntToByteTruncate

    public void packIntToByteTruncate(int[] src, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### packIntToByteTruncate

    public void packIntToByteTruncate(int[] src, int srcOffset, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### packIntToByteTruncateInterleaved4

    public void packIntToByteTruncateInterleaved4(int[] src, int src0Offset, int src1Offset, int src2Offset, int src3Offset, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### packBytesInterleaved3

    public void packBytesInterleaved3(byte[] src0, byte[] src1, byte[] src2, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### packBytesInterleaved3

    public void packBytesInterleaved3(byte[] src, int src0Offset, int src1Offset, int src2Offset, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### packBytesInterleaved4

    public void packBytesInterleaved4(byte[] src0, byte[] src1, byte[] src2, byte[] src3, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### packBytesInterleaved4

    public void packBytesInterleaved4(byte[] src, int src0Offset, int src1Offset, int src2Offset, int src3Offset, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### permuteBytes

    public void permuteBytes(byte[] src, byte[] indices, byte[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### add

    public void add(int[] srcA, int[] srcB, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### add

    public void add(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### sub

    public void sub(int[] srcA, int[] srcB, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### mul

    public void mul(int[] srcA, int[] srcB, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### min

    public void min(int[] srcA, int[] srcB, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### max

    public void max(int[] srcA, int[] srcB, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### abs

    public void abs(int[] src, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### clamp

    public void clamp(int[] src, int[] dst, int minValue, int maxValue, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### and

    public void and(int[] srcA, int[] srcB, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### and

    public void and(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### or

    public void or(int[] srcA, int[] srcB, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### or

    public void or(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### xor

    public void xor(int[] srcA, int[] srcB, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### not

    public void not(int[] src, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### shl

    public void shl(int[] src, int bits, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### shl

    public void shl(int[] src, int srcOffset, int bits, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### shrLogical

    public void shrLogical(int[] src, int bits, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### shrLogical

    public void shrLogical(int[] src, int srcOffset, int bits, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### shrArithmetic

    public void shrArithmetic(int[] src, int bits, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpEq

    public void cmpEq(int[] srcA, int[] srcB, byte[] dstMask, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpEq

    public void cmpEq(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, byte[] dstMask, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpLt

    public void cmpLt(int[] srcA, int[] srcB, byte[] dstMask, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpLt

    public void cmpLt(int[] srcA, int srcAOffset, int[] srcB, int srcBOffset, byte[] dstMask, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpGt

    public void cmpGt(int[] srcA, int[] srcB, byte[] dstMask, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### select

    public void select(byte[] mask, int[] trueValues, int[] falseValues, int[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### select

    public void select(byte[] mask, int maskOffset, int[] trueValues, int trueOffset, int[] falseValues, int falseOffset, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### sum

    public int sum(int[] src, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### dot

    public int dot(int[] srcA, int[] srcB, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### add

    public void add(float[] srcA, float[] srcB, float[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### sub

    public void sub(float[] srcA, float[] srcB, float[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### mul

    public void mul(float[] srcA, float[] srcB, float[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### min

    public void min(float[] srcA, float[] srcB, float[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### max

    public void max(float[] srcA, float[] srcB, float[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### abs

    public void abs(float[] src, float[] dst, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### clamp

    public void clamp(float[] src, float[] dst, float minValue, float maxValue, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### sum

    public float sum(float[] src, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### dot

    public float dot(float[] srcA, float[] srcB, int offset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### and

    public void and(int[] src, int srcOffset, int constant, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### or

    public void or(int[] src, int srcOffset, int constant, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### xor

    public void xor(int[] src, int srcOffset, int constant, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpEq

    public void cmpEq(int[] src, int srcOffset, int constant, byte[] dstMask, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpLt

    public void cmpLt(int[] src, int srcOffset, int constant, byte[] dstMask, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### cmpGt

    public void cmpGt(int[] src, int srcOffset, int constant, byte[] dstMask, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### not

    public void not(byte[] src, int srcOffset, byte[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### select

    public void select(byte[] mask, int maskOffset, int trueConstant, int falseConstant, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### select

    public void select(byte[] mask, int maskOffset, int[] trueValues, int trueOffset, int falseConstant, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### select

    public void select(byte[] mask, int maskOffset, int trueConstant, int[] falseValues, int falseOffset, int[] dst, int dstOffset, int length)
    Exposes SIMD APIs directly all arrays MUST be aligned arrays

  - ### blendByMaskTestNonzero

    public void blendByMaskTestNonzero(int[] src, int srcOffset, int testMask, int trueKeepMask, int trueOrValue, int[] dst, int dstOffset, int length)

    Fused single-pass conditional bit-blend driven by a masked-non-zero test of `src` against `testMask`. For every element:

    `dst[i] = (src[i] & testMask) != 0 ? (src[i] & trueKeepMask) | trueOrValue : src[i]`

    This collapses a "test-then-modify-or-keep-source" pattern that would otherwise require three or more separate primitive calls (and three or more passes over `src`) into a single pass. It maps directly to one NEON / SSE vector loop on platforms that ship a vectorized implementation. All arrays MUST be aligned/registered arrays.

  - ### blendByMaskTestNonzeroSubstituteOnKeepEq

    public void blendByMaskTestNonzeroSubstituteOnKeepEq(int[] src, int srcOffset, int testMask, int trueKeepMask, int trueOrValue, int removeMatch, int removeValue, int[] dst, int dstOffset, int length)

    Fused single-pass extension of `blendByMaskTestNonzero` that additionally substitutes `removeValue` whenever the post-mask result would equal `removeMatch`. For every element:

        v = src[i]
        if ((v & testMask) == 0)            dst[i] = v
        else if ((v & trueKeepMask) == removeMatch) dst[i] = removeValue
        else                                dst[i] = (v & trueKeepMask) | trueOrValue

    This collapses a `blendByMaskTestNonzero` + `cmpEq` + `select` chain (three passes over the buffer plus two scratch allocations) into a single vector pass. It maps to one NEON / SSE loop on platforms that ship a vectorized implementation. All arrays MUST be aligned / registered arrays.

  - ### replaceTopByteFromUnsignedBytes

    public void replaceTopByteFromUnsignedBytes(int[] rgbSrc, int rgbSrcOffset, byte[] alphaSrc, int alphaSrcOffset, int[] dst, int dstOffset, int length)

    Fused single-pass replacement of the top byte of every int in `rgbSrc` with the corresponding unsigned byte from `alphaSrc`. For every element:

    `dst[i] = (rgbSrc[i] & 0x00ffffff) | ((alphaSrc[i] & 0xff) << 24)`

    Designed for the `Image.applyMask` hot path, which previously required four separate primitive calls (`unpackUnsignedByteToInt`, `shl`, `and`, `or`) and two scratch allocations. Maps to a single NEON / SSE vector loop (`vmovl_u8` => `vshlq_n_u32(24)` => `vorrq(vandq, ...)`) on platforms that ship a vectorized implementation. All arrays MUST be aligned / registered arrays.

  - ### validateBinaryByte

    protected final void validateBinaryByte(byte[] srcA, byte[] srcB, byte[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateMaskBinaryByte

    protected final void validateMaskBinaryByte(byte[] srcA, byte[] srcB, byte[] dstMask, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateRangeMaskByte

    protected final void validateRangeMaskByte(byte[] src, byte[] dstMask, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateSelectByte

    protected final void validateSelectByte(byte[] mask, byte[] trueValues, byte[] falseValues, byte[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateByteToInt

    protected final void validateByteToInt(byte[] src, int[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateIntToByte

    protected final void validateIntToByte(int[] src, byte[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validatePermuteByte

    protected final void validatePermuteByte(byte[] src, byte[] indices, byte[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateUnaryByte

    protected final void validateUnaryByte(byte[] src, byte[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateBinaryInt

    protected final void validateBinaryInt(int[] srcA, int[] srcB, int[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateUnaryInt

    protected final void validateUnaryInt(int[] src, int[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateMaskBinaryInt

    protected final void validateMaskBinaryInt(int[] srcA, int[] srcB, byte[] dstMask, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateSelectInt

    protected final void validateSelectInt(byte[] mask, int[] trueValues, int[] falseValues, int[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateReductionInt

    protected final void validateReductionInt(int[] src, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateDotInt

    protected final void validateDotInt(int[] srcA, int[] srcB, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateBinaryFloat

    protected final void validateBinaryFloat(float[] srcA, float[] srcB, float[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateUnaryFloat

    protected final void validateUnaryFloat(float[] src, float[] dst, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateReductionFloat

    protected final void validateReductionFloat(float[] src, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateDotFloat

    protected final void validateDotFloat(float[] srcA, float[] srcB, int offset, int length)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateNotNull

    protected final void validateNotNull(Object o, String name)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.

  - ### validateRange

    protected final void validateRange(int arrayLength, int offset, int length, String name)
    This API is used internally to verify valid array arguments in the simulator notice that no validation occurs on the devices.