Yeppp!
 All Classes Namespaces Functions Variables Properties Pages
Static Public Member Functions | List of all members
Core Class Reference

Basic arithmetic operations More...

Static Public Member Functions

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

Detailed Description

Basic arithmetic operations

Member Function Documentation

static unsafe void Add_V8sV8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
sbyte[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V8sV8s_V16s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
short[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V8uV8u_V16u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
ushort[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V16sV16s_V32s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V16uV16u_V32u ( ushort[]  xArray,
int  xOffset,
ushort[]  yArray,
int  yOffset,
uint[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V32sV32s_V64s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V32uV32u_V64u ( uint[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
ulong[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V64sV64s_V64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
long[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or sumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V8sS8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
sbyte[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V8sS8s_V16s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
short[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V8uS8u_V16u ( byte[]  xArray,
int  xOffset,
byte  y,
ushort[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf xArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V16sS16s_V32s ( short[]  xArray,
int  xOffset,
short  y,
int[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf xArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V16uS16u_V32u ( ushort[]  xArray,
int  xOffset,
ushort  y,
uint[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf xArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf xArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V32uS32u_V64u ( uint[]  xArray,
int  xOffset,
uint  y,
ulong[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf xArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V32sS32s_V64s ( int[]  xArray,
int  xOffset,
int  y,
long[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf xArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V64sS64s_V64s ( long[]  xArray,
int  xOffset,
long  y,
long[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf xArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf xArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  sumArray,
int  sumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or sumArray is null.
System.DataMisalignedExceptionIf xArray or sumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, sumOffset is negative, sumOffset + length exceeds the length of sumArray, or length is negative.
static unsafe void Add_IV8sV8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Add_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Add_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Add_IV64sV64s_IV64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Add_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Add_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Add_IV8sS8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Add_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Add_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Add_IV64sS64s_IV64s ( long[]  xArray,
int  xOffset,
long  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Add_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Add_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Add_V8sV8s_V8s ( sbyte *  x,
sbyte *  y,
sbyte *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 8-bit integer elements.
yPointer to the second addend array of signed 8-bit integer elements.
sumPointer to the summand array of signed 8-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V8sV8s_V16s ( sbyte *  x,
sbyte *  y,
short *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 8-bit integer elements.
yPointer to the second addend array of signed 8-bit integer elements.
sumPointer to the summand array of signed 16-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V8uV8u_V16u ( byte *  x,
byte *  y,
ushort *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of unsigned 8-bit integer elements.
yPointer to the second addend array of unsigned 8-bit integer elements.
sumPointer to the summand array of unsigned 16-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V16sV16s_V16s ( short *  x,
short *  y,
short *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 16-bit integer elements.
yPointer to the second addend array of signed 16-bit integer elements.
sumPointer to the summand array of signed 16-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf x, y or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V16sV16s_V32s ( short *  x,
short *  y,
int *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 16-bit integer elements.
yPointer to the second addend array of signed 16-bit integer elements.
sumPointer to the summand array of signed 32-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf x, y or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V16uV16u_V32u ( ushort *  x,
ushort *  y,
uint *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of unsigned 16-bit integer elements.
yPointer to the second addend array of unsigned 16-bit integer elements.
sumPointer to the summand array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf x, y or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V32sV32s_V32s ( int *  x,
int *  y,
int *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 32-bit integer elements.
yPointer to the second addend array of signed 32-bit integer elements.
sumPointer to the summand array of signed 32-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf x, y or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V32sV32s_V64s ( int *  x,
int *  y,
long *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 32-bit integer elements.
yPointer to the second addend array of signed 32-bit integer elements.
sumPointer to the summand array of signed 64-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf x, y or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V32uV32u_V64u ( uint *  x,
uint *  y,
ulong *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of unsigned 32-bit integer elements.
yPointer to the second addend array of unsigned 32-bit integer elements.
sumPointer to the summand array of unsigned 64-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf x, y or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V64sV64s_V64s ( long *  x,
long *  y,
long *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 64-bit integer elements.
yPointer to the second addend array of signed 64-bit integer elements.
sumPointer to the summand array of signed 64-bit integer elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf x, y or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V32fV32f_V32f ( float *  x,
float *  y,
float *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of single precision (32-bit) floating-point elements.
yPointer to the second addend array of single precision (32-bit) floating-point elements.
sumPointer to the summand array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf x, y or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V64fV64f_V64f ( double *  x,
double *  y,
double *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of double precision (64-bit) floating-point elements.
yPointer to the second addend array of double precision (64-bit) floating-point elements.
sumPointer to the summand array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x, y, and sum.
Exceptions
System.NullReferenceExceptionIf x, y or sum is null.
System.DataMisalignedExceptionIf x, y or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V8sS8s_V8s ( sbyte *  x,
sbyte  y,
sbyte *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 8-bit integer elements.
yThe signed 8-bit integer constant to be added.
sumPointer to the summand array of signed 8-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V8sS8s_V16s ( sbyte *  x,
sbyte  y,
short *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 8-bit integer elements.
yThe signed 8-bit integer constant to be added.
sumPointer to the summand array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V8uS8u_V16u ( byte *  x,
byte  y,
ushort *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of unsigned 8-bit integer elements.
yThe unsigned 8-bit integer constant to be added.
sumPointer to the summand array of unsigned 16-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V16sS16s_V16s ( short *  x,
short  y,
short *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 16-bit integer elements.
yThe signed 16-bit integer constant to be added.
sumPointer to the summand array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf x or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V16sS16s_V32s ( short *  x,
short  y,
int *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 16-bit integer elements.
yThe signed 16-bit integer constant to be added.
sumPointer to the summand array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf x or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V16uS16u_V32u ( ushort *  x,
ushort  y,
uint *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of unsigned 16-bit integer elements.
yThe unsigned 16-bit integer constant to be added.
sumPointer to the summand array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf x or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V32sS32s_V32s ( int *  x,
int  y,
int *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 32-bit integer elements.
yThe signed 32-bit integer constant to be added.
sumPointer to the summand array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf x or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V32uS32u_V64u ( uint *  x,
uint  y,
ulong *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of unsigned 32-bit integer elements.
yThe unsigned 32-bit integer constant to be added.
sumPointer to the summand array of unsigned 64-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf x or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V32sS32s_V64s ( int *  x,
int  y,
long *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 32-bit integer elements.
yThe signed 32-bit integer constant to be added.
sumPointer to the summand array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf x or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V64sS64s_V64s ( long *  x,
long  y,
long *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 64-bit integer elements.
yThe signed 64-bit integer constant to be added.
sumPointer to the summand array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf x or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V32fS32f_V32f ( float *  x,
float  y,
float *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant to be added.
sumPointer to the summand array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf x or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_V64fS64f_V64f ( double *  x,
double  y,
double *  sum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant to be added.
sumPointer to the summand array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x and sum.
Exceptions
System.NullReferenceExceptionIf x or sum is null.
System.DataMisalignedExceptionIf x or sum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV8sV8s_IV8s ( sbyte *  x,
sbyte *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 8-bit integer elements.
yPointer to the second addend array of signed 8-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV16sV16s_IV16s ( short *  x,
short *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 16-bit integer elements.
yPointer to the second addend array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV32sV32s_IV32s ( int *  x,
int *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 32-bit integer elements.
yPointer to the second addend array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV64sV64s_IV64s ( long *  x,
long *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of signed 64-bit integer elements.
yPointer to the second addend array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV32fV32f_IV32f ( float *  x,
float *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of single precision (32-bit) floating-point elements.
yPointer to the second addend array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV64fV64f_IV64f ( double *  x,
double *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first addend array of double precision (64-bit) floating-point elements.
yPointer to the second addend array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV8sS8s_IV8s ( sbyte *  x,
sbyte  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 8-bit integer elements.
yThe signed 8-bit integer constant to be added.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV16sS16s_IV16s ( short *  x,
short  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 16-bit integer elements.
yThe signed 16-bit integer constant to be added.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV32sS32s_IV32s ( int *  x,
int  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 32-bit integer elements.
yThe signed 32-bit integer constant to be added.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV64sS64s_IV64s ( long *  x,
long  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of signed 64-bit integer elements.
yThe signed 64-bit integer constant to be added.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV32fS32f_IV32f ( float *  x,
float  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant to be added.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Add_IV64fS64f_IV64f ( double *  x,
double  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the addend array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant to be added.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe float DotProduct_V32fV32f_S32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe double DotProduct_V64fV64f_S64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe float DotProduct_V32fV32f_S32f ( float *  x,
float *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first vector of elements.
yPointer to the second vector of elements.
lengthLength of the vectors specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe double DotProduct_V64fV64f_S64f ( double *  x,
double *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first vector of elements.
yPointer to the second vector of elements.
lengthLength of the vectors specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe sbyte Max_V8s_S8s ( sbyte[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe byte Max_V8u_S8u ( byte[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe short Max_V16s_S16s ( short[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe ushort Max_V16u_S16u ( ushort[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe int Max_V32s_S32s ( int[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe uint Max_V32u_S32u ( uint[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe long Max_V64s_S64s ( long[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe ulong Max_V64u_S64u ( ulong[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe float Max_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe double Max_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe void Max_V8sV8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
sbyte[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V8uV8u_V8u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
byte[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V16uV16u_V16u ( ushort[]  xArray,
int  xOffset,
ushort[]  yArray,
int  yOffset,
ushort[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V32uV32u_V32u ( uint[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
uint[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V64sV32s_V64s ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V64uV32u_V64u ( ulong[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
ulong[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V8sS8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
sbyte[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V8uS8u_V8u ( byte[]  xArray,
int  xOffset,
byte  y,
byte[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V16uS16u_V16u ( ushort[]  xArray,
int  xOffset,
ushort  y,
ushort[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V32uS32u_V32u ( uint[]  xArray,
int  xOffset,
uint  y,
uint[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V64sS32s_V64s ( long[]  xArray,
int  xOffset,
int  y,
long[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V64uS32u_V64u ( ulong[]  xArray,
int  xOffset,
uint  y,
ulong[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  maximumArray,
int  maximumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or maximumArray is null.
System.DataMisalignedExceptionIf xArray or maximumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, maximumOffset is negative, maximumOffset + length exceeds the length of maximumArray, or length is negative.
static unsafe void Max_IV8sV8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV8uV8u_IV8u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV16uV16u_IV16u ( ushort[]  xArray,
int  xOffset,
ushort[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV32uV32u_IV32u ( uint[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV64sV32s_IV64s ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV64uV32u_IV64u ( ulong[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Max_IV8sS8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Max_IV8uS8u_IV8u ( byte[]  xArray,
int  xOffset,
byte  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Max_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Max_IV16uS16u_IV16u ( ushort[]  xArray,
int  xOffset,
ushort  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Max_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Max_IV32uS32u_IV32u ( uint[]  xArray,
int  xOffset,
uint  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Max_IV64sS32s_IV64s ( long[]  xArray,
int  xOffset,
int  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Max_IV64uS32u_IV64u ( ulong[]  xArray,
int  xOffset,
uint  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Max_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Max_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe sbyte Max_V8s_S8s ( sbyte *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe byte Max_V8u_S8u ( byte *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe short Max_V16s_S16s ( short *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe ushort Max_V16u_S16u ( ushort *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe int Max_V32s_S32s ( int *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe uint Max_V32u_S32u ( uint *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe long Max_V64s_S64s ( long *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe ulong Max_V64u_S64u ( ulong *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe float Max_V32f_S32f ( float *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe double Max_V64f_S64f ( double *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose maximum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe void Max_V8sV8s_V8s ( sbyte *  x,
sbyte *  y,
sbyte *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 8-bit integer elements.
yPointer to the second array of signed 8-bit integer elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V8uV8u_V8u ( byte *  x,
byte *  y,
byte *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 8-bit integer elements.
yPointer to the second array of unsigned 8-bit integer elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V16sV16s_V16s ( short *  x,
short *  y,
short *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 16-bit integer elements.
yPointer to the second array of signed 16-bit integer elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.DataMisalignedExceptionIf x, y or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V16uV16u_V16u ( ushort *  x,
ushort *  y,
ushort *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 16-bit integer elements.
yPointer to the second array of unsigned 16-bit integer elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.DataMisalignedExceptionIf x, y or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V32sV32s_V32s ( int *  x,
int *  y,
int *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 32-bit integer elements.
yPointer to the second array of signed 32-bit integer elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.DataMisalignedExceptionIf x, y or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V32uV32u_V32u ( uint *  x,
uint *  y,
uint *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 32-bit integer elements.
yPointer to the second array of unsigned 32-bit integer elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.DataMisalignedExceptionIf x, y or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V64sV32s_V64s ( long *  x,
int *  y,
long *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 64-bit integer elements.
yPointer to the second array of signed 32-bit integer elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.DataMisalignedExceptionIf x, y or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V64uV32u_V64u ( ulong *  x,
uint *  y,
ulong *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 64-bit integer elements.
yPointer to the second array of unsigned 32-bit integer elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.DataMisalignedExceptionIf x, y or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V32fV32f_V32f ( float *  x,
float *  y,
float *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of single precision (32-bit) floating-point elements.
yPointer to the second array of single precision (32-bit) floating-point elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.DataMisalignedExceptionIf x, y or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V64fV64f_V64f ( double *  x,
double *  y,
double *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of double precision (64-bit) floating-point elements.
yPointer to the second array of double precision (64-bit) floating-point elements.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x, y or maximum is null.
System.DataMisalignedExceptionIf x, y or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V8sS8s_V8s ( sbyte *  x,
sbyte  y,
sbyte *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 8-bit integer elements.
yThe signed 8-bit integer constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V8uS8u_V8u ( byte *  x,
byte  y,
byte *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 8-bit integer elements.
yThe unsigned 8-bit integer constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V16sS16s_V16s ( short *  x,
short  y,
short *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 16-bit integer elements.
yThe signed 16-bit integer constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.DataMisalignedExceptionIf x or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V16uS16u_V16u ( ushort *  x,
ushort  y,
ushort *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 16-bit integer elements.
yThe unsigned 16-bit integer constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.DataMisalignedExceptionIf x or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V32sS32s_V32s ( int *  x,
int  y,
int *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 32-bit integer elements.
yThe signed 32-bit integer constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.DataMisalignedExceptionIf x or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V32uS32u_V32u ( uint *  x,
uint  y,
uint *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 32-bit integer elements.
yThe unsigned 32-bit integer constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.DataMisalignedExceptionIf x or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V64sS32s_V64s ( long *  x,
int  y,
long *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 64-bit integer elements.
yThe signed 32-bit integer constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.DataMisalignedExceptionIf x or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V64uS32u_V64u ( ulong *  x,
uint  y,
ulong *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 64-bit integer elements.
yThe unsigned 32-bit integer constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.DataMisalignedExceptionIf x or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V32fS32f_V32f ( float *  x,
float  y,
float *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.DataMisalignedExceptionIf x or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_V64fS64f_V64f ( double *  x,
double  y,
double *  maximum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant.
maximumPointer to the array of pairwise maximum elements.
lengthLength of the arrays specified by x, y, and maximum.
Exceptions
System.NullReferenceExceptionIf x or maximum is null.
System.DataMisalignedExceptionIf x or maximum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV8sV8s_IV8s ( sbyte *  x,
sbyte *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 8-bit integer elements.
yPointer to the second array of signed 8-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV8uV8u_IV8u ( byte *  x,
byte *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 8-bit integer elements.
yPointer to the second array of unsigned 8-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV16sV16s_IV16s ( short *  x,
short *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 16-bit integer elements.
yPointer to the second array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV16uV16u_IV16u ( ushort *  x,
ushort *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 16-bit integer elements.
yPointer to the second array of unsigned 16-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV32sV32s_IV32s ( int *  x,
int *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 32-bit integer elements.
yPointer to the second array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV32uV32u_IV32u ( uint *  x,
uint *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 32-bit integer elements.
yPointer to the second array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV64sV32s_IV64s ( long *  x,
int *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 64-bit integer elements.
yPointer to the second array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV64uV32u_IV64u ( ulong *  x,
uint *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 64-bit integer elements.
yPointer to the second array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV32fV32f_IV32f ( float *  x,
float *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of single precision (32-bit) floating-point elements.
yPointer to the second array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV64fV64f_IV64f ( double *  x,
double *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of double precision (64-bit) floating-point elements.
yPointer to the second array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV8sS8s_IV8s ( sbyte *  x,
sbyte  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of signed 8-bit integer elements.
yThe signed 8-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV8uS8u_IV8u ( byte *  x,
byte  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of unsigned 8-bit integer elements.
yThe unsigned 8-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV16sS16s_IV16s ( short *  x,
short  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of signed 16-bit integer elements.
yThe signed 16-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV16uS16u_IV16u ( ushort *  x,
ushort  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of unsigned 16-bit integer elements.
yThe unsigned 16-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV32sS32s_IV32s ( int *  x,
int  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of signed 32-bit integer elements.
yThe signed 32-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV32uS32u_IV32u ( uint *  x,
uint  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of unsigned 32-bit integer elements.
yThe unsigned 32-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV64sS32s_IV64s ( long *  x,
int  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of signed 64-bit integer elements.
yThe signed 32-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV64uS32u_IV64u ( ulong *  x,
uint  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of unsigned 64-bit integer elements.
yThe unsigned 32-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV32fS32f_IV32f ( float *  x,
float  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Max_IV64fS64f_IV64f ( double *  x,
double  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe sbyte Min_V8s_S8s ( sbyte[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe byte Min_V8u_S8u ( byte[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe short Min_V16s_S16s ( short[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe ushort Min_V16u_S16u ( ushort[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe int Min_V32s_S32s ( int[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe uint Min_V32u_S32u ( uint[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe long Min_V64s_S64s ( long[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe ulong Min_V64u_S64u ( ulong[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe float Min_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe double Min_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe void Min_V8sV8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
sbyte[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V8uV8u_V8u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
byte[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V16uV16u_V16u ( ushort[]  xArray,
int  xOffset,
ushort[]  yArray,
int  yOffset,
ushort[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V32uV32u_V32u ( uint[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
uint[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V64sV32s_V64s ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V64uV32u_V64u ( ulong[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
ulong[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray, yArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V8sS8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
sbyte[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V8uS8u_V8u ( byte[]  xArray,
int  xOffset,
byte  y,
byte[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V16uS16u_V16u ( ushort[]  xArray,
int  xOffset,
ushort  y,
ushort[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V32uS32u_V32u ( uint[]  xArray,
int  xOffset,
uint  y,
uint[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V64sS32s_V64s ( long[]  xArray,
int  xOffset,
int  y,
long[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V64uS32u_V64u ( ulong[]  xArray,
int  xOffset,
uint  y,
ulong[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  minimumArray,
int  minimumOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or minimumArray is null.
System.DataMisalignedExceptionIf xArray or minimumArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, minimumOffset is negative, minimumOffset + length exceeds the length of minimumArray, or length is negative.
static unsafe void Min_IV8sV8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV8uV8u_IV8u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV16uV16u_IV16u ( ushort[]  xArray,
int  xOffset,
ushort[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV32uV32u_IV32u ( uint[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV64sV32s_IV64s ( long[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV64uV32u_IV64u ( ulong[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Min_IV8sS8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Min_IV8uS8u_IV8u ( byte[]  xArray,
int  xOffset,
byte  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Min_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Min_IV16uS16u_IV16u ( ushort[]  xArray,
int  xOffset,
ushort  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Min_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Min_IV32uS32u_IV32u ( uint[]  xArray,
int  xOffset,
uint  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Min_IV64sS32s_IV64s ( long[]  xArray,
int  xOffset,
int  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Min_IV64uS32u_IV64u ( ulong[]  xArray,
int  xOffset,
uint  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Min_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Min_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe sbyte Min_V8s_S8s ( sbyte *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe byte Min_V8u_S8u ( byte *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe short Min_V16s_S16s ( short *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe ushort Min_V16u_S16u ( ushort *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe int Min_V32s_S32s ( int *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe uint Min_V32u_S32u ( uint *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe long Min_V64s_S64s ( long *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe ulong Min_V64u_S64u ( ulong *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe float Min_V32f_S32f ( float *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe double Min_V64f_S64f ( double *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose minimum will be computed.
lengthLength of the array specified by v. Must be non-zero.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative or length is zero.
static unsafe void Min_V8sV8s_V8s ( sbyte *  x,
sbyte *  y,
sbyte *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 8-bit integer elements.
yPointer to the second array of signed 8-bit integer elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V8uV8u_V8u ( byte *  x,
byte *  y,
byte *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 8-bit integer elements.
yPointer to the second array of unsigned 8-bit integer elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V16sV16s_V16s ( short *  x,
short *  y,
short *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 16-bit integer elements.
yPointer to the second array of signed 16-bit integer elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.DataMisalignedExceptionIf x, y or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V16uV16u_V16u ( ushort *  x,
ushort *  y,
ushort *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 16-bit integer elements.
yPointer to the second array of unsigned 16-bit integer elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.DataMisalignedExceptionIf x, y or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V32sV32s_V32s ( int *  x,
int *  y,
int *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 32-bit integer elements.
yPointer to the second array of signed 32-bit integer elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.DataMisalignedExceptionIf x, y or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V32uV32u_V32u ( uint *  x,
uint *  y,
uint *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 32-bit integer elements.
yPointer to the second array of unsigned 32-bit integer elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.DataMisalignedExceptionIf x, y or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V64sV32s_V64s ( long *  x,
int *  y,
long *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 64-bit integer elements.
yPointer to the second array of signed 32-bit integer elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.DataMisalignedExceptionIf x, y or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V64uV32u_V64u ( ulong *  x,
uint *  y,
ulong *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 64-bit integer elements.
yPointer to the second array of unsigned 32-bit integer elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.DataMisalignedExceptionIf x, y or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V32fV32f_V32f ( float *  x,
float *  y,
float *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of single precision (32-bit) floating-point elements.
yPointer to the second array of single precision (32-bit) floating-point elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.DataMisalignedExceptionIf x, y or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V64fV64f_V64f ( double *  x,
double *  y,
double *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of double precision (64-bit) floating-point elements.
yPointer to the second array of double precision (64-bit) floating-point elements.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x, y or minimum is null.
System.DataMisalignedExceptionIf x, y or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V8sS8s_V8s ( sbyte *  x,
sbyte  y,
sbyte *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 8-bit integer elements.
yThe signed 8-bit integer constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V8uS8u_V8u ( byte *  x,
byte  y,
byte *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 8-bit integer elements.
yThe unsigned 8-bit integer constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V16sS16s_V16s ( short *  x,
short  y,
short *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 16-bit integer elements.
yThe signed 16-bit integer constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.DataMisalignedExceptionIf x or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V16uS16u_V16u ( ushort *  x,
ushort  y,
ushort *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 16-bit integer elements.
yThe unsigned 16-bit integer constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.DataMisalignedExceptionIf x or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V32sS32s_V32s ( int *  x,
int  y,
int *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 32-bit integer elements.
yThe signed 32-bit integer constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.DataMisalignedExceptionIf x or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V32uS32u_V32u ( uint *  x,
uint  y,
uint *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 32-bit integer elements.
yThe unsigned 32-bit integer constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.DataMisalignedExceptionIf x or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V64sS32s_V64s ( long *  x,
int  y,
long *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 64-bit integer elements.
yThe signed 32-bit integer constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.DataMisalignedExceptionIf x or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V64uS32u_V64u ( ulong *  x,
uint  y,
ulong *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 64-bit integer elements.
yThe unsigned 32-bit integer constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.DataMisalignedExceptionIf x or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V32fS32f_V32f ( float *  x,
float  y,
float *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.DataMisalignedExceptionIf x or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_V64fS64f_V64f ( double *  x,
double  y,
double *  minimum,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant.
minimumPointer to the array of pairwise minimum elements.
lengthLength of the arrays specified by x, y, and minimum.
Exceptions
System.NullReferenceExceptionIf x or minimum is null.
System.DataMisalignedExceptionIf x or minimum is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV8sV8s_IV8s ( sbyte *  x,
sbyte *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 8-bit integer elements.
yPointer to the second array of signed 8-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV8uV8u_IV8u ( byte *  x,
byte *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 8-bit integer elements.
yPointer to the second array of unsigned 8-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV16sV16s_IV16s ( short *  x,
short *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 16-bit integer elements.
yPointer to the second array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV16uV16u_IV16u ( ushort *  x,
ushort *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 16-bit integer elements.
yPointer to the second array of unsigned 16-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV32sV32s_IV32s ( int *  x,
int *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 32-bit integer elements.
yPointer to the second array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV32uV32u_IV32u ( uint *  x,
uint *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 32-bit integer elements.
yPointer to the second array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV64sV32s_IV64s ( long *  x,
int *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of signed 64-bit integer elements.
yPointer to the second array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV64uV32u_IV64u ( ulong *  x,
uint *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of unsigned 64-bit integer elements.
yPointer to the second array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV32fV32f_IV32f ( float *  x,
float *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of single precision (32-bit) floating-point elements.
yPointer to the second array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV64fV64f_IV64f ( double *  x,
double *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first array of double precision (64-bit) floating-point elements.
yPointer to the second array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV8sS8s_IV8s ( sbyte *  x,
sbyte  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of signed 8-bit integer elements.
yThe signed 8-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV8uS8u_IV8u ( byte *  x,
byte  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of unsigned 8-bit integer elements.
yThe unsigned 8-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV16sS16s_IV16s ( short *  x,
short  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of signed 16-bit integer elements.
yThe signed 16-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV16uS16u_IV16u ( ushort *  x,
ushort  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of unsigned 16-bit integer elements.
yThe unsigned 16-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV32sS32s_IV32s ( int *  x,
int  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of signed 32-bit integer elements.
yThe signed 32-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV32uS32u_IV32u ( uint *  x,
uint  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of unsigned 32-bit integer elements.
yThe unsigned 32-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV64sS32s_IV64s ( long *  x,
int  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of signed 64-bit integer elements.
yThe signed 32-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV64uS32u_IV64u ( ulong *  x,
uint  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of unsigned 64-bit integer elements.
yThe unsigned 32-bit integer constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV32fS32f_IV32f ( float *  x,
float  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Min_IV64fS64f_IV64f ( double *  x,
double  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V8sV8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
sbyte[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V8sV8s_V16s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
short[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V8uV8u_V16u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
ushort[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf xArray, yArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V16sV16s_V32s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf xArray, yArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V16uV16u_V32u ( ushort[]  xArray,
int  xOffset,
ushort[]  yArray,
int  yOffset,
uint[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf xArray, yArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf xArray, yArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V32sV32s_V64s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf xArray, yArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V32uV32u_V64u ( uint[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
ulong[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf xArray, yArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V64sV64s_V64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
long[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf xArray, yArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf xArray, yArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or productArray is null.
System.DataMisalignedExceptionIf xArray, yArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V8sS8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
sbyte[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V8sS8s_V16s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
short[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V8uS8u_V16u ( byte[]  xArray,
int  xOffset,
byte  y,
ushort[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf xArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V16sS16s_V32s ( short[]  xArray,
int  xOffset,
short  y,
int[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf xArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V16uS16u_V32u ( ushort[]  xArray,
int  xOffset,
ushort  y,
uint[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf xArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf xArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V32sS32s_V64s ( int[]  xArray,
int  xOffset,
int  y,
long[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf xArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V32uS32u_V64u ( uint[]  xArray,
int  xOffset,
uint  y,
ulong[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf xArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V64sS64s_V64s ( long[]  xArray,
int  xOffset,
long  y,
long[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf xArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf xArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  productArray,
int  productOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or productArray is null.
System.DataMisalignedExceptionIf xArray or productArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, productOffset is negative, productOffset + length exceeds the length of productArray, or length is negative.
static unsafe void Multiply_IV8sV8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Multiply_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Multiply_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Multiply_IV64sV64s_IV64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Multiply_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Multiply_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Multiply_IV8sS8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Multiply_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Multiply_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Multiply_IV64sS64s_IV64s ( long[]  xArray,
int  xOffset,
long  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Multiply_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Multiply_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Multiply_V8sV8s_V8s ( sbyte *  x,
sbyte *  y,
sbyte *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 8-bit integer elements.
yPointer to the second factor array of signed 8-bit integer elements.
productPointer to the product array of signed 8-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V8sV8s_V16s ( sbyte *  x,
sbyte *  y,
short *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 8-bit integer elements.
yPointer to the second factor array of signed 8-bit integer elements.
productPointer to the product array of signed 16-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V8uV8u_V16u ( byte *  x,
byte *  y,
ushort *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of unsigned 8-bit integer elements.
yPointer to the second factor array of unsigned 8-bit integer elements.
productPointer to the product array of unsigned 16-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V16sV16s_V16s ( short *  x,
short *  y,
short *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 16-bit integer elements.
yPointer to the second factor array of signed 16-bit integer elements.
productPointer to the product array of signed 16-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf x, y or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V16sV16s_V32s ( short *  x,
short *  y,
int *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 16-bit integer elements.
yPointer to the second factor array of signed 16-bit integer elements.
productPointer to the product array of signed 32-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf x, y or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V16uV16u_V32u ( ushort *  x,
ushort *  y,
uint *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of unsigned 16-bit integer elements.
yPointer to the second factor array of unsigned 16-bit integer elements.
productPointer to the product array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf x, y or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V32sV32s_V32s ( int *  x,
int *  y,
int *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 32-bit integer elements.
yPointer to the second factor array of signed 32-bit integer elements.
productPointer to the product array of signed 32-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf x, y or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V32sV32s_V64s ( int *  x,
int *  y,
long *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 32-bit integer elements.
yPointer to the second factor array of signed 32-bit integer elements.
productPointer to the product array of signed 64-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf x, y or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V32uV32u_V64u ( uint *  x,
uint *  y,
ulong *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of unsigned 32-bit integer elements.
yPointer to the second factor array of unsigned 32-bit integer elements.
productPointer to the product array of unsigned 64-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf x, y or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V64sV64s_V64s ( long *  x,
long *  y,
long *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 64-bit integer elements.
yPointer to the second factor array of signed 64-bit integer elements.
productPointer to the product array of signed 64-bit integer elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf x, y or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V32fV32f_V32f ( float *  x,
float *  y,
float *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of single precision (32-bit) floating-point elements.
yPointer to the second factor array of single precision (32-bit) floating-point elements.
productPointer to the product array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf x, y or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V64fV64f_V64f ( double *  x,
double *  y,
double *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of double precision (64-bit) floating-point elements.
yPointer to the second factor array of double precision (64-bit) floating-point elements.
productPointer to the product array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x, y, and product.
Exceptions
System.NullReferenceExceptionIf x, y or product is null.
System.DataMisalignedExceptionIf x, y or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V8sS8s_V8s ( sbyte *  x,
sbyte  y,
sbyte *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 8-bit integer elements.
yThe signed 8-bit integer constant to be multiplied by.
productPointer to the product array of signed 8-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V8sS8s_V16s ( sbyte *  x,
sbyte  y,
short *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 8-bit integer elements.
yThe signed 8-bit integer constant to be multiplied by.
productPointer to the product array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V8uS8u_V16u ( byte *  x,
byte  y,
ushort *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of unsigned 8-bit integer elements.
yThe unsigned 8-bit integer constant to be multiplied by.
productPointer to the product array of unsigned 16-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V16sS16s_V16s ( short *  x,
short  y,
short *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 16-bit integer elements.
yThe signed 16-bit integer constant to be multiplied by.
productPointer to the product array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf x or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V16sS16s_V32s ( short *  x,
short  y,
int *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 16-bit integer elements.
yThe signed 16-bit integer constant to be multiplied by.
productPointer to the product array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf x or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V16uS16u_V32u ( ushort *  x,
ushort  y,
uint *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of unsigned 16-bit integer elements.
yThe unsigned 16-bit integer constant to be multiplied by.
productPointer to the product array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf x or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V32sS32s_V32s ( int *  x,
int  y,
int *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 32-bit integer elements.
yThe signed 32-bit integer constant to be multiplied by.
productPointer to the product array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf x or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V32sS32s_V64s ( int *  x,
int  y,
long *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 32-bit integer elements.
yThe signed 32-bit integer constant to be multiplied by.
productPointer to the product array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf x or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V32uS32u_V64u ( uint *  x,
uint  y,
ulong *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of unsigned 32-bit integer elements.
yThe unsigned 32-bit integer constant to be multiplied by.
productPointer to the product array of unsigned 64-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf x or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V64sS64s_V64s ( long *  x,
long  y,
long *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 64-bit integer elements.
yThe signed 64-bit integer constant to be multiplied by.
productPointer to the product array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf x or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V32fS32f_V32f ( float *  x,
float  y,
float *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant to be multiplied by.
productPointer to the product array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf x or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_V64fS64f_V64f ( double *  x,
double  y,
double *  product,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant to be multiplied by.
productPointer to the product array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x and product.
Exceptions
System.NullReferenceExceptionIf x or product is null.
System.DataMisalignedExceptionIf x or product is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV8sV8s_IV8s ( sbyte *  x,
sbyte *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 8-bit integer elements.
yPointer to the second factor array of signed 8-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV16sV16s_IV16s ( short *  x,
short *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 16-bit integer elements.
yPointer to the second factor array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV32sV32s_IV32s ( int *  x,
int *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 32-bit integer elements.
yPointer to the second factor array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV64sV64s_IV64s ( long *  x,
long *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of signed 64-bit integer elements.
yPointer to the second factor array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV32fV32f_IV32f ( float *  x,
float *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of single precision (32-bit) floating-point elements.
yPointer to the second factor array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV64fV64f_IV64f ( double *  x,
double *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the first factor array of double precision (64-bit) floating-point elements.
yPointer to the second factor array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV8sS8s_IV8s ( sbyte *  x,
sbyte  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 8-bit integer elements.
yThe signed 8-bit integer constant factor.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV16sS16s_IV16s ( short *  x,
short  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 16-bit integer elements.
yThe signed 16-bit integer constant factor.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV32sS32s_IV32s ( int *  x,
int  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 32-bit integer elements.
yThe signed 32-bit integer constant factor.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV64sS64s_IV64s ( long *  x,
long  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of signed 64-bit integer elements.
yThe signed 64-bit integer constant factor.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV32fS32f_IV32f ( float *  x,
float  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant factor.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Multiply_IV64fS64f_IV64f ( double *  x,
double  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the factor array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant factor.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_V8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

Negates elements in signed 8-bit integer array.

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Negate_V16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

Negates elements in signed 16-bit integer array.

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Negate_V32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

Negates elements in signed 32-bit integer array.

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Negate_V64s_V64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

Negates elements in signed 64-bit integer array.

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Negate_V32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Negate_V64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Negate_IV8s_IV8s ( sbyte[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe void Negate_IV16s_IV16s ( short[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe void Negate_IV32s_IV32s ( int[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe void Negate_IV64s_IV64s ( long[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe void Negate_IV32f_IV32f ( float[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe void Negate_IV64f_IV64f ( double[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe void Negate_V8s_V8s ( sbyte *  x,
sbyte *  y,
int  length 
)
inlinestatic

Negates elements in signed 8-bit integer array.

Parameters
xPointer to the array of signed 8-bit integer elements to be negated.
yPointer to the signed 8-bit integer array to store negated elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_V16s_V16s ( short *  x,
short *  y,
int  length 
)
inlinestatic

Negates elements in signed 16-bit integer array.

Parameters
xPointer to the array of signed 16-bit integer elements to be negated.
yPointer to the signed 16-bit integer array to store negated elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_V32s_V32s ( int *  x,
int *  y,
int  length 
)
inlinestatic

Negates elements in signed 32-bit integer array.

Parameters
xPointer to the array of signed 32-bit integer elements to be negated.
yPointer to the signed 32-bit integer array to store negated elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_V64s_V64s ( long *  x,
long *  y,
int  length 
)
inlinestatic

Negates elements in signed 64-bit integer array.

Parameters
xPointer to the array of signed 64-bit integer elements to be negated.
yPointer to the signed 64-bit integer array to store negated elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_V32f_V32f ( float *  x,
float *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of single precision (32-bit) floating-point elements to be negated.
yPointer to the single precision (32-bit) floating-point array to store negated elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_V64f_V64f ( double *  x,
double *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the array of double precision (64-bit) floating-point elements to be negated.
yPointer to the double precision (64-bit) floating-point array to store negated elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_IV8s_IV8s ( sbyte *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of signed 8-bit integer elements to be negated.
lengthLength of the array specified by v.
Exceptions
System.NullReferenceExceptionIf v is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_IV16s_IV16s ( short *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of signed 16-bit integer elements to be negated.
lengthLength of the array specified by v.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_IV32s_IV32s ( int *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of signed 32-bit integer elements to be negated.
lengthLength of the array specified by v.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_IV64s_IV64s ( long *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of signed 64-bit integer elements to be negated.
lengthLength of the array specified by v.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_IV32f_IV32f ( float *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of single precision (32-bit) floating-point elements to be negated.
lengthLength of the array specified by v.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Negate_IV64f_IV64f ( double *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of double precision (64-bit) floating-point elements to be negated.
lengthLength of the array specified by v.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V8sV8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
sbyte[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V8sV8s_V16s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V8uV8u_V16u ( byte[]  xArray,
int  xOffset,
byte[]  yArray,
int  yOffset,
ushort[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V16sV16s_V16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf xArray, yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V16sV16s_V32s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf xArray, yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V16uV16u_V32u ( ushort[]  xArray,
int  xOffset,
ushort[]  yArray,
int  yOffset,
uint[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf xArray, yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V32sV32s_V32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf xArray, yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V32sV32s_V64s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf xArray, yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V32uV32u_V64u ( uint[]  xArray,
int  xOffset,
uint[]  yArray,
int  yOffset,
ulong[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf xArray, yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V64sV64s_V64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf xArray, yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V32fV32f_V32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
float[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf xArray, yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V64fV64f_V64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
double[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray, yArray or diffArray is null.
System.DataMisalignedExceptionIf xArray, yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V8sS8s_V8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
sbyte[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V8sS8s_V16s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
short[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V8uS8u_V16u ( byte[]  xArray,
int  xOffset,
byte  y,
ushort[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V16sS16s_V16s ( short[]  xArray,
int  xOffset,
short  y,
short[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf xArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V16sS16s_V32s ( short[]  xArray,
int  xOffset,
short  y,
int[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf xArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V16uS16u_V32u ( ushort[]  xArray,
int  xOffset,
ushort  y,
uint[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf xArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V32sS32s_V32s ( int[]  xArray,
int  xOffset,
int  y,
int[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf xArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V32sS32s_V64s ( int[]  xArray,
int  xOffset,
int  y,
long[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf xArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V32uS32u_V64u ( uint[]  xArray,
int  xOffset,
uint  y,
ulong[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf xArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V64sS64s_V64s ( long[]  xArray,
int  xOffset,
long  y,
long[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf xArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V32fS32f_V32f ( float[]  xArray,
int  xOffset,
float  y,
float[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf xArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_V64fS64f_V64f ( double[]  xArray,
int  xOffset,
double  y,
double[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or diffArray is null.
System.DataMisalignedExceptionIf xArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S8sV8s_V8s ( sbyte  x,
sbyte[]  yArray,
int  yOffset,
sbyte[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S8sV8s_V16s ( sbyte  x,
sbyte[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S8uV8u_V16u ( byte  x,
byte[]  yArray,
int  yOffset,
ushort[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S16sV16s_V16s ( short  x,
short[]  yArray,
int  yOffset,
short[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S16sV16s_V32s ( short  x,
short[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S16uV16u_V32u ( ushort  x,
ushort[]  yArray,
int  yOffset,
uint[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S32sV32s_V32s ( int  x,
int[]  yArray,
int  yOffset,
int[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S32sV32s_V64s ( int  x,
int[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S32uV32u_V64u ( uint  x,
uint[]  yArray,
int  yOffset,
ulong[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S64sV64s_V64s ( long  x,
long[]  yArray,
int  yOffset,
long[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S32fV32f_V32f ( float  x,
float[]  yArray,
int  yOffset,
float[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_S64fV64f_V64f ( double  x,
double[]  yArray,
int  yOffset,
double[]  diffArray,
int  diffOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray or diffArray is null.
System.DataMisalignedExceptionIf yArray or diffArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, diffOffset is negative, diffOffset + length exceeds the length of diffArray, or length is negative.
static unsafe void Subtract_IV8sV8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_IV16sV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_IV32sV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_IV64sV64s_IV64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_IV32fV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_IV64fV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_V8sIV8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_V16sIV16s_IV16s ( short[]  xArray,
int  xOffset,
short[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_V32sIV32s_IV32s ( int[]  xArray,
int  xOffset,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_V64sIV64s_IV64s ( long[]  xArray,
int  xOffset,
long[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_V32fIV32f_IV32f ( float[]  xArray,
int  xOffset,
float[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_V64fIV64f_IV64f ( double[]  xArray,
int  xOffset,
double[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray or yArray is null.
System.DataMisalignedExceptionIf xArray or yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_IV8sS8s_IV8s ( sbyte[]  xArray,
int  xOffset,
sbyte  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Subtract_IV16sS16s_IV16s ( short[]  xArray,
int  xOffset,
short  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Subtract_IV32sS32s_IV32s ( int[]  xArray,
int  xOffset,
int  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Subtract_IV64sS64s_IV64s ( long[]  xArray,
int  xOffset,
long  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Subtract_IV32fS32f_IV32f ( float[]  xArray,
int  xOffset,
float  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Subtract_IV64fS64f_IV64f ( double[]  xArray,
int  xOffset,
double  y,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf xArray is null.
System.DataMisalignedExceptionIf xArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf xOffset is negative, xOffset + length exceeds the length of xArray, or length is negative.
static unsafe void Subtract_S8sIV8s_IV8s ( sbyte  x,
sbyte[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray is null.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_S16sIV16s_IV16s ( short  x,
short[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray is null.
System.DataMisalignedExceptionIf yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_S32sIV32s_IV32s ( int  x,
int[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray is null.
System.DataMisalignedExceptionIf yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_S64sIV64s_IV64s ( long  x,
long[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray is null.
System.DataMisalignedExceptionIf yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_S32fIV32f_IV32f ( float  x,
float[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray is null.
System.DataMisalignedExceptionIf yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_S64fIV64f_IV64f ( double  x,
double[]  yArray,
int  yOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf yArray is null.
System.DataMisalignedExceptionIf yArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf yOffset is negative, yOffset + length exceeds the length of yArray, or length is negative.
static unsafe void Subtract_V8sV8s_V8s ( sbyte *  x,
sbyte *  y,
sbyte *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 8-bit integer elements.
yPointer to the subtrahend array of signed 8-bit integer elements.
diffPointer to the difference array of signed 8-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V8sV8s_V16s ( sbyte *  x,
sbyte *  y,
short *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 8-bit integer elements.
yPointer to the subtrahend array of signed 8-bit integer elements.
diffPointer to the difference array of signed 16-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V8uV8u_V16u ( byte *  x,
byte *  y,
ushort *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of unsigned 8-bit integer elements.
yPointer to the subtrahend array of unsigned 8-bit integer elements.
diffPointer to the difference array of unsigned 16-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V16sV16s_V16s ( short *  x,
short *  y,
short *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 16-bit integer elements.
yPointer to the subtrahend array of signed 16-bit integer elements.
diffPointer to the difference array of signed 16-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf x, y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V16sV16s_V32s ( short *  x,
short *  y,
int *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 16-bit integer elements.
yPointer to the subtrahend array of signed 16-bit integer elements.
diffPointer to the difference array of signed 32-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf x, y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V16uV16u_V32u ( ushort *  x,
ushort *  y,
uint *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of unsigned 16-bit integer elements.
yPointer to the subtrahend array of unsigned 16-bit integer elements.
diffPointer to the difference array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf x, y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32sV32s_V32s ( int *  x,
int *  y,
int *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 32-bit integer elements.
yPointer to the subtrahend array of signed 32-bit integer elements.
diffPointer to the difference array of signed 32-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf x, y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32sV32s_V64s ( int *  x,
int *  y,
long *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 32-bit integer elements.
yPointer to the subtrahend array of signed 32-bit integer elements.
diffPointer to the difference array of signed 64-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf x, y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32uV32u_V64u ( uint *  x,
uint *  y,
ulong *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of unsigned 32-bit integer elements.
yPointer to the subtrahend array of unsigned 32-bit integer elements.
diffPointer to the difference array of unsigned 64-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf x, y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V64sV64s_V64s ( long *  x,
long *  y,
long *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 64-bit integer elements.
yPointer to the subtrahend array of signed 64-bit integer elements.
diffPointer to the difference array of signed 64-bit integer elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf x, y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32fV32f_V32f ( float *  x,
float *  y,
float *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of single precision (32-bit) floating-point elements.
yPointer to the subtrahend array of single precision (32-bit) floating-point elements.
diffPointer to the difference array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf x, y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V64fV64f_V64f ( double *  x,
double *  y,
double *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of double precision (64-bit) floating-point elements.
yPointer to the subtrahend array of double precision (64-bit) floating-point elements.
diffPointer to the difference array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x, y, and diff.
Exceptions
System.NullReferenceExceptionIf x, y or diff is null.
System.DataMisalignedExceptionIf x, y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V8sS8s_V8s ( sbyte *  x,
sbyte  y,
sbyte *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 8-bit integer elements.
yThe signed 8-bit integer constant to be subtracted.
diffPointer to the difference array of signed 8-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V8sS8s_V16s ( sbyte *  x,
sbyte  y,
short *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 8-bit integer elements.
yThe signed 8-bit integer constant to be subtracted.
diffPointer to the difference array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V8uS8u_V16u ( byte *  x,
byte  y,
ushort *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of unsigned 8-bit integer elements.
yThe unsigned 8-bit integer constant to be subtracted.
diffPointer to the difference array of unsigned 16-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V16sS16s_V16s ( short *  x,
short  y,
short *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 16-bit integer elements.
yThe signed 16-bit integer constant to be subtracted.
diffPointer to the difference array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf x or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V16sS16s_V32s ( short *  x,
short  y,
int *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 16-bit integer elements.
yThe signed 16-bit integer constant to be subtracted.
diffPointer to the difference array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf x or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V16uS16u_V32u ( ushort *  x,
ushort  y,
uint *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of unsigned 16-bit integer elements.
yThe unsigned 16-bit integer constant to be subtracted.
diffPointer to the difference array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf x or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32sS32s_V32s ( int *  x,
int  y,
int *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 32-bit integer elements.
yThe signed 32-bit integer constant to be subtracted.
diffPointer to the difference array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf x or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32sS32s_V64s ( int *  x,
int  y,
long *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 32-bit integer elements.
yThe signed 32-bit integer constant to be subtracted.
diffPointer to the difference array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf x or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32uS32u_V64u ( uint *  x,
uint  y,
ulong *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of unsigned 32-bit integer elements.
yThe unsigned 32-bit integer constant to be subtracted.
diffPointer to the difference array of unsigned 64-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf x or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V64sS64s_V64s ( long *  x,
long  y,
long *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 64-bit integer elements.
yThe signed 64-bit integer constant to be subtracted.
diffPointer to the difference array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf x or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32fS32f_V32f ( float *  x,
float  y,
float *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant to be subtracted.
diffPointer to the difference array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf x or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V64fS64f_V64f ( double *  x,
double  y,
double *  diff,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant to be subtracted.
diffPointer to the difference array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x and diff.
Exceptions
System.NullReferenceExceptionIf x or diff is null.
System.DataMisalignedExceptionIf x or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S8sV8s_V8s ( sbyte  x,
sbyte *  y,
sbyte *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe signed 8-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 8-bit integer elements.
diffPointer to the difference array of signed 8-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S8sV8s_V16s ( sbyte  x,
sbyte *  y,
short *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe signed 8-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 8-bit integer elements.
diffPointer to the difference array of signed 16-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S8uV8u_V16u ( byte  x,
byte *  y,
ushort *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe unsigned 8-bit integer constant to be subtracted from.
yPointer to the subtrahend array of unsigned 8-bit integer elements.
diffPointer to the difference array of unsigned 16-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S16sV16s_V16s ( short  x,
short *  y,
short *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe signed 16-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 16-bit integer elements.
diffPointer to the difference array of signed 16-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S16sV16s_V32s ( short  x,
short *  y,
int *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe signed 16-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 16-bit integer elements.
diffPointer to the difference array of signed 32-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S16uV16u_V32u ( ushort  x,
ushort *  y,
uint *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe unsigned 16-bit integer constant to be subtracted from.
yPointer to the subtrahend array of unsigned 16-bit integer elements.
diffPointer to the difference array of unsigned 32-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S32sV32s_V32s ( int  x,
int *  y,
int *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe signed 32-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 32-bit integer elements.
diffPointer to the difference array of signed 32-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S32sV32s_V64s ( int  x,
int *  y,
long *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe signed 32-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 32-bit integer elements.
diffPointer to the difference array of signed 64-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S32uV32u_V64u ( uint  x,
uint *  y,
ulong *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe unsigned 32-bit integer constant to be subtracted from.
yPointer to the subtrahend array of unsigned 32-bit integer elements.
diffPointer to the difference array of unsigned 64-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S64sV64s_V64s ( long  x,
long *  y,
long *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe signed 64-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 64-bit integer elements.
diffPointer to the difference array of signed 64-bit integer elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S32fV32f_V32f ( float  x,
float *  y,
float *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe single precision (32-bit) floating-point constant to be subtracted from.
yPointer to the subtrahend array of single precision (32-bit) floating-point elements.
diffPointer to the difference array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S64fV64f_V64f ( double  x,
double *  y,
double *  diff,
int  length 
)
inlinestatic

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

Parameters
xThe double precision (64-bit) floating-point constant to be subtracted from.
yPointer to the subtrahend array of double precision (64-bit) floating-point elements.
diffPointer to the difference array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by y and diff.
Exceptions
System.NullReferenceExceptionIf y or diff is null.
System.DataMisalignedExceptionIf y or diff is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV8sV8s_IV8s ( sbyte *  x,
sbyte *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 8-bit integer elements.
yPointer to the subtrahend array of signed 8-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV16sV16s_IV16s ( short *  x,
short *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 16-bit integer elements.
yPointer to the subtrahend array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV32sV32s_IV32s ( int *  x,
int *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 32-bit integer elements.
yPointer to the subtrahend array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV64sV64s_IV64s ( long *  x,
long *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 64-bit integer elements.
yPointer to the subtrahend array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV32fV32f_IV32f ( float *  x,
float *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of single precision (32-bit) floating-point elements.
yPointer to the subtrahend array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV64fV64f_IV64f ( double *  x,
double *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of double precision (64-bit) floating-point elements.
yPointer to the subtrahend array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V8sIV8s_IV8s ( sbyte *  x,
sbyte *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 8-bit integer elements.
yPointer to the subtrahend array of signed 8-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V16sIV16s_IV16s ( short *  x,
short *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 16-bit integer elements.
yPointer to the subtrahend array of signed 16-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32sIV32s_IV32s ( int *  x,
int *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 32-bit integer elements.
yPointer to the subtrahend array of signed 32-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V64sIV64s_IV64s ( long *  x,
long *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 64-bit integer elements.
yPointer to the subtrahend array of signed 64-bit integer elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V32fIV32f_IV32f ( float *  x,
float *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of single precision (32-bit) floating-point elements.
yPointer to the subtrahend array of single precision (32-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_V64fIV64f_IV64f ( double *  x,
double *  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of double precision (64-bit) floating-point elements.
yPointer to the subtrahend array of double precision (64-bit) floating-point elements.
lengthLength of the arrays specified by x and y.
Exceptions
System.NullReferenceExceptionIf x or y is null.
System.DataMisalignedExceptionIf x or y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV8sS8s_IV8s ( sbyte *  x,
sbyte  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 8-bit integer elements.
yThe signed 8-bit integer constant to be subtracted.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV16sS16s_IV16s ( short *  x,
short  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 16-bit integer elements.
yThe signed 16-bit integer constant to be subtracted.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV32sS32s_IV32s ( int *  x,
int  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 32-bit integer elements.
yThe signed 32-bit integer constant to be subtracted.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV64sS64s_IV64s ( long *  x,
long  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of signed 64-bit integer elements.
yThe signed 64-bit integer constant to be subtracted.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV32fS32f_IV32f ( float *  x,
float  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of single precision (32-bit) floating-point elements.
yThe single precision (32-bit) floating-point constant to be subtracted.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_IV64fS64f_IV64f ( double *  x,
double  y,
int  length 
)
inlinestatic

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

Parameters
xPointer to the minuend array of double precision (64-bit) floating-point elements.
yThe double precision (64-bit) floating-point constant to be subtracted.
lengthLength of the array specified by x.
Exceptions
System.NullReferenceExceptionIf x is null.
System.DataMisalignedExceptionIf x is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S8sIV8s_IV8s ( sbyte  x,
sbyte *  y,
int  length 
)
inlinestatic

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

Parameters
xThe signed 8-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 8-bit integer elements.
lengthLength of the array specified by y.
Exceptions
System.NullReferenceExceptionIf y is null.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S16sIV16s_IV16s ( short  x,
short *  y,
int  length 
)
inlinestatic

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

Parameters
xThe signed 16-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 16-bit integer elements.
lengthLength of the array specified by y.
Exceptions
System.NullReferenceExceptionIf y is null.
System.DataMisalignedExceptionIf y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S32sIV32s_IV32s ( int  x,
int *  y,
int  length 
)
inlinestatic

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

Parameters
xThe signed 32-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 32-bit integer elements.
lengthLength of the array specified by y.
Exceptions
System.NullReferenceExceptionIf y is null.
System.DataMisalignedExceptionIf y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S64sIV64s_IV64s ( long  x,
long *  y,
int  length 
)
inlinestatic

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

Parameters
xThe signed 64-bit integer constant to be subtracted from.
yPointer to the subtrahend array of signed 64-bit integer elements.
lengthLength of the array specified by y.
Exceptions
System.NullReferenceExceptionIf y is null.
System.DataMisalignedExceptionIf y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S32fIV32f_IV32f ( float  x,
float *  y,
int  length 
)
inlinestatic

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

Parameters
xThe single precision (32-bit) floating-point constant to be subtracted from.
yPointer to the subtrahend array of single precision (32-bit) floating-point elements.
lengthLength of the array specified by y.
Exceptions
System.NullReferenceExceptionIf y is null.
System.DataMisalignedExceptionIf y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe void Subtract_S64fIV64f_IV64f ( double  x,
double *  y,
int  length 
)
inlinestatic

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

Parameters
xThe double precision (64-bit) floating-point constant to be subtracted from.
yPointer to the subtrahend array of double precision (64-bit) floating-point elements.
lengthLength of the array specified by y.
Exceptions
System.NullReferenceExceptionIf y is null.
System.DataMisalignedExceptionIf y is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe float Sum_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe double Sum_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe float Sum_V32f_S32f ( float *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements which will be summed up.
lengthLength of the array specified by v. If length is zero, the computed sum will be 0.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe double Sum_V64f_S64f ( double *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements which will be summed up.
lengthLength of the array specified by v. If length is zero, the computed sum will be 0.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe float SumAbs_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe double SumAbs_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe float SumAbs_V32f_S32f ( float *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose absolute values will be summed up.
lengthLength of the array specified by v. If length is zero, the computed sum will be 0.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe double SumAbs_V64f_S64f ( double *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements whose absolute values will be summed up.
lengthLength of the array specified by v. If length is zero, the computed sum will be 0.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe float SumSquares_V32f_S32f ( float[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe double SumSquares_V64f_S64f ( double[]  vArray,
int  vOffset,
int  length 
)
inlinestatic

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

Exceptions
System.NullReferenceExceptionIf vArray is null.
System.DataMisalignedExceptionIf vArray is not naturally aligned.
System.ArgumentExceptionIf length is negative.
System.IndexOutOfRangeExceptionIf vOffset is negative, vOffset + length exceeds the length of vArray, or length is negative.
static unsafe float SumSquares_V32f_S32f ( float *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements which will be squared (without write-back) and summed up.
lengthLength of the array specified by v. If length is zero, the computed sum of squares will be 0.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.
static unsafe double SumSquares_V64f_S64f ( double *  v,
int  length 
)
inlinestatic

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

Parameters
vPointer to the array of elements which will be squared (without write-back) and summed up.
lengthLength of the array specified by v. If length is zero, the computed sum of squares will be 0.
Exceptions
System.NullReferenceExceptionIf v is null.
System.DataMisalignedExceptionIf v is not naturally aligned.
System.ArgumentExceptionIf length is negative.