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	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

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.