Yeppp!
 All Classes Functions Variables Pages
List of all members
Core Class Reference

Basic arithmetic operations. More...

Static Public Member Functions

Addition
static native void Add_V8sV8s_V8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, byte[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 8-bit integer elements. More...
 
static native void Add_V8sV8s_V16s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, short[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 16-bit integer elements. More...
 
static native void Add_V8uV8u_V16u (byte[] xArray, int xOffset, byte[] yArray, int yOffset, short[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two unsigned 8-bit integer arrays. Produces an array of unsigned 16-bit integer elements. More...
 
static native void Add_V16sV16s_V16s (short[] xArray, int xOffset, short[] yArray, int yOffset, short[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 16-bit integer elements. More...
 
static native void Add_V16sV16s_V32s (short[] xArray, int xOffset, short[] yArray, int yOffset, int[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 32-bit integer elements. More...
 
static native void Add_V16uV16u_V32u (short[] xArray, int xOffset, short[] yArray, int yOffset, int[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two unsigned 16-bit integer arrays. Produces an array of unsigned 32-bit integer elements. More...
 
static native void Add_V32sV32s_V32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 32-bit integer elements. More...
 
static native void Add_V32sV32s_V64s (int[] xArray, int xOffset, int[] yArray, int yOffset, long[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 64-bit integer elements. More...
 
static native void Add_V32uV32u_V64u (int[] xArray, int xOffset, int[] yArray, int yOffset, long[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two unsigned 32-bit integer arrays. Produces an array of unsigned 64-bit integer elements. More...
 
static native void Add_V64sV64s_V64s (long[] xArray, int xOffset, long[] yArray, int yOffset, long[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two signed 64-bit integer arrays. Produces an array of signed 64-bit integer elements. More...
 
static native void Add_V32fV32f_V32f (float[] xArray, int xOffset, float[] yArray, int yOffset, float[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two single precision (32-bit) floating-point arrays. Produces an array of single precision (32-bit) floating-point elements. More...
 
static native void Add_V64fV64f_V64f (double[] xArray, int xOffset, double[] yArray, int yOffset, double[] sumArray, int sumOffset, int length)
 Adds corresponding elements in two double precision (64-bit) floating-point arrays. Produces an array of double precision (64-bit) floating-point elements. More...
 
static native void Add_V8sS8s_V8s (byte[] xArray, int xOffset, byte y, byte[] sumArray, int sumOffset, int length)
 Adds a constant to signed 8-bit integer array elements. Produces an array of signed 8-bit integer elements. More...
 
static native void Add_V8sS8s_V16s (byte[] xArray, int xOffset, byte y, short[] sumArray, int sumOffset, int length)
 Adds a constant to signed 8-bit integer array elements. Produces an array of signed 16-bit integer elements. More...
 
static native void Add_V8uS8u_V16u (byte[] xArray, int xOffset, byte y, short[] sumArray, int sumOffset, int length)
 Adds a constant to unsigned 8-bit integer array elements. Produces an array of unsigned 16-bit integer elements. More...
 
static native void Add_V16sS16s_V16s (short[] xArray, int xOffset, short y, short[] sumArray, int sumOffset, int length)
 Adds a constant to signed 16-bit integer array elements. Produces an array of signed 16-bit integer elements. More...
 
static native void Add_V16sS16s_V32s (short[] xArray, int xOffset, short y, int[] sumArray, int sumOffset, int length)
 Adds a constant to signed 16-bit integer array elements. Produces an array of signed 32-bit integer elements. More...
 
static native void Add_V16uS16u_V32u (short[] xArray, int xOffset, short y, int[] sumArray, int sumOffset, int length)
 Adds a constant to unsigned 16-bit integer array elements. Produces an array of unsigned 32-bit integer elements. More...
 
static native void Add_V32sS32s_V32s (int[] xArray, int xOffset, int y, int[] sumArray, int sumOffset, int length)
 Adds a constant to signed 32-bit integer array elements. Produces an array of signed 32-bit integer elements. More...
 
static native void Add_V32uS32u_V64u (int[] xArray, int xOffset, int y, long[] sumArray, int sumOffset, int length)
 Adds a constant to unsigned 32-bit integer array elements. Produces an array of unsigned 64-bit integer elements. More...
 
static native void Add_V32sS32s_V64s (int[] xArray, int xOffset, int y, long[] sumArray, int sumOffset, int length)
 Adds a constant to signed 32-bit integer array elements. Produces an array of signed 64-bit integer elements. More...
 
static native void Add_V64sS64s_V64s (long[] xArray, int xOffset, long y, long[] sumArray, int sumOffset, int length)
 Adds a constant to signed 64-bit integer array elements. Produces an array of signed 64-bit integer elements. More...
 
static native void Add_V32fS32f_V32f (float[] xArray, int xOffset, float y, float[] sumArray, int sumOffset, int length)
 Adds a constant to single precision (32-bit) floating-point array elements. Produces an array of single precision (32-bit) floating-point elements. More...
 
static native void Add_V64fS64f_V64f (double[] xArray, int xOffset, double y, double[] sumArray, int sumOffset, int length)
 Adds a constant to double precision (64-bit) floating-point array elements. Produces an array of double precision (64-bit) floating-point elements. More...
 
static native void Add_IV8sV8s_IV8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, int length)
 Adds corresponding elements in two signed 8-bit integer arrays and writes the result to the first array. More...
 
static native void Add_IV16sV16s_IV16s (short[] xArray, int xOffset, short[] yArray, int yOffset, int length)
 Adds corresponding elements in two signed 16-bit integer arrays and writes the result to the first array. More...
 
static native void Add_IV32sV32s_IV32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Adds corresponding elements in two signed 32-bit integer arrays and writes the result to the first array. More...
 
static native void Add_IV64sV64s_IV64s (long[] xArray, int xOffset, long[] yArray, int yOffset, int length)
 Adds corresponding elements in two signed 64-bit integer arrays and writes the result to the first array. More...
 
static native void Add_IV32fV32f_IV32f (float[] xArray, int xOffset, float[] yArray, int yOffset, int length)
 Adds corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Add_IV64fV64f_IV64f (double[] xArray, int xOffset, double[] yArray, int yOffset, int length)
 Adds corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Add_IV8sS8s_IV8s (byte[] xArray, int xOffset, byte y, int length)
 Adds a constant to signed 8-bit integer array elements and writes the result to the same array. More...
 
static native void Add_IV16sS16s_IV16s (short[] xArray, int xOffset, short y, int length)
 Adds a constant to signed 16-bit integer array elements and writes the result to the same array. More...
 
static native void Add_IV32sS32s_IV32s (int[] xArray, int xOffset, int y, int length)
 Adds a constant to signed 32-bit integer array elements and writes the result to the same array. More...
 
static native void Add_IV64sS64s_IV64s (long[] xArray, int xOffset, long y, int length)
 Adds a constant to signed 64-bit integer array elements and writes the result to the same array. More...
 
static native void Add_IV32fS32f_IV32f (float[] xArray, int xOffset, float y, int length)
 Adds a constant to single precision (32-bit) floating-point array elements and writes the result to the same array. More...
 
static native void Add_IV64fS64f_IV64f (double[] xArray, int xOffset, double y, int length)
 Adds a constant to double precision (64-bit) floating-point array elements and writes the result to the same array. More...
 
Subtraction
static native void Subtract_V8sV8s_V8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, byte[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 8-bit integer elements. More...
 
static native void Subtract_V8sV8s_V16s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, short[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 16-bit integer elements. More...
 
static native void Subtract_V8uV8u_V16u (byte[] xArray, int xOffset, byte[] yArray, int yOffset, short[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two unsigned 8-bit integer arrays. Produces an array of unsigned 16-bit integer elements. More...
 
static native void Subtract_V16sV16s_V16s (short[] xArray, int xOffset, short[] yArray, int yOffset, short[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 16-bit integer elements. More...
 
static native void Subtract_V16sV16s_V32s (short[] xArray, int xOffset, short[] yArray, int yOffset, int[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 32-bit integer elements. More...
 
static native void Subtract_V16uV16u_V32u (short[] xArray, int xOffset, short[] yArray, int yOffset, int[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two unsigned 16-bit integer arrays. Produces an array of unsigned 32-bit integer elements. More...
 
static native void Subtract_V32sV32s_V32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 32-bit integer elements. More...
 
static native void Subtract_V32sV32s_V64s (int[] xArray, int xOffset, int[] yArray, int yOffset, long[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 64-bit integer elements. More...
 
static native void Subtract_V32uV32u_V64u (int[] xArray, int xOffset, int[] yArray, int yOffset, long[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two unsigned 32-bit integer arrays. Produces an array of unsigned 64-bit integer elements. More...
 
static native void Subtract_V64sV64s_V64s (long[] xArray, int xOffset, long[] yArray, int yOffset, long[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 64-bit integer arrays. Produces an array of signed 64-bit integer elements. More...
 
static native void Subtract_V32fV32f_V32f (float[] xArray, int xOffset, float[] yArray, int yOffset, float[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two single precision (32-bit) floating-point arrays. Produces an array of single precision (32-bit) floating-point elements. More...
 
static native void Subtract_V64fV64f_V64f (double[] xArray, int xOffset, double[] yArray, int yOffset, double[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two double precision (64-bit) floating-point arrays. Produces an array of double precision (64-bit) floating-point elements. More...
 
static native void Subtract_V8sS8s_V8s (byte[] xArray, int xOffset, byte y, byte[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 8-bit integer elements. More...
 
static native void Subtract_V8sS8s_V16s (byte[] xArray, int xOffset, byte y, short[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 16-bit integer elements. More...
 
static native void Subtract_V8uS8u_V16u (byte[] xArray, int xOffset, byte y, short[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two unsigned 8-bit integer arrays. Produces an array of unsigned 16-bit integer elements. More...
 
static native void Subtract_V16sS16s_V16s (short[] xArray, int xOffset, short y, short[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 16-bit integer elements. More...
 
static native void Subtract_V16sS16s_V32s (short[] xArray, int xOffset, short y, int[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 32-bit integer elements. More...
 
static native void Subtract_V16uS16u_V32u (short[] xArray, int xOffset, short y, int[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two unsigned 16-bit integer arrays. Produces an array of unsigned 32-bit integer elements. More...
 
static native void Subtract_V32sS32s_V32s (int[] xArray, int xOffset, int y, int[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 32-bit integer elements. More...
 
static native void Subtract_V32sS32s_V64s (int[] xArray, int xOffset, int y, long[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 64-bit integer elements. More...
 
static native void Subtract_V32uS32u_V64u (int[] xArray, int xOffset, int y, long[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two unsigned 32-bit integer arrays. Produces an array of unsigned 64-bit integer elements. More...
 
static native void Subtract_V64sS64s_V64s (long[] xArray, int xOffset, long y, long[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two signed 64-bit integer arrays. Produces an array of signed 64-bit integer elements. More...
 
static native void Subtract_V32fS32f_V32f (float[] xArray, int xOffset, float y, float[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two single precision (32-bit) floating-point arrays. Produces an array of single precision (32-bit) floating-point elements. More...
 
static native void Subtract_V64fS64f_V64f (double[] xArray, int xOffset, double y, double[] diffArray, int diffOffset, int length)
 Subtracts corresponding elements in two double precision (64-bit) floating-point arrays. Produces an array of double precision (64-bit) floating-point elements. More...
 
static native void Subtract_S8sV8s_V8s (byte x, byte[] yArray, int yOffset, byte[] diffArray, int diffOffset, int length)
 Subtracts signed 8-bit integer array elements from a constant. Produces an array of signed 8-bit integer elements. More...
 
static native void Subtract_S8sV8s_V16s (byte x, byte[] yArray, int yOffset, short[] diffArray, int diffOffset, int length)
 Subtracts signed 8-bit integer array elements from a constant. Produces an array of signed 16-bit integer elements. More...
 
static native void Subtract_S8uV8u_V16u (byte x, byte[] yArray, int yOffset, short[] diffArray, int diffOffset, int length)
 Subtracts unsigned 8-bit integer array elements from a constant. Produces an array of unsigned 16-bit integer elements. More...
 
static native void Subtract_S16sV16s_V16s (short x, short[] yArray, int yOffset, short[] diffArray, int diffOffset, int length)
 Subtracts signed 16-bit integer array elements from a constant. Produces an array of signed 16-bit integer elements. More...
 
static native void Subtract_S16sV16s_V32s (short x, short[] yArray, int yOffset, int[] diffArray, int diffOffset, int length)
 Subtracts signed 16-bit integer array elements from a constant. Produces an array of signed 32-bit integer elements. More...
 
static native void Subtract_S16uV16u_V32u (short x, short[] yArray, int yOffset, int[] diffArray, int diffOffset, int length)
 Subtracts unsigned 16-bit integer array elements from a constant. Produces an array of unsigned 32-bit integer elements. More...
 
static native void Subtract_S32sV32s_V32s (int x, int[] yArray, int yOffset, int[] diffArray, int diffOffset, int length)
 Subtracts signed 32-bit integer array elements from a constant. Produces an array of signed 32-bit integer elements. More...
 
static native void Subtract_S32sV32s_V64s (int x, int[] yArray, int yOffset, long[] diffArray, int diffOffset, int length)
 Subtracts signed 32-bit integer array elements from a constant. Produces an array of signed 64-bit integer elements. More...
 
static native void Subtract_S32uV32u_V64u (int x, int[] yArray, int yOffset, long[] diffArray, int diffOffset, int length)
 Subtracts unsigned 32-bit integer array elements from a constant. Produces an array of unsigned 64-bit integer elements. More...
 
static native void Subtract_S64sV64s_V64s (long x, long[] yArray, int yOffset, long[] diffArray, int diffOffset, int length)
 Subtracts signed 64-bit integer array elements from a constant. Produces an array of signed 64-bit integer elements. More...
 
static native void Subtract_S32fV32f_V32f (float x, float[] yArray, int yOffset, float[] diffArray, int diffOffset, int length)
 Subtracts single precision (32-bit) floating-point array elements from a constant. Produces an array of single precision (32-bit) floating-point elements. More...
 
static native void Subtract_S64fV64f_V64f (double x, double[] yArray, int yOffset, double[] diffArray, int diffOffset, int length)
 Subtracts double precision (64-bit) floating-point array elements from a constant. Produces an array of double precision (64-bit) floating-point elements. More...
 
static native void Subtract_IV8sV8s_IV8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two signed 8-bit integer arrays and writes the result to the first array. More...
 
static native void Subtract_IV16sV16s_IV16s (short[] xArray, int xOffset, short[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two signed 16-bit integer arrays and writes the result to the first array. More...
 
static native void Subtract_IV32sV32s_IV32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two signed 32-bit integer arrays and writes the result to the first array. More...
 
static native void Subtract_IV64sV64s_IV64s (long[] xArray, int xOffset, long[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two signed 64-bit integer arrays and writes the result to the first array. More...
 
static native void Subtract_IV32fV32f_IV32f (float[] xArray, int xOffset, float[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Subtract_IV64fV64f_IV64f (double[] xArray, int xOffset, double[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Subtract_V8sIV8s_IV8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two signed 8-bit integer arrays and writes the result to the second array. More...
 
static native void Subtract_V16sIV16s_IV16s (short[] xArray, int xOffset, short[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two signed 16-bit integer arrays and writes the result to the second array. More...
 
static native void Subtract_V32sIV32s_IV32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two signed 32-bit integer arrays and writes the result to the second array. More...
 
static native void Subtract_V64sIV64s_IV64s (long[] xArray, int xOffset, long[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two signed 64-bit integer arrays and writes the result to the second array. More...
 
static native void Subtract_V32fIV32f_IV32f (float[] xArray, int xOffset, float[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the second array. More...
 
static native void Subtract_V64fIV64f_IV64f (double[] xArray, int xOffset, double[] yArray, int yOffset, int length)
 Subtracts corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the second array. More...
 
static native void Subtract_IV8sS8s_IV8s (byte[] xArray, int xOffset, byte y, int length)
 Subtracts a constant from signed 8-bit integer array elements and writes the result to the same array. More...
 
static native void Subtract_IV16sS16s_IV16s (short[] xArray, int xOffset, short y, int length)
 Subtracts a constant from signed 16-bit integer array elements and writes the result to the same array. More...
 
static native void Subtract_IV32sS32s_IV32s (int[] xArray, int xOffset, int y, int length)
 Subtracts a constant from signed 32-bit integer array elements and writes the result to the same array. More...
 
static native void Subtract_IV64sS64s_IV64s (long[] xArray, int xOffset, long y, int length)
 Subtracts a constant from signed 64-bit integer array elements and writes the result to the same array. More...
 
static native void Subtract_IV32fS32f_IV32f (float[] xArray, int xOffset, float y, int length)
 Subtracts a constant from single precision (32-bit) floating-point array elements and writes the result to the same array. More...
 
static native void Subtract_IV64fS64f_IV64f (double[] xArray, int xOffset, double y, int length)
 Subtracts a constant from double precision (64-bit) floating-point array elements and writes the result to the same array. More...
 
static native void Subtract_S8sIV8s_IV8s (byte x, byte[] yArray, int yOffset, int length)
 Subtracts signed 8-bit integer array elements from a constant and writes the result to the same array. More...
 
static native void Subtract_S16sIV16s_IV16s (short x, short[] yArray, int yOffset, int length)
 Subtracts signed 16-bit integer array elements from a constant and writes the result to the same array. More...
 
static native void Subtract_S32sIV32s_IV32s (int x, int[] yArray, int yOffset, int length)
 Subtracts signed 32-bit integer array elements from a constant and writes the result to the same array. More...
 
static native void Subtract_S64sIV64s_IV64s (long x, long[] yArray, int yOffset, int length)
 Subtracts signed 64-bit integer array elements from a constant and writes the result to the same array. More...
 
static native void Subtract_S32fIV32f_IV32f (float x, float[] yArray, int yOffset, int length)
 Subtracts single precision (32-bit) floating-point array elements from a constant and writes the result to the same array. More...
 
static native void Subtract_S64fIV64f_IV64f (double x, double[] yArray, int yOffset, int length)
 Subtracts double precision (64-bit) floating-point array elements from a constant and writes the result to the same array. More...
 
Negation
static native void Negate_V8s_V8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, int length)
 Negates elements in signed 8-bit integer array. More...
 
static native void Negate_V16s_V16s (short[] xArray, int xOffset, short[] yArray, int yOffset, int length)
 Negates elements in signed 16-bit integer array. More...
 
static native void Negate_V32s_V32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Negates elements in signed 32-bit integer array. More...
 
static native void Negate_V64s_V64s (long[] xArray, int xOffset, long[] yArray, int yOffset, int length)
 Negates elements in signed 64-bit integer array. More...
 
static native void Negate_V32f_V32f (float[] xArray, int xOffset, float[] yArray, int yOffset, int length)
 Negates elements in single precision (32-bit) floating-point array. More...
 
static native void Negate_V64f_V64f (double[] xArray, int xOffset, double[] yArray, int yOffset, int length)
 Negates elements in double precision (64-bit) floating-point array. More...
 
static native void Negate_IV8s_IV8s (byte[] vArray, int vOffset, int length)
 Negates elements in signed 8-bit integer array and writes the results to the same array. More...
 
static native void Negate_IV16s_IV16s (short[] vArray, int vOffset, int length)
 Negates elements in signed 16-bit integer array and writes the results to the same array. More...
 
static native void Negate_IV32s_IV32s (int[] vArray, int vOffset, int length)
 Negates elements in signed 32-bit integer array and writes the results to the same array. More...
 
static native void Negate_IV64s_IV64s (long[] vArray, int vOffset, int length)
 Negates elements in signed 64-bit integer array and writes the results to the same array. More...
 
static native void Negate_IV32f_IV32f (float[] vArray, int vOffset, int length)
 Negates elements in single precision (32-bit) floating-point array and writes the results to the same array. More...
 
static native void Negate_IV64f_IV64f (double[] vArray, int vOffset, int length)
 Negates elements in double precision (64-bit) floating-point array and writes the results to the same array. More...
 
Multiplication
static native void Multiply_V8sV8s_V8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, byte[] productArray, int productOffset, int length)
 Multiples corresponding elements in two signed 8-bit integer arrays, producing an array of signed 8-bit integer elements. More...
 
static native void Multiply_V8sV8s_V16s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, short[] productArray, int productOffset, int length)
 Multiples corresponding elements in two signed 8-bit integer arrays, producing an array of signed 16-bit integer elements. More...
 
static native void Multiply_V8uV8u_V16u (byte[] xArray, int xOffset, byte[] yArray, int yOffset, short[] productArray, int productOffset, int length)
 Multiples corresponding elements in two unsigned 8-bit integer arrays, producing an array of unsigned 16-bit integer elements. More...
 
static native void Multiply_V16sV16s_V16s (short[] xArray, int xOffset, short[] yArray, int yOffset, short[] productArray, int productOffset, int length)
 Multiples corresponding elements in two signed 16-bit integer arrays, producing an array of signed 16-bit integer elements. More...
 
static native void Multiply_V16sV16s_V32s (short[] xArray, int xOffset, short[] yArray, int yOffset, int[] productArray, int productOffset, int length)
 Multiples corresponding elements in two signed 16-bit integer arrays, producing an array of signed 32-bit integer elements. More...
 
static native void Multiply_V16uV16u_V32u (short[] xArray, int xOffset, short[] yArray, int yOffset, int[] productArray, int productOffset, int length)
 Multiples corresponding elements in two unsigned 16-bit integer arrays, producing an array of unsigned 32-bit integer elements. More...
 
static native void Multiply_V32sV32s_V32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int[] productArray, int productOffset, int length)
 Multiples corresponding elements in two signed 32-bit integer arrays, producing an array of signed 32-bit integer elements. More...
 
static native void Multiply_V32sV32s_V64s (int[] xArray, int xOffset, int[] yArray, int yOffset, long[] productArray, int productOffset, int length)
 Multiples corresponding elements in two signed 32-bit integer arrays, producing an array of signed 64-bit integer elements. More...
 
static native void Multiply_V32uV32u_V64u (int[] xArray, int xOffset, int[] yArray, int yOffset, long[] productArray, int productOffset, int length)
 Multiples corresponding elements in two unsigned 32-bit integer arrays, producing an array of unsigned 64-bit integer elements. More...
 
static native void Multiply_V64sV64s_V64s (long[] xArray, int xOffset, long[] yArray, int yOffset, long[] productArray, int productOffset, int length)
 Multiples corresponding elements in two signed 64-bit integer arrays, producing an array of signed 64-bit integer elements. More...
 
static native void Multiply_V32fV32f_V32f (float[] xArray, int xOffset, float[] yArray, int yOffset, float[] productArray, int productOffset, int length)
 Multiples corresponding elements in two single precision (32-bit) floating-point arrays, producing an array of single precision (32-bit) floating-point elements. More...
 
static native void Multiply_V64fV64f_V64f (double[] xArray, int xOffset, double[] yArray, int yOffset, double[] productArray, int productOffset, int length)
 Multiples corresponding elements in two double precision (64-bit) floating-point arrays, producing an array of double precision (64-bit) floating-point elements. More...
 
static native void Multiply_V8sS8s_V8s (byte[] xArray, int xOffset, byte y, byte[] productArray, int productOffset, int length)
 Multiplies signed 8-bit integer array elements by a constant. Produces an array of signed 8-bit integer elements. More...
 
static native void Multiply_V8sS8s_V16s (byte[] xArray, int xOffset, byte y, short[] productArray, int productOffset, int length)
 Multiplies signed 8-bit integer array elements by a constant. Produces an array of signed 16-bit integer elements. More...
 
static native void Multiply_V8uS8u_V16u (byte[] xArray, int xOffset, byte y, short[] productArray, int productOffset, int length)
 Multiplies unsigned 8-bit integer array elements by a constant. Produces an array of unsigned 16-bit integer elements. More...
 
static native void Multiply_V16sS16s_V16s (short[] xArray, int xOffset, short y, short[] productArray, int productOffset, int length)
 Multiplies signed 16-bit integer array elements by a constant. Produces an array of signed 16-bit integer elements. More...
 
static native void Multiply_V16sS16s_V32s (short[] xArray, int xOffset, short y, int[] productArray, int productOffset, int length)
 Multiplies signed 16-bit integer array elements by a constant. Produces an array of signed 32-bit integer elements. More...
 
static native void Multiply_V16uS16u_V32u (short[] xArray, int xOffset, short y, int[] productArray, int productOffset, int length)
 Multiplies unsigned 16-bit integer array elements by a constant. Produces an array of unsigned 32-bit integer elements. More...
 
static native void Multiply_V32sS32s_V32s (int[] xArray, int xOffset, int y, int[] productArray, int productOffset, int length)
 Multiplies signed 32-bit integer array elements by a constant. Produces an array of signed 32-bit integer elements. More...
 
static native void Multiply_V32sS32s_V64s (int[] xArray, int xOffset, int y, long[] productArray, int productOffset, int length)
 Multiplies signed 32-bit integer array elements by a constant. Produces an array of signed 64-bit integer elements. More...
 
static native void Multiply_V32uS32u_V64u (int[] xArray, int xOffset, int y, long[] productArray, int productOffset, int length)
 Multiplies unsigned 32-bit integer array elements by a constant. Produces an array of unsigned 64-bit integer elements. More...
 
static native void Multiply_V64sS64s_V64s (long[] xArray, int xOffset, long y, long[] productArray, int productOffset, int length)
 Multiplies signed 64-bit integer array elements by a constant. Produces an array of signed 64-bit integer elements. More...
 
static native void Multiply_V32fS32f_V32f (float[] xArray, int xOffset, float y, float[] productArray, int productOffset, int length)
 Multiplies single precision (32-bit) floating-point array elements by a constant. Produces an array of single precision (32-bit) floating-point elements. More...
 
static native void Multiply_V64fS64f_V64f (double[] xArray, int xOffset, double y, double[] productArray, int productOffset, int length)
 Multiplies double precision (64-bit) floating-point array elements by a constant. Produces an array of double precision (64-bit) floating-point elements. More...
 
static native void Multiply_IV8sV8s_IV8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, int length)
 Multiplies corresponding elements in two signed 8-bit integer arrays and writes the result to the first array. More...
 
static native void Multiply_IV16sV16s_IV16s (short[] xArray, int xOffset, short[] yArray, int yOffset, int length)
 Multiplies corresponding elements in two signed 16-bit integer arrays and writes the result to the first array. More...
 
static native void Multiply_IV32sV32s_IV32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Multiplies corresponding elements in two signed 32-bit integer arrays and writes the result to the first array. More...
 
static native void Multiply_IV64sV64s_IV64s (long[] xArray, int xOffset, long[] yArray, int yOffset, int length)
 Multiplies corresponding elements in two signed 64-bit integer arrays and writes the result to the first array. More...
 
static native void Multiply_IV32fV32f_IV32f (float[] xArray, int xOffset, float[] yArray, int yOffset, int length)
 Multiplies corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Multiply_IV64fV64f_IV64f (double[] xArray, int xOffset, double[] yArray, int yOffset, int length)
 Multiplies corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Multiply_IV8sS8s_IV8s (byte[] xArray, int xOffset, byte y, int length)
 Multiplies signed 8-bit integer array elements by a constant and writes the result to the same array. More...
 
static native void Multiply_IV16sS16s_IV16s (short[] xArray, int xOffset, short y, int length)
 Multiplies signed 16-bit integer array elements by a constant and writes the result to the same array. More...
 
static native void Multiply_IV32sS32s_IV32s (int[] xArray, int xOffset, int y, int length)
 Multiplies signed 32-bit integer array elements by a constant and writes the result to the same array. More...
 
static native void Multiply_IV64sS64s_IV64s (long[] xArray, int xOffset, long y, int length)
 Multiplies signed 64-bit integer array elements by a constant and writes the result to the same array. More...
 
static native void Multiply_IV32fS32f_IV32f (float[] xArray, int xOffset, float y, int length)
 Multiplies single precision (32-bit) floating-point array elements by a constant and writes the result to the same array. More...
 
static native void Multiply_IV64fS64f_IV64f (double[] xArray, int xOffset, double y, int length)
 Multiplies double precision (64-bit) floating-point array elements by a constant and writes the result to the same array. More...
 
Minimum
static native byte Min_V8s_S8s (byte[] vArray, int vOffset, int length)
 Computes the minimum of signed 8-bit integer array elements. More...
 
static native byte Min_V8u_S8u (byte[] vArray, int vOffset, int length)
 Computes the minimum of unsigned 8-bit integer array elements. More...
 
static native short Min_V16s_S16s (short[] vArray, int vOffset, int length)
 Computes the minimum of signed 16-bit integer array elements. More...
 
static native short Min_V16u_S16u (short[] vArray, int vOffset, int length)
 Computes the minimum of unsigned 16-bit integer array elements. More...
 
static native int Min_V32s_S32s (int[] vArray, int vOffset, int length)
 Computes the minimum of signed 32-bit integer array elements. More...
 
static native int Min_V32u_S32u (int[] vArray, int vOffset, int length)
 Computes the minimum of unsigned 32-bit integer array elements. More...
 
static native long Min_V64s_S64s (long[] vArray, int vOffset, int length)
 Computes the minimum of signed 64-bit integer array elements. More...
 
static native long Min_V64u_S64u (long[] vArray, int vOffset, int length)
 Computes the minimum of unsigned 64-bit integer array elements. More...
 
static native float Min_V32f_S32f (float[] vArray, int vOffset, int length)
 Computes the minimum of single precision (32-bit) floating-point array elements. More...
 
static native double Min_V64f_S64f (double[] vArray, int vOffset, int length)
 Computes the minimum of double precision (64-bit) floating-point array elements. More...
 
static native void Min_V8sV8s_V8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, byte[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two signed 8-bit integer arrays. More...
 
static native void Min_V8uV8u_V8u (byte[] xArray, int xOffset, byte[] yArray, int yOffset, byte[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two unsigned 8-bit integer arrays. More...
 
static native void Min_V16sV16s_V16s (short[] xArray, int xOffset, short[] yArray, int yOffset, short[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two signed 16-bit integer arrays. More...
 
static native void Min_V16uV16u_V16u (short[] xArray, int xOffset, short[] yArray, int yOffset, short[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two unsigned 16-bit integer arrays. More...
 
static native void Min_V32sV32s_V32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two signed 32-bit integer arrays. More...
 
static native void Min_V32uV32u_V32u (int[] xArray, int xOffset, int[] yArray, int yOffset, int[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two unsigned 32-bit integer arrays. More...
 
static native void Min_V64sV32s_V64s (long[] xArray, int xOffset, int[] yArray, int yOffset, long[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two signed 64-bit integer arrays. More...
 
static native void Min_V64uV32u_V64u (long[] xArray, int xOffset, int[] yArray, int yOffset, long[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two unsigned 64-bit integer arrays. More...
 
static native void Min_V32fV32f_V32f (float[] xArray, int xOffset, float[] yArray, int yOffset, float[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two single precision (32-bit) floating-point arrays. More...
 
static native void Min_V64fV64f_V64f (double[] xArray, int xOffset, double[] yArray, int yOffset, double[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of corresponding elements in two double precision (64-bit) floating-point arrays. More...
 
static native void Min_V8sS8s_V8s (byte[] xArray, int xOffset, byte y, byte[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of signed 8-bit integer array elements and a constant. More...
 
static native void Min_V8uS8u_V8u (byte[] xArray, int xOffset, byte y, byte[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of unsigned 8-bit integer array elements and a constant. More...
 
static native void Min_V16sS16s_V16s (short[] xArray, int xOffset, short y, short[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of signed 16-bit integer array elements and a constant. More...
 
static native void Min_V16uS16u_V16u (short[] xArray, int xOffset, short y, short[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of unsigned 16-bit integer array elements and a constant. More...
 
static native void Min_V32sS32s_V32s (int[] xArray, int xOffset, int y, int[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of signed 32-bit integer array elements and a constant. More...
 
static native void Min_V32uS32u_V32u (int[] xArray, int xOffset, int y, int[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of unsigned 32-bit integer array elements and a constant. More...
 
static native void Min_V64sS32s_V64s (long[] xArray, int xOffset, int y, long[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of signed 64-bit integer array elements and a constant. More...
 
static native void Min_V64uS32u_V64u (long[] xArray, int xOffset, int y, long[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of unsigned 64-bit integer array elements and a constant. More...
 
static native void Min_V32fS32f_V32f (float[] xArray, int xOffset, float y, float[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of single precision (32-bit) floating-point array elements and a constant. More...
 
static native void Min_V64fS64f_V64f (double[] xArray, int xOffset, double y, double[] minimumArray, int minimumOffset, int length)
 Computes pairwise minima of double precision (64-bit) floating-point array elements and a constant. More...
 
static native void Min_IV8sV8s_IV8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two signed 8-bit integer arrays and writes the result to the first array. More...
 
static native void Min_IV8uV8u_IV8u (byte[] xArray, int xOffset, byte[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two unsigned 8-bit integer arrays and writes the result to the first array. More...
 
static native void Min_IV16sV16s_IV16s (short[] xArray, int xOffset, short[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two signed 16-bit integer arrays and writes the result to the first array. More...
 
static native void Min_IV16uV16u_IV16u (short[] xArray, int xOffset, short[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two unsigned 16-bit integer arrays and writes the result to the first array. More...
 
static native void Min_IV32sV32s_IV32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two signed 32-bit integer arrays and writes the result to the first array. More...
 
static native void Min_IV32uV32u_IV32u (int[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two unsigned 32-bit integer arrays and writes the result to the first array. More...
 
static native void Min_IV64sV32s_IV64s (long[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two signed 64-bit integer arrays and writes the result to the first array. More...
 
static native void Min_IV64uV32u_IV64u (long[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two unsigned 64-bit integer arrays and writes the result to the first array. More...
 
static native void Min_IV32fV32f_IV32f (float[] xArray, int xOffset, float[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Min_IV64fV64f_IV64f (double[] xArray, int xOffset, double[] yArray, int yOffset, int length)
 Computes pairwise minima of corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Min_IV8sS8s_IV8s (byte[] xArray, int xOffset, byte y, int length)
 Computes pairwise minima of signed 8-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Min_IV8uS8u_IV8u (byte[] xArray, int xOffset, byte y, int length)
 Computes pairwise minima of unsigned 8-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Min_IV16sS16s_IV16s (short[] xArray, int xOffset, short y, int length)
 Computes pairwise minima of signed 16-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Min_IV16uS16u_IV16u (short[] xArray, int xOffset, short y, int length)
 Computes pairwise minima of unsigned 16-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Min_IV32sS32s_IV32s (int[] xArray, int xOffset, int y, int length)
 Computes pairwise minima of signed 32-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Min_IV32uS32u_IV32u (int[] xArray, int xOffset, int y, int length)
 Computes pairwise minima of unsigned 32-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Min_IV64sS32s_IV64s (long[] xArray, int xOffset, int y, int length)
 Computes pairwise minima of signed 64-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Min_IV64uS32u_IV64u (long[] xArray, int xOffset, int y, int length)
 Computes pairwise minima of unsigned 64-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Min_IV32fS32f_IV32f (float[] xArray, int xOffset, float y, int length)
 Computes pairwise minima of single precision (32-bit) floating-point array elements and a constant and writes the result to the same array. More...
 
static native void Min_IV64fS64f_IV64f (double[] xArray, int xOffset, double y, int length)
 Computes pairwise minima of double precision (64-bit) floating-point array elements and a constant and writes the result to the same array. More...
 
Maximum
static native byte Max_V8s_S8s (byte[] vArray, int vOffset, int length)
 Computes the maximum of signed 8-bit integer array elements. More...
 
static native byte Max_V8u_S8u (byte[] vArray, int vOffset, int length)
 Computes the maximum of unsigned 8-bit integer array elements. More...
 
static native short Max_V16s_S16s (short[] vArray, int vOffset, int length)
 Computes the maximum of signed 16-bit integer array elements. More...
 
static native short Max_V16u_S16u (short[] vArray, int vOffset, int length)
 Computes the maximum of unsigned 16-bit integer array elements. More...
 
static native int Max_V32s_S32s (int[] vArray, int vOffset, int length)
 Computes the maximum of signed 32-bit integer array elements. More...
 
static native int Max_V32u_S32u (int[] vArray, int vOffset, int length)
 Computes the maximum of unsigned 32-bit integer array elements. More...
 
static native long Max_V64s_S64s (long[] vArray, int vOffset, int length)
 Computes the maximum of signed 64-bit integer array elements. More...
 
static native long Max_V64u_S64u (long[] vArray, int vOffset, int length)
 Computes the maximum of unsigned 64-bit integer array elements. More...
 
static native float Max_V32f_S32f (float[] vArray, int vOffset, int length)
 Computes the maximum of single precision (32-bit) floating-point array elements. More...
 
static native double Max_V64f_S64f (double[] vArray, int vOffset, int length)
 Computes the maximum of double precision (64-bit) floating-point array elements. More...
 
static native void Max_V8sV8s_V8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, byte[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two signed 8-bit integer arrays. More...
 
static native void Max_V8uV8u_V8u (byte[] xArray, int xOffset, byte[] yArray, int yOffset, byte[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two unsigned 8-bit integer arrays. More...
 
static native void Max_V16sV16s_V16s (short[] xArray, int xOffset, short[] yArray, int yOffset, short[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two signed 16-bit integer arrays. More...
 
static native void Max_V16uV16u_V16u (short[] xArray, int xOffset, short[] yArray, int yOffset, short[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two unsigned 16-bit integer arrays. More...
 
static native void Max_V32sV32s_V32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two signed 32-bit integer arrays. More...
 
static native void Max_V32uV32u_V32u (int[] xArray, int xOffset, int[] yArray, int yOffset, int[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two unsigned 32-bit integer arrays. More...
 
static native void Max_V64sV32s_V64s (long[] xArray, int xOffset, int[] yArray, int yOffset, long[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two signed 64-bit integer arrays. More...
 
static native void Max_V64uV32u_V64u (long[] xArray, int xOffset, int[] yArray, int yOffset, long[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two unsigned 64-bit integer arrays. More...
 
static native void Max_V32fV32f_V32f (float[] xArray, int xOffset, float[] yArray, int yOffset, float[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two single precision (32-bit) floating-point arrays. More...
 
static native void Max_V64fV64f_V64f (double[] xArray, int xOffset, double[] yArray, int yOffset, double[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of corresponding elements in two double precision (64-bit) floating-point arrays. More...
 
static native void Max_V8sS8s_V8s (byte[] xArray, int xOffset, byte y, byte[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of signed 8-bit integer array elements and a constant. More...
 
static native void Max_V8uS8u_V8u (byte[] xArray, int xOffset, byte y, byte[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of unsigned 8-bit integer array elements and a constant. More...
 
static native void Max_V16sS16s_V16s (short[] xArray, int xOffset, short y, short[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of signed 16-bit integer array elements and a constant. More...
 
static native void Max_V16uS16u_V16u (short[] xArray, int xOffset, short y, short[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of unsigned 16-bit integer array elements and a constant. More...
 
static native void Max_V32sS32s_V32s (int[] xArray, int xOffset, int y, int[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of signed 32-bit integer array elements and a constant. More...
 
static native void Max_V32uS32u_V32u (int[] xArray, int xOffset, int y, int[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of unsigned 32-bit integer array elements and a constant. More...
 
static native void Max_V64sS32s_V64s (long[] xArray, int xOffset, int y, long[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of signed 64-bit integer array elements and a constant. More...
 
static native void Max_V64uS32u_V64u (long[] xArray, int xOffset, int y, long[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of unsigned 64-bit integer array elements and a constant. More...
 
static native void Max_V32fS32f_V32f (float[] xArray, int xOffset, float y, float[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of single precision (32-bit) floating-point array elements and a constant. More...
 
static native void Max_V64fS64f_V64f (double[] xArray, int xOffset, double y, double[] maximumArray, int maximumOffset, int length)
 Computes pairwise maxima of double precision (64-bit) floating-point array elements and a constant. More...
 
static native void Max_IV8sV8s_IV8s (byte[] xArray, int xOffset, byte[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two signed 8-bit integer arrays and writes the result to the first array. More...
 
static native void Max_IV8uV8u_IV8u (byte[] xArray, int xOffset, byte[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two unsigned 8-bit integer arrays and writes the result to the first array. More...
 
static native void Max_IV16sV16s_IV16s (short[] xArray, int xOffset, short[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two signed 16-bit integer arrays and writes the result to the first array. More...
 
static native void Max_IV16uV16u_IV16u (short[] xArray, int xOffset, short[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two unsigned 16-bit integer arrays and writes the result to the first array. More...
 
static native void Max_IV32sV32s_IV32s (int[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two signed 32-bit integer arrays and writes the result to the first array. More...
 
static native void Max_IV32uV32u_IV32u (int[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two unsigned 32-bit integer arrays and writes the result to the first array. More...
 
static native void Max_IV64sV32s_IV64s (long[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two signed 64-bit integer arrays and writes the result to the first array. More...
 
static native void Max_IV64uV32u_IV64u (long[] xArray, int xOffset, int[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two unsigned 64-bit integer arrays and writes the result to the first array. More...
 
static native void Max_IV32fV32f_IV32f (float[] xArray, int xOffset, float[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Max_IV64fV64f_IV64f (double[] xArray, int xOffset, double[] yArray, int yOffset, int length)
 Computes pairwise maxima of corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array. More...
 
static native void Max_IV8sS8s_IV8s (byte[] xArray, int xOffset, byte y, int length)
 Computes pairwise maxima of signed 8-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Max_IV8uS8u_IV8u (byte[] xArray, int xOffset, byte y, int length)
 Computes pairwise maxima of unsigned 8-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Max_IV16sS16s_IV16s (short[] xArray, int xOffset, short y, int length)
 Computes pairwise maxima of signed 16-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Max_IV16uS16u_IV16u (short[] xArray, int xOffset, short y, int length)
 Computes pairwise maxima of unsigned 16-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Max_IV32sS32s_IV32s (int[] xArray, int xOffset, int y, int length)
 Computes pairwise maxima of signed 32-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Max_IV32uS32u_IV32u (int[] xArray, int xOffset, int y, int length)
 Computes pairwise maxima of unsigned 32-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Max_IV64sS32s_IV64s (long[] xArray, int xOffset, int y, int length)
 Computes pairwise maxima of signed 64-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Max_IV64uS32u_IV64u (long[] xArray, int xOffset, int y, int length)
 Computes pairwise maxima of unsigned 64-bit integer array elements and a constant and writes the result to the same array. More...
 
static native void Max_IV32fS32f_IV32f (float[] xArray, int xOffset, float y, int length)
 Computes pairwise maxima of single precision (32-bit) floating-point array elements and a constant and writes the result to the same array. More...
 
static native void Max_IV64fS64f_IV64f (double[] xArray, int xOffset, double y, int length)
 Computes pairwise maxima of double precision (64-bit) floating-point array elements and a constant and writes the result to the same array. More...
 
Sum
static native float Sum_V32f_S32f (float[] vArray, int vOffset, int length)
 Computes the sum of single precision (32-bit) floating-point array elements. More...
 
static native double Sum_V64f_S64f (double[] vArray, int vOffset, int length)
 Computes the sum of double precision (64-bit) floating-point array elements. More...
 
Sum of absolute values
static native float SumAbs_V32f_S32f (float[] vArray, int vOffset, int length)
 Computes the sum of absolute values of single precision (32-bit) floating-point array elements. More...
 
static native double SumAbs_V64f_S64f (double[] vArray, int vOffset, int length)
 Computes the sum of absolute values of double precision (64-bit) floating-point array elements. More...
 
Sum of squares (squared L2 norm)
static native float SumSquares_V32f_S32f (float[] vArray, int vOffset, int length)
 Computes the sum of squares of single precision (32-bit) floating-point array elements. More...
 
static native double SumSquares_V64f_S64f (double[] vArray, int vOffset, int length)
 Computes the sum of squares of double precision (64-bit) floating-point array elements. More...
 
Dot product
static native float DotProduct_V32fV32f_S32f (float[] xArray, int xOffset, float[] yArray, int yOffset, int length)
 Computes the dot product of two vectors of single precision (32-bit) floating-point elements. More...
 
static native double DotProduct_V64fV64f_S64f (double[] xArray, int xOffset, double[] yArray, int yOffset, int length)
 Computes the dot product of two vectors of double precision (64-bit) floating-point elements. More...
 

Detailed Description

Basic arithmetic operations.

Member Function Documentation

static native void Add_V8sV8s_V8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
byte[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 8-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
ARMARM Cortex-A9VFP2, NEON
static native void Add_V8sV8s_V16s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
short[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 16-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
ARMARM Cortex-A9VFP2, NEON
static native void Add_V8uV8u_V16u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
short[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two unsigned 8-bit integer arrays. Produces an array of unsigned 16-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
ARMARM Cortex-A9VFP2, NEON
static native void Add_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 16-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
ARMARM Cortex-A9VFP2, NEON
static native void Add_V16sV16s_V32s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
ARMARM Cortex-A9VFP2, NEON
static native void Add_V16uV16u_V32u ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two unsigned 16-bit integer arrays. Produces an array of unsigned 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
ARMARM Cortex-A9VFP2, NEON
static native void Add_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
ARMARM Cortex-A9VFP2, NEON
static native void Add_V32sV32s_V64s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Add_V32uV32u_V64u ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two unsigned 32-bit integer arrays. Produces an array of unsigned 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Add_V64sV64s_V64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
long[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two signed 64-bit integer arrays. Produces an array of signed 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
ARMARM Cortex-A9VFP2, NEON
static native void Add_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two single precision (32-bit) floating-point arrays. Produces an array of single precision (32-bit) floating-point elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE
x86-64Intel Sandy BridgeAVX
ARMARM Cortex-A9VFP2, NEON
static native void Add_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds corresponding elements in two double precision (64-bit) floating-point arrays. Produces an array of double precision (64-bit) floating-point elements.

Exceptions
NullPointerExceptionIf xArray, yArray or sumArray is null.
MisalignedPointerErrorIf xArray, yArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
ARMARM Cortex-A9VFP2
static native void Add_V8sS8s_V8s ( byte[]  xArray,
int  xOffset,
byte  y,
byte[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to signed 8-bit integer array elements. Produces an array of signed 8-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
static native void Add_V8sS8s_V16s ( byte[]  xArray,
int  xOffset,
byte  y,
short[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to signed 8-bit integer array elements. Produces an array of signed 16-bit integer elements.

Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeSSE2, AVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Add_V8uS8u_V16u ( byte[]  xArray,
int  xOffset,
byte  y,
short[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to unsigned 8-bit integer array elements. Produces an array of unsigned 16-bit integer elements.

Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeSSE2, AVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Add_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to signed 16-bit integer array elements. Produces an array of signed 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
static native void Add_V16sS16s_V32s ( short[]  xArray,
int  xOffset,
short  y,
int[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to signed 16-bit integer array elements. Produces an array of signed 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeSSE2, AVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Add_V16uS16u_V32u ( short[]  xArray,
int  xOffset,
short  y,
int[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to unsigned 16-bit integer array elements. Produces an array of unsigned 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeSSE2, AVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Add_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to signed 32-bit integer array elements. Produces an array of signed 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
static native void Add_V32uS32u_V64u ( int[]  xArray,
int  xOffset,
int  y,
long[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to unsigned 32-bit integer array elements. Produces an array of unsigned 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeSSE2, AVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Add_V32sS32s_V64s ( int[]  xArray,
int  xOffset,
int  y,
long[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to signed 32-bit integer array elements. Produces an array of signed 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeSSE2, AVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Add_V64sS64s_V64s ( long[]  xArray,
int  xOffset,
long  y,
long[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to signed 64-bit integer array elements. Produces an array of signed 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
static native void Add_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to single precision (32-bit) floating-point array elements. Produces an array of single precision (32-bit) floating-point elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
static native void Add_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  sumArray,
int  sumOffset,
int  length 
)
static

Adds a constant to double precision (64-bit) floating-point array elements. Produces an array of double precision (64-bit) floating-point elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or sumArray is null.
MisalignedPointerErrorIf xArray or sumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or sumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or sumOffset + length exceeds the length of sumArray.
static native void Add_IV8sV8s_IV8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Adds corresponding elements in two signed 8-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Add_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
static

Adds corresponding elements in two signed 16-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Add_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Adds corresponding elements in two signed 32-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Add_IV64sV64s_IV64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
static

Adds corresponding elements in two signed 64-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Add_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
static

Adds corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Add_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
static

Adds corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Add_IV8sS8s_IV8s ( byte[]  xArray,
int  xOffset,
byte  y,
int  length 
)
static

Adds a constant to signed 8-bit integer array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Add_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
static

Adds a constant to signed 16-bit integer array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Add_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Adds a constant to signed 32-bit integer array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Add_IV64sS64s_IV64s ( long[]  xArray,
int  xOffset,
long  y,
int  length 
)
static

Adds a constant to signed 64-bit integer array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Add_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
static

Adds a constant to single precision (32-bit) floating-point array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Add_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
static

Adds a constant to double precision (64-bit) floating-point array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Subtract_V8sV8s_V8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
byte[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 8-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
ARMARM Cortex-A9VFP2, NEON
static native void Subtract_V8sV8s_V16s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 16-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
ARMARM Cortex-A9VFP2, NEON
static native void Subtract_V8uV8u_V16u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two unsigned 8-bit integer arrays. Produces an array of unsigned 16-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
ARMARM Cortex-A9VFP2, NEON
static native void Subtract_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 16-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
ARMARM Cortex-A9VFP2, NEON
static native void Subtract_V16sV16s_V32s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
ARMARM Cortex-A9VFP2, NEON
static native void Subtract_V16uV16u_V32u ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two unsigned 16-bit integer arrays. Produces an array of unsigned 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
ARMARM Cortex-A9VFP2, NEON
static native void Subtract_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
ARMARM Cortex-A9VFP2, NEON
static native void Subtract_V32sV32s_V64s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Subtract_V32uV32u_V64u ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two unsigned 32-bit integer arrays. Produces an array of unsigned 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Subtract_V64sV64s_V64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 64-bit integer arrays. Produces an array of signed 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
ARMARM Cortex-A9VFP2, NEON
static native void Subtract_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two single precision (32-bit) floating-point arrays. Produces an array of single precision (32-bit) floating-point elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE
x86-64Intel Sandy BridgeAVX
ARMARM Cortex-A9VFP2, NEON
static native void Subtract_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two double precision (64-bit) floating-point arrays. Produces an array of double precision (64-bit) floating-point elements.

Exceptions
NullPointerExceptionIf xArray, yArray or diffArray is null.
MisalignedPointerErrorIf xArray, yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
ARMARM Cortex-A9VFP2
static native void Subtract_V8sS8s_V8s ( byte[]  xArray,
int  xOffset,
byte  y,
byte[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 8-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V8sS8s_V16s ( byte[]  xArray,
int  xOffset,
byte  y,
short[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 8-bit integer arrays. Produces an array of signed 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V8uS8u_V16u ( byte[]  xArray,
int  xOffset,
byte  y,
short[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two unsigned 8-bit integer arrays. Produces an array of unsigned 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V16sS16s_V32s ( short[]  xArray,
int  xOffset,
short  y,
int[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 16-bit integer arrays. Produces an array of signed 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V16uS16u_V32u ( short[]  xArray,
int  xOffset,
short  y,
int[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two unsigned 16-bit integer arrays. Produces an array of unsigned 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V32sS32s_V64s ( int[]  xArray,
int  xOffset,
int  y,
long[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 32-bit integer arrays. Produces an array of signed 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V32uS32u_V64u ( int[]  xArray,
int  xOffset,
int  y,
long[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two unsigned 32-bit integer arrays. Produces an array of unsigned 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V64sS64s_V64s ( long[]  xArray,
int  xOffset,
long  y,
long[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 64-bit integer arrays. Produces an array of signed 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two single precision (32-bit) floating-point arrays. Produces an array of single precision (32-bit) floating-point elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts corresponding elements in two double precision (64-bit) floating-point arrays. Produces an array of double precision (64-bit) floating-point elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or diffArray is null.
MisalignedPointerErrorIf xArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S8sV8s_V8s ( byte  x,
byte[]  yArray,
int  yOffset,
byte[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts signed 8-bit integer array elements from a constant. Produces an array of signed 8-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S8sV8s_V16s ( byte  x,
byte[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts signed 8-bit integer array elements from a constant. Produces an array of signed 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S8uV8u_V16u ( byte  x,
byte[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts unsigned 8-bit integer array elements from a constant. Produces an array of unsigned 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S16sV16s_V16s ( short  x,
short[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts signed 16-bit integer array elements from a constant. Produces an array of signed 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S16sV16s_V32s ( short  x,
short[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts signed 16-bit integer array elements from a constant. Produces an array of signed 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S16uV16u_V32u ( short  x,
short[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts unsigned 16-bit integer array elements from a constant. Produces an array of unsigned 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S32sV32s_V32s ( int  x,
int[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts signed 32-bit integer array elements from a constant. Produces an array of signed 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S32sV32s_V64s ( int  x,
int[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts signed 32-bit integer array elements from a constant. Produces an array of signed 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S32uV32u_V64u ( int  x,
int[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts unsigned 32-bit integer array elements from a constant. Produces an array of unsigned 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S64sV64s_V64s ( long  x,
long[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts signed 64-bit integer array elements from a constant. Produces an array of signed 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S32fV32f_V32f ( float  x,
float[]  yArray,
int  yOffset,
float[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts single precision (32-bit) floating-point array elements from a constant. Produces an array of single precision (32-bit) floating-point elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_S64fV64f_V64f ( double  x,
double[]  yArray,
int  yOffset,
double[]  diffArray,
int  diffOffset,
int  length 
)
static

Subtracts double precision (64-bit) floating-point array elements from a constant. Produces an array of double precision (64-bit) floating-point elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray or diffArray is null.
MisalignedPointerErrorIf yArray or diffArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset or diffOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray or diffOffset + length exceeds the length of diffArray.
static native void Subtract_IV8sV8s_IV8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 8-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 16-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 32-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_IV64sV64s_IV64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 64-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_V8sIV8s_IV8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 8-bit integer arrays and writes the result to the second array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_V16sIV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 16-bit integer arrays and writes the result to the second array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_V32sIV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 32-bit integer arrays and writes the result to the second array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_V64sIV64s_IV64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two signed 64-bit integer arrays and writes the result to the second array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_V32fIV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the second array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_V64fIV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the second array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Subtract_IV8sS8s_IV8s ( byte[]  xArray,
int  xOffset,
byte  y,
int  length 
)
static

Subtracts a constant from signed 8-bit integer array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Subtract_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
static

Subtracts a constant from signed 16-bit integer array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Subtract_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Subtracts a constant from signed 32-bit integer array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Subtract_IV64sS64s_IV64s ( long[]  xArray,
int  xOffset,
long  y,
int  length 
)
static

Subtracts a constant from signed 64-bit integer array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Subtract_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
static

Subtracts a constant from single precision (32-bit) floating-point array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Subtract_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
static

Subtracts a constant from double precision (64-bit) floating-point array elements and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Subtract_S8sIV8s_IV8s ( byte  x,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts signed 8-bit integer array elements from a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray is null.
MisalignedPointerErrorIf yArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray.
static native void Subtract_S16sIV16s_IV16s ( short  x,
short[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts signed 16-bit integer array elements from a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray is null.
MisalignedPointerErrorIf yArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray.
static native void Subtract_S32sIV32s_IV32s ( int  x,
int[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts signed 32-bit integer array elements from a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray is null.
MisalignedPointerErrorIf yArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray.
static native void Subtract_S64sIV64s_IV64s ( long  x,
long[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts signed 64-bit integer array elements from a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray is null.
MisalignedPointerErrorIf yArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray.
static native void Subtract_S32fIV32f_IV32f ( float  x,
float[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts single precision (32-bit) floating-point array elements from a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray is null.
MisalignedPointerErrorIf yArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray.
static native void Subtract_S64fIV64f_IV64f ( double  x,
double[]  yArray,
int  yOffset,
int  length 
)
static

Subtracts double precision (64-bit) floating-point array elements from a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf yArray is null.
MisalignedPointerErrorIf yArray is not naturally aligned.
InvalidArgumentExceptionIf yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf yOffset + length exceeds the length of yArray.
static native void Negate_V8s_V8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Negates elements in signed 8-bit integer array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Negate_V16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
static

Negates elements in signed 16-bit integer array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Negate_V32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Negates elements in signed 32-bit integer array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Negate_V64s_V64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
static

Negates elements in signed 64-bit integer array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Negate_V32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
static

Negates elements in single precision (32-bit) floating-point array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Negate_V64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
static

Negates elements in double precision (64-bit) floating-point array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Negate_IV8s_IV8s ( byte[]  vArray,
int  vOffset,
int  length 
)
static

Negates elements in signed 8-bit integer array and writes the results to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native void Negate_IV16s_IV16s ( short[]  vArray,
int  vOffset,
int  length 
)
static

Negates elements in signed 16-bit integer array and writes the results to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native void Negate_IV32s_IV32s ( int[]  vArray,
int  vOffset,
int  length 
)
static

Negates elements in signed 32-bit integer array and writes the results to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native void Negate_IV64s_IV64s ( long[]  vArray,
int  vOffset,
int  length 
)
static

Negates elements in signed 64-bit integer array and writes the results to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native void Negate_IV32f_IV32f ( float[]  vArray,
int  vOffset,
int  length 
)
static

Negates elements in single precision (32-bit) floating-point array and writes the results to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native void Negate_IV64f_IV64f ( double[]  vArray,
int  vOffset,
int  length 
)
static

Negates elements in double precision (64-bit) floating-point array and writes the results to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native void Multiply_V8sV8s_V8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
byte[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two signed 8-bit integer arrays, producing an array of signed 8-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V8sV8s_V16s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
short[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two signed 8-bit integer arrays, producing an array of signed 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V8uV8u_V16u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
short[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two unsigned 8-bit integer arrays, producing an array of unsigned 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two signed 16-bit integer arrays, producing an array of signed 16-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
static native void Multiply_V16sV16s_V32s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two signed 16-bit integer arrays, producing an array of signed 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD BulldozerAVX
static native void Multiply_V16uV16u_V32u ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two unsigned 16-bit integer arrays, producing an array of unsigned 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD BulldozerAVX
static native void Multiply_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two signed 32-bit integer arrays, producing an array of signed 32-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
static native void Multiply_V32sV32s_V64s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two signed 32-bit integer arrays, producing an array of signed 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
static native void Multiply_V32uV32u_V64u ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two unsigned 32-bit integer arrays, producing an array of unsigned 64-bit integer elements.

Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2, SSE4.1
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, AVX2
x86-64AMD K10SSE2
static native void Multiply_V64sV64s_V64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
long[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two signed 64-bit integer arrays, producing an array of signed 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two single precision (32-bit) floating-point arrays, producing an array of single precision (32-bit) floating-point elements.

Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE
x86-64Intel Sandy BridgeAVX
static native void Multiply_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  productArray,
int  productOffset,
int  length 
)
static

Multiples corresponding elements in two double precision (64-bit) floating-point arrays, producing an array of double precision (64-bit) floating-point elements.

Exceptions
NullPointerExceptionIf xArray, yArray or productArray is null.
MisalignedPointerErrorIf xArray, yArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or productOffset + length exceeds the length of productArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
ARMARM Cortex-A9VFP2
static native void Multiply_V8sS8s_V8s ( byte[]  xArray,
int  xOffset,
byte  y,
byte[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies signed 8-bit integer array elements by a constant. Produces an array of signed 8-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V8sS8s_V16s ( byte[]  xArray,
int  xOffset,
byte  y,
short[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies signed 8-bit integer array elements by a constant. Produces an array of signed 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V8uS8u_V16u ( byte[]  xArray,
int  xOffset,
byte  y,
short[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies unsigned 8-bit integer array elements by a constant. Produces an array of unsigned 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies signed 16-bit integer array elements by a constant. Produces an array of signed 16-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V16sS16s_V32s ( short[]  xArray,
int  xOffset,
short  y,
int[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies signed 16-bit integer array elements by a constant. Produces an array of signed 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V16uS16u_V32u ( short[]  xArray,
int  xOffset,
short  y,
int[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies unsigned 16-bit integer array elements by a constant. Produces an array of unsigned 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies signed 32-bit integer array elements by a constant. Produces an array of signed 32-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V32sS32s_V64s ( int[]  xArray,
int  xOffset,
int  y,
long[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies signed 32-bit integer array elements by a constant. Produces an array of signed 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V32uS32u_V64u ( int[]  xArray,
int  xOffset,
int  y,
long[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies unsigned 32-bit integer array elements by a constant. Produces an array of unsigned 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V64sS64s_V64s ( long[]  xArray,
int  xOffset,
long  y,
long[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies signed 64-bit integer array elements by a constant. Produces an array of signed 64-bit integer elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies single precision (32-bit) floating-point array elements by a constant. Produces an array of single precision (32-bit) floating-point elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  productArray,
int  productOffset,
int  length 
)
static

Multiplies double precision (64-bit) floating-point array elements by a constant. Produces an array of double precision (64-bit) floating-point elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or productArray is null.
MisalignedPointerErrorIf xArray or productArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or productOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or productOffset + length exceeds the length of productArray.
static native void Multiply_IV8sV8s_IV8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Multiplies corresponding elements in two signed 8-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Multiply_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
static

Multiplies corresponding elements in two signed 16-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Multiply_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Multiplies corresponding elements in two signed 32-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Multiply_IV64sV64s_IV64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
static

Multiplies corresponding elements in two signed 64-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Multiply_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
static

Multiplies corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Multiply_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
static

Multiplies corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Multiply_IV8sS8s_IV8s ( byte[]  xArray,
int  xOffset,
byte  y,
int  length 
)
static

Multiplies signed 8-bit integer array elements by a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Multiply_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
static

Multiplies signed 16-bit integer array elements by a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Multiply_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Multiplies signed 32-bit integer array elements by a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Multiply_IV64sS64s_IV64s ( long[]  xArray,
int  xOffset,
long  y,
int  length 
)
static

Multiplies signed 64-bit integer array elements by a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Multiply_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
static

Multiplies single precision (32-bit) floating-point array elements by a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Multiply_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
static

Multiplies double precision (64-bit) floating-point array elements by a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native byte Min_V8s_S8s ( byte[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of signed 8-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native byte Min_V8u_S8u ( byte[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of unsigned 8-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native short Min_V16s_S16s ( short[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of signed 16-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native short Min_V16u_S16u ( short[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of unsigned 16-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native int Min_V32s_S32s ( int[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of signed 32-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native int Min_V32u_S32u ( int[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of unsigned 32-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native long Min_V64s_S64s ( long[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of signed 64-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native long Min_V64u_S64u ( long[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of unsigned 64-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native float Min_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of single precision (32-bit) floating-point array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native double Min_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
static

Computes the minimum of double precision (64-bit) floating-point array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native void Min_V8sV8s_V8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
byte[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two signed 8-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Min_V8uV8u_V8u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
byte[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two unsigned 8-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Min_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two signed 16-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Min_V16uV16u_V16u ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two unsigned 16-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Min_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two signed 32-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Min_V32uV32u_V32u ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two unsigned 32-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Min_V64sV32s_V64s ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two signed 64-bit integer arrays.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V64uV32u_V64u ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two unsigned 64-bit integer arrays.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two single precision (32-bit) floating-point arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE
x86-64Intel Sandy BridgeAVX
static native void Min_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two double precision (64-bit) floating-point arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or minimumArray is null.
MisalignedPointerErrorIf xArray, yArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or minimumOffset + length exceeds the length of minimumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
static native void Min_V8sS8s_V8s ( byte[]  xArray,
int  xOffset,
byte  y,
byte[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of signed 8-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V8uS8u_V8u ( byte[]  xArray,
int  xOffset,
byte  y,
byte[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of unsigned 8-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of signed 16-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V16uS16u_V16u ( short[]  xArray,
int  xOffset,
short  y,
short[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of unsigned 16-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of signed 32-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V32uS32u_V32u ( int[]  xArray,
int  xOffset,
int  y,
int[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of unsigned 32-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V64sS32s_V64s ( long[]  xArray,
int  xOffset,
int  y,
long[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of signed 64-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V64uS32u_V64u ( long[]  xArray,
int  xOffset,
int  y,
long[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of unsigned 64-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of single precision (32-bit) floating-point array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  minimumArray,
int  minimumOffset,
int  length 
)
static

Computes pairwise minima of double precision (64-bit) floating-point array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or minimumArray is null.
MisalignedPointerErrorIf xArray or minimumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or minimumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or minimumOffset + length exceeds the length of minimumArray.
static native void Min_IV8sV8s_IV8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two signed 8-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV8uV8u_IV8u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two unsigned 8-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two signed 16-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV16uV16u_IV16u ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two unsigned 16-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two signed 32-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV32uV32u_IV32u ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two unsigned 32-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV64sV32s_IV64s ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two signed 64-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV64uV32u_IV64u ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two unsigned 64-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise minima of corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Min_IV8sS8s_IV8s ( byte[]  xArray,
int  xOffset,
byte  y,
int  length 
)
static

Computes pairwise minima of signed 8-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Min_IV8uS8u_IV8u ( byte[]  xArray,
int  xOffset,
byte  y,
int  length 
)
static

Computes pairwise minima of unsigned 8-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Min_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
static

Computes pairwise minima of signed 16-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Min_IV16uS16u_IV16u ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
static

Computes pairwise minima of unsigned 16-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Min_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Computes pairwise minima of signed 32-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Min_IV32uS32u_IV32u ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Computes pairwise minima of unsigned 32-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Min_IV64sS32s_IV64s ( long[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Computes pairwise minima of signed 64-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Min_IV64uS32u_IV64u ( long[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Computes pairwise minima of unsigned 64-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Min_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
static

Computes pairwise minima of single precision (32-bit) floating-point array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Min_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
static

Computes pairwise minima of double precision (64-bit) floating-point array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native byte Max_V8s_S8s ( byte[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of signed 8-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native byte Max_V8u_S8u ( byte[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of unsigned 8-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native short Max_V16s_S16s ( short[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of signed 16-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native short Max_V16u_S16u ( short[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of unsigned 16-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native int Max_V32s_S32s ( int[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of signed 32-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native int Max_V32u_S32u ( int[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of unsigned 32-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native long Max_V64s_S64s ( long[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of signed 64-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native long Max_V64u_S64u ( long[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of unsigned 64-bit integer array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native float Max_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of single precision (32-bit) floating-point array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native double Max_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
static

Computes the maximum of double precision (64-bit) floating-point array elements.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative or length is zero.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
static native void Max_V8sV8s_V8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
byte[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two signed 8-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Max_V8uV8u_V8u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
byte[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two unsigned 8-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Max_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two signed 16-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Max_V16uV16u_V16u ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two unsigned 16-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Max_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two signed 32-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Max_V32uV32u_V32u ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two unsigned 32-bit integer arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
ARMARM Cortex-A9VFP2, NEON
static native void Max_V64sV32s_V64s ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two signed 64-bit integer arrays.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V64uV32u_V64u ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two unsigned 64-bit integer arrays.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two single precision (32-bit) floating-point arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE
x86-64Intel Sandy BridgeAVX
static native void Max_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two double precision (64-bit) floating-point arrays.

Exceptions
NullPointerExceptionIf xArray, yArray or maximumArray is null.
MisalignedPointerErrorIf xArray, yArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset, yOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray, yOffset + length exceeds the length of yArray or maximumOffset + length exceeds the length of maximumArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
x86-64Intel Sandy BridgeAVX
static native void Max_V8sS8s_V8s ( byte[]  xArray,
int  xOffset,
byte  y,
byte[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of signed 8-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V8uS8u_V8u ( byte[]  xArray,
int  xOffset,
byte  y,
byte[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of unsigned 8-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of signed 16-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V16uS16u_V16u ( short[]  xArray,
int  xOffset,
short  y,
short[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of unsigned 16-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of signed 32-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V32uS32u_V32u ( int[]  xArray,
int  xOffset,
int  y,
int[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of unsigned 32-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V64sS32s_V64s ( long[]  xArray,
int  xOffset,
int  y,
long[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of signed 64-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V64uS32u_V64u ( long[]  xArray,
int  xOffset,
int  y,
long[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of unsigned 64-bit integer array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of single precision (32-bit) floating-point array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  maximumArray,
int  maximumOffset,
int  length 
)
static

Computes pairwise maxima of double precision (64-bit) floating-point array elements and a constant.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or maximumArray is null.
MisalignedPointerErrorIf xArray or maximumArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or maximumOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or maximumOffset + length exceeds the length of maximumArray.
static native void Max_IV8sV8s_IV8s ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two signed 8-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV8uV8u_IV8u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two unsigned 8-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two signed 16-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV16uV16u_IV16u ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two unsigned 16-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two signed 32-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV32uV32u_IV32u ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two unsigned 32-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV64sV32s_IV64s ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two signed 64-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV64uV32u_IV64u ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two unsigned 64-bit integer arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two single precision (32-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
static

Computes pairwise maxima of corresponding elements in two double precision (64-bit) floating-point arrays and writes the result to the first array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
static native void Max_IV8sS8s_IV8s ( byte[]  xArray,
int  xOffset,
byte  y,
int  length 
)
static

Computes pairwise maxima of signed 8-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Max_IV8uS8u_IV8u ( byte[]  xArray,
int  xOffset,
byte  y,
int  length 
)
static

Computes pairwise maxima of unsigned 8-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Max_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
static

Computes pairwise maxima of signed 16-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Max_IV16uS16u_IV16u ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
static

Computes pairwise maxima of unsigned 16-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Max_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Computes pairwise maxima of signed 32-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Max_IV32uS32u_IV32u ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Computes pairwise maxima of unsigned 32-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Max_IV64sS32s_IV64s ( long[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Computes pairwise maxima of signed 64-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Max_IV64uS32u_IV64u ( long[]  xArray,
int  xOffset,
int  y,
int  length 
)
static

Computes pairwise maxima of unsigned 64-bit integer array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Max_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
static

Computes pairwise maxima of single precision (32-bit) floating-point array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native void Max_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
static

Computes pairwise maxima of double precision (64-bit) floating-point array elements and a constant and writes the result to the same array.

Warning
This version of Yeppp! does not include optimized implementations for this function
Exceptions
NullPointerExceptionIf xArray is null.
MisalignedPointerErrorIf xArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray.
static native float Sum_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
static

Computes the sum of single precision (32-bit) floating-point array elements.

Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE3
x86-64Intel Sandy BridgeAVX
x86-64AMD BulldozerAVX
static native double Sum_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
static

Computes the sum of double precision (64-bit) floating-point array elements.

Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE2
x86-64Intel Sandy BridgeAVX
x86-64AMD BulldozerAVX
static native float SumAbs_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
static

Computes the sum of absolute values of single precision (32-bit) floating-point array elements.

Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE2, SSE3
x86-64Intel Sandy BridgeAVX
x86-64AMD BulldozerAVX
static native double SumAbs_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
static

Computes the sum of absolute values of double precision (64-bit) floating-point array elements.

Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE2
x86-64Intel Sandy BridgeAVX
x86-64AMD BulldozerAVX
static native float SumSquares_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
static

Computes the sum of squares of single precision (32-bit) floating-point array elements.

Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE3
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, FMA3
x86-64AMD BulldozerAVX, FMA4
static native double SumSquares_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
static

Computes the sum of squares of double precision (64-bit) floating-point array elements.

Exceptions
NullPointerExceptionIf vArray is null.
MisalignedPointerErrorIf vArray is not naturally aligned.
InvalidArgumentExceptionIf vOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf vOffset + length exceeds the length of vArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, FMA3
x86-64AMD BulldozerAVX, FMA4
static native float DotProduct_V32fV32f_S32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
static

Computes the dot product of two vectors of single precision (32-bit) floating-point elements.

Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE3
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, FMA3
x86-64AMD BulldozerAVX, FMA4
static native double DotProduct_V64fV64f_S64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
static

Computes the dot product of two vectors of double precision (64-bit) floating-point elements.

Exceptions
NullPointerExceptionIf xArray or yArray is null.
MisalignedPointerErrorIf xArray or yArray is not naturally aligned.
InvalidArgumentExceptionIf xOffset or yOffset is negative.
NegativeArraySizeExceptionIf length is negative.
IndexOutOfBoundsExceptionIf xOffset + length exceeds the length of xArray or yOffset + length exceeds the length of yArray.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE2
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, FMA3
x86-64Intel BonnellSSE, SSE2
x86-64AMD BulldozerAVX, FMA4