Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

edu.mines.jtk.util
Class Array

java.lang.Object
  extended by edu.mines.jtk.util.Array

public class Array
extends java.lang.Object

Utilities and math for arrays of real and complex values.

A real array rx is an array of numeric values, in which each value represents one real number. A complex array is an array of float or double values, in which each consecutive pair of values represents the real and imaginary parts of one complex number. This means that a complex array cx contains cx.length/2 complex numbers, and cx.length is an even number. For example, the length of a 1-D complex array cx with dimension n1 is cx.length = 2*n1; i.e., n1 is the number of complex elements in the array.

Methods are overloaded for 1-D arrays, 2-D arrays (arrays of arrays), and 3-D arrays (arrays of arrays of arrays). Multi-dimensional arrays can be regular or ragged. For example, the dimensions of a regular 3-D array float[n3][n2][n1] are n1, n2, and n3, where n1 is the fastest dimension, and n3 is the slowest dimension. In contrast, the lengths of arrays within a ragged array of arrays (of arrays) may vary.

Some methods that create new arrays (e.g., zero, fill, ramp, and rand) have no array arguments; these methods have arguments that specify regular array dimensions n1, n2, and/or n3. All other methods, those with at least one array argument, use the dimensions of the first array argument to determine the number of array elements to process.

Some methods may have arguments that are arrays of real and/or complex numbers. In such cases, arguments with names like rx, ry, and rz denote arrays of real (non-complex) elements. Arguments with names like ra and rb denote real values. Arguments with names like cx, cy, and cz denote arrays of complex elements, and arguments with names like ca and cb denote complex values.

Because complex numbers are packed into arrays of the same types (float or double) as real arrays, method overloading cannot distinguish methods with real array arguments from those with complex array arguments. Therefore, all methods with at least one complex array argument are prefixed with the letter 'c'. For example, the methods mul multiply two arrays of real numbers, and the corresponding methods cmul multiply two arrays of complex numbers. 

 Creation and copy operations:
 zero - fills an array with a constant value zero
 fill - fills an array with a specified constant value
 ramp - fills an array with a linear values ra + rb1*i1 (+ rb2*i2 + rb3*i3)
 rand - fills an array with pseudo-random numbers
 copy - copies an array, or a specified subset of an array
 
 Binary operations:
 add - adds one array (or value) to another array (or value)
 sub - subtracts one array (or value) from another array (or value)
 mul - multiplies one array (or value) by another array (or value)
 div - divides one array (or value) by another array (or value)
 
 Unary operations:
 abs - absolute value
 neg - negation
 cos - cosine
 sin - sine
 sqrt - square-root
 exp - exponential
 log - natural logarithm
 log10 - logarithm base 10
 clip - clip values to be within specified min/max bounds
 pow - raise to a specified power
 sgn - sign (1 if positive, -1 if negative, 0 if zero)
 
 Other operations:
 equal - compares arrays for equality (to within an optional tolerance)
 sum - returns the sum of array values
 max - returns the maximum value in an array and (optionally) its indices
 min - returns the minimum value in an array and (optionally) its indices
 dump - prints an array to standard output

Version:
2005.05.17
Author:
Dave Hale, Colorado School of Mines

Method Summary
static double[] abs(double[] rx)
           
static double[][] abs(double[][] rx)
           
static double[][][] abs(double[][][] rx)
           
static void abs(double[][][] rx, double[][][] ry)
           
static void abs(double[][] rx, double[][] ry)
           
static void abs(double[] rx, double[] ry)
           
static float[] abs(float[] rx)
           
static float[][] abs(float[][] rx)
           
static float[][][] abs(float[][][] rx)
           
static void abs(float[][][] rx, float[][][] ry)
           
static void abs(float[][] rx, float[][] ry)
           
static void abs(float[] rx, float[] ry)
           
static double[][][] add(double[][][] rx, double rb)
           
static double[][][] add(double[][][] rx, double[][][] ry)
           
static void add(double[][][] rx, double[][][] ry, double[][][] rz)
           
static void add(double[][][] rx, double rb, double[][][] rz)
           
static double[][] add(double[][] rx, double rb)
           
static double[][] add(double[][] rx, double[][] ry)
           
static void add(double[][] rx, double[][] ry, double[][] rz)
           
static void add(double[][] rx, double rb, double[][] rz)
           
static double[] add(double[] rx, double rb)
           
static double[] add(double[] rx, double[] ry)
           
static void add(double[] rx, double[] ry, double[] rz)
           
static void add(double[] rx, double rb, double[] rz)
           
static double[] add(double ra, double[] ry)
           
static double[][] add(double ra, double[][] ry)
           
static double[][][] add(double ra, double[][][] ry)
           
static void add(double ra, double[][][] ry, double[][][] rz)
           
static void add(double ra, double[][] ry, double[][] rz)
           
static void add(double ra, double[] ry, double[] rz)
           
static float[][][] add(float[][][] rx, float rb)
           
static float[][][] add(float[][][] rx, float[][][] ry)
           
static void add(float[][][] rx, float[][][] ry, float[][][] rz)
           
static void add(float[][][] rx, float rb, float[][][] rz)
           
static float[][] add(float[][] rx, float rb)
           
static float[][] add(float[][] rx, float[][] ry)
           
static void add(float[][] rx, float[][] ry, float[][] rz)
           
static void add(float[][] rx, float rb, float[][] rz)
           
static float[] add(float[] rx, float rb)
           
static float[] add(float[] rx, float[] ry)
           
static void add(float[] rx, float[] ry, float[] rz)
           
static void add(float[] rx, float rb, float[] rz)
           
static float[] add(float ra, float[] ry)
           
static float[][] add(float ra, float[][] ry)
           
static float[][][] add(float ra, float[][][] ry)
           
static void add(float ra, float[][][] ry, float[][][] rz)
           
static void add(float ra, float[][] ry, float[][] rz)
           
static void add(float ra, float[] ry, float[] rz)
           
static int binarySearch(byte[] a, byte x)
          Performs a binary search in a monotonic array of values.
static int binarySearch(byte[] a, byte x, int i)
          Performs a binary search in a monotonic array of values.
static int binarySearch(double[] a, double x)
          Performs a binary search in a monotonic array of values.
static int binarySearch(double[] a, double x, int i)
          Performs a binary search in a monotonic array of values.
static int binarySearch(float[] a, float x)
          Performs a binary search in a monotonic array of values.
static int binarySearch(float[] a, float x, int i)
          Performs a binary search in a monotonic array of values.
static int binarySearch(int[] a, int x)
          Performs a binary search in a monotonic array of values.
static int binarySearch(int[] a, int x, int i)
          Performs a binary search in a monotonic array of values.
static int binarySearch(long[] a, long x)
          Performs a binary search in a monotonic array of values.
static int binarySearch(long[] a, long x, int i)
          Performs a binary search in a monotonic array of values.
static int binarySearch(short[] a, short x)
          Performs a binary search in a monotonic array of values.
static int binarySearch(short[] a, short x, int i)
          Performs a binary search in a monotonic array of values.
static double[] cabs(double[] cx)
           
static double[][] cabs(double[][] cx)
           
static double[][][] cabs(double[][][] cx)
           
static void cabs(double[][][] cx, double[][][] cy)
           
static void cabs(double[][] cx, double[][] cy)
           
static void cabs(double[] cx, double[] cy)
           
static float[] cabs(float[] cx)
           
static float[][] cabs(float[][] cx)
           
static float[][][] cabs(float[][][] cx)
           
static void cabs(float[][][] cx, float[][][] cy)
           
static void cabs(float[][] cx, float[][] cy)
           
static void cabs(float[] cx, float[] cy)
           
static double[] cadd(Cdouble ca, double[] cy)
           
static double[][] cadd(Cdouble ca, double[][] cy)
           
static double[][][] cadd(Cdouble ca, double[][][] cy)
           
static void cadd(Cdouble ca, double[][][] cy, double[][][] cz)
           
static void cadd(Cdouble ca, double[][] cy, double[][] cz)
           
static void cadd(Cdouble ca, double[] cy, double[] cz)
           
static float[] cadd(Cfloat ca, float[] cy)
           
static float[][] cadd(Cfloat ca, float[][] cy)
           
static float[][][] cadd(Cfloat ca, float[][][] cy)
           
static void cadd(Cfloat ca, float[][][] cy, float[][][] cz)
           
static void cadd(Cfloat ca, float[][] cy, float[][] cz)
           
static void cadd(Cfloat ca, float[] cy, float[] cz)
           
static double[][][] cadd(double[][][] cx, Cdouble cb)
           
static void cadd(double[][][] cx, Cdouble cb, double[][][] cz)
           
static double[][][] cadd(double[][][] cx, double[][][] cy)
           
static void cadd(double[][][] cx, double[][][] cy, double[][][] cz)
           
static double[][] cadd(double[][] cx, Cdouble cb)
           
static void cadd(double[][] cx, Cdouble cb, double[][] cz)
           
static double[][] cadd(double[][] cx, double[][] cy)
           
static void cadd(double[][] cx, double[][] cy, double[][] cz)
           
static double[] cadd(double[] cx, Cdouble cb)
           
static void cadd(double[] cx, Cdouble cb, double[] cz)
           
static double[] cadd(double[] cx, double[] cy)
           
static void cadd(double[] cx, double[] cy, double[] cz)
           
static float[][][] cadd(float[][][] cx, Cfloat cb)
           
static void cadd(float[][][] cx, Cfloat cb, float[][][] cz)
           
static float[][][] cadd(float[][][] cx, float[][][] cy)
           
static void cadd(float[][][] cx, float[][][] cy, float[][][] cz)
           
static float[][] cadd(float[][] cx, Cfloat cb)
           
static void cadd(float[][] cx, Cfloat cb, float[][] cz)
           
static float[][] cadd(float[][] cx, float[][] cy)
           
static void cadd(float[][] cx, float[][] cy, float[][] cz)
           
static float[] cadd(float[] cx, Cfloat cb)
           
static void cadd(float[] cx, Cfloat cb, float[] cz)
           
static float[] cadd(float[] cx, float[] cy)
           
static void cadd(float[] cx, float[] cy, float[] cz)
           
static double[] carg(double[] cx)
           
static double[][] carg(double[][] cx)
           
static double[][][] carg(double[][][] cx)
           
static void carg(double[][][] cx, double[][][] cy)
           
static void carg(double[][] cx, double[][] cy)
           
static void carg(double[] cx, double[] cy)
           
static float[] carg(float[] cx)
           
static float[][] carg(float[][] cx)
           
static float[][][] carg(float[][][] cx)
           
static void carg(float[][][] cx, float[][][] cy)
           
static void carg(float[][] cx, float[][] cy)
           
static void carg(float[] cx, float[] cy)
           
static double[] cconj(double[] cx)
           
static double[][] cconj(double[][] cx)
           
static double[][][] cconj(double[][][] cx)
           
static void cconj(double[][][] cx, double[][][] cy)
           
static void cconj(double[][] cx, double[][] cy)
           
static void cconj(double[] cx, double[] cy)
           
static float[] cconj(float[] cx)
           
static float[][] cconj(float[][] cx)
           
static float[][][] cconj(float[][][] cx)
           
static void cconj(float[][][] cx, float[][][] cy)
           
static void cconj(float[][] cx, float[][] cy)
           
static void cconj(float[] cx, float[] cy)
           
static double[] ccopy(double[] cx)
          Returns array copy of elements from the specified array.
static double[][] ccopy(double[][] cx)
          Returns array copy of elements from the specified array.
static double[][][] ccopy(double[][][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(double[][][] cx, double[][][] cy)
          Copies elements from one specified array to another.
static void ccopy(double[][] cx, double[][] cy)
          Copies elements from one specified array to another.
static void ccopy(double[] cx, double[] cy)
          Copies elements from one specified array to another.
static float[] ccopy(float[] cx)
          Returns array copy of elements from the specified array.
static float[][] ccopy(float[][] cx)
          Returns array copy of elements from the specified array.
static float[][][] ccopy(float[][][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(float[][][] cx, float[][][] cy)
          Copies elements from one specified array to another.
static void ccopy(float[][] cx, float[][] cy)
          Copies elements from one specified array to another.
static void ccopy(float[] cx, float[] cy)
          Copies elements from one specified array to another.
static double[] ccopy(int n1, double[] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, double[] cx, double[] cy)
          Copies elements from one specified array to another.
static float[] ccopy(int n1, float[] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, float[] cx, float[] cy)
          Copies elements from one specified array to another.
static double[] ccopy(int n1, int j1, double[] cx)
          Returns array copy of elements from the specified array.
static double[][] ccopy(int n1, int n2, double[][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, double[][] cx, double[][] cy)
          Copies elements from one specified array to another.
static void ccopy(int n1, int j1x, double[] cx, int j1y, double[] cy)
          Copies elements from one specified array to another.
static float[] ccopy(int n1, int j1, float[] cx)
          Returns array copy of elements from the specified array.
static float[][] ccopy(int n1, int n2, float[][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, float[][] cx, float[][] cy)
          Copies elements from one specified array to another.
static void ccopy(int n1, int j1x, float[] cx, int j1y, float[] cy)
          Copies elements from one specified array to another.
static double[] ccopy(int n1, int j1, int k1, double[] cx)
          Returns array copy of elements from the specified array.
static double[][][] ccopy(int n1, int n2, int n3, double[][][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, int n3, double[][][] cx, double[][][] cy)
          Copies elements from one specified array to another.
static void ccopy(int n1, int j1x, int k1x, double[] cx, int j1y, int k1y, double[] cy)
          Copies elements from one specified array to another.
static float[] ccopy(int n1, int j1, int k1, float[] cx)
          Returns array copy of elements from the specified array.
static float[][][] ccopy(int n1, int n2, int n3, float[][][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, int n3, float[][][] cx, float[][][] cy)
          Copies elements from one specified array to another.
static void ccopy(int n1, int j1x, int k1x, float[] cx, int j1y, int k1y, float[] cy)
          Copies elements from one specified array to another.
static double[][] ccopy(int n1, int n2, int j1, int j2, double[][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, int j1x, int j2x, double[][] cx, int j1y, int j2y, double[][] cy)
          Copies elements from one specified array to another.
static float[][] ccopy(int n1, int n2, int j1, int j2, float[][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, int j1x, int j2x, float[][] cx, int j1y, int j2y, float[][] cy)
          Copies elements from one specified array to another.
static double[][] ccopy(int n1, int n2, int j1, int j2, int k1, int k2, double[][] cx)
          Returns array copy of elements from the specified array.
static double[][][] ccopy(int n1, int n2, int n3, int j1, int j2, int j3, double[][][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, int n3, int j1x, int j2x, int j3x, double[][][] cx, int j1y, int j2y, int j3y, double[][][] cy)
          Copies elements from one specified array to another.
static void ccopy(int n1, int n2, int j1x, int j2x, int k1x, int k2x, double[][] cx, int j1y, int j2y, int k1y, int k2y, double[][] cy)
          Copies elements from one specified array to another.
static float[][] ccopy(int n1, int n2, int j1, int j2, int k1, int k2, float[][] cx)
          Returns array copy of elements from the specified array.
static float[][][] ccopy(int n1, int n2, int n3, int j1, int j2, int j3, float[][][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, int n3, int j1x, int j2x, int j3x, float[][][] cx, int j1y, int j2y, int j3y, float[][][] cy)
          Copies elements from one specified array to another.
static void ccopy(int n1, int n2, int j1x, int j2x, int k1x, int k2x, float[][] cx, int j1y, int j2y, int k1y, int k2y, float[][] cy)
          Copies elements from one specified array to another.
static double[][][] ccopy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, double[][][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, int n3, int j1x, int j2x, int j3x, int k1x, int k2x, int k3x, double[][][] cx, int j1y, int j2y, int j3y, int k1y, int k2y, int k3y, double[][][] cy)
          Copies elements from one specified array to another.
static float[][][] ccopy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, float[][][] cx)
          Returns array copy of elements from the specified array.
static void ccopy(int n1, int n2, int n3, int j1x, int j2x, int j3x, int k1x, int k2x, int k3x, float[][][] cx, int j1y, int j2y, int j3y, int k1y, int k2y, int k3y, float[][][] cy)
          Copies elements from one specified array to another.
static double[] ccos(double[] cx)
           
static double[][] ccos(double[][] cx)
           
static double[][][] ccos(double[][][] cx)
           
static void ccos(double[][][] cx, double[][][] cy)
           
static void ccos(double[][] cx, double[][] cy)
           
static void ccos(double[] cx, double[] cy)
           
static float[] ccos(float[] cx)
           
static float[][] ccos(float[][] cx)
           
static float[][][] ccos(float[][][] cx)
           
static void ccos(float[][][] cx, float[][][] cy)
           
static void ccos(float[][] cx, float[][] cy)
           
static void ccos(float[] cx, float[] cy)
           
static double[] cdiv(Cdouble ca, double[] cy)
           
static double[][] cdiv(Cdouble ca, double[][] cy)
           
static double[][][] cdiv(Cdouble ca, double[][][] cy)
           
static void cdiv(Cdouble ca, double[][][] cy, double[][][] cz)
           
static void cdiv(Cdouble ca, double[][] cy, double[][] cz)
           
static void cdiv(Cdouble ca, double[] cy, double[] cz)
           
static float[] cdiv(Cfloat ca, float[] cy)
           
static float[][] cdiv(Cfloat ca, float[][] cy)
           
static float[][][] cdiv(Cfloat ca, float[][][] cy)
           
static void cdiv(Cfloat ca, float[][][] cy, float[][][] cz)
           
static void cdiv(Cfloat ca, float[][] cy, float[][] cz)
           
static void cdiv(Cfloat ca, float[] cy, float[] cz)
           
static double[][][] cdiv(double[][][] cx, Cdouble cb)
           
static void cdiv(double[][][] cx, Cdouble cb, double[][][] cz)
           
static double[][][] cdiv(double[][][] cx, double[][][] cy)
           
static void cdiv(double[][][] cx, double[][][] cy, double[][][] cz)
           
static double[][] cdiv(double[][] cx, Cdouble cb)
           
static void cdiv(double[][] cx, Cdouble cb, double[][] cz)
           
static double[][] cdiv(double[][] cx, double[][] cy)
           
static void cdiv(double[][] cx, double[][] cy, double[][] cz)
           
static double[] cdiv(double[] cx, Cdouble cb)
           
static void cdiv(double[] cx, Cdouble cb, double[] cz)
           
static double[] cdiv(double[] cx, double[] cy)
           
static void cdiv(double[] cx, double[] cy, double[] cz)
           
static float[][][] cdiv(float[][][] cx, Cfloat cb)
           
static void cdiv(float[][][] cx, Cfloat cb, float[][][] cz)
           
static float[][][] cdiv(float[][][] cx, float[][][] cy)
           
static void cdiv(float[][][] cx, float[][][] cy, float[][][] cz)
           
static float[][] cdiv(float[][] cx, Cfloat cb)
           
static void cdiv(float[][] cx, Cfloat cb, float[][] cz)
           
static float[][] cdiv(float[][] cx, float[][] cy)
           
static void cdiv(float[][] cx, float[][] cy, float[][] cz)
           
static float[] cdiv(float[] cx, Cfloat cb)
           
static void cdiv(float[] cx, Cfloat cb, float[] cz)
           
static float[] cdiv(float[] cx, float[] cy)
           
static void cdiv(float[] cx, float[] cy, float[] cz)
           
static void cdump(double[] cx)
           
static void cdump(double[][] cx)
           
static void cdump(double[][][] cx)
           
static void cdump(float[] cx)
           
static void cdump(float[][] cx)
           
static void cdump(float[][][] cx)
           
static boolean cequal(double[][][] cx, double[][][] cy)
          Determines whether all elements in two specified arrays are equal.
static boolean cequal(double[][] cx, double[][] cy)
          Determines whether all elements in two specified arrays are equal.
static boolean cequal(double[] cx, double[] cy)
          Determines whether all elements in two specified arrays are equal.
static boolean cequal(double tolerance, double[][][] cx, double[][][] cy)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean cequal(double tolerance, double[][] cx, double[][] cy)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean cequal(double tolerance, double[] cx, double[] cy)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean cequal(float[][][] cx, float[][][] cy)
          Determines whether all elements in two specified arrays are equal.
static boolean cequal(float[][] cx, float[][] cy)
          Determines whether all elements in two specified arrays are equal.
static boolean cequal(float[] cx, float[] cy)
          Determines whether all elements in two specified arrays are equal.
static boolean cequal(float tolerance, float[][][] cx, float[][][] cy)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean cequal(float tolerance, float[][] cx, float[][] cy)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean cequal(float tolerance, float[] cx, float[] cy)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static double[] cexp(double[] cx)
           
static double[][] cexp(double[][] cx)
           
static double[][][] cexp(double[][][] cx)
           
static void cexp(double[][][] cx, double[][][] cy)
           
static void cexp(double[][] cx, double[][] cy)
           
static void cexp(double[] cx, double[] cy)
           
static float[] cexp(float[] cx)
           
static float[][] cexp(float[][] cx)
           
static float[][][] cexp(float[][][] cx)
           
static void cexp(float[][][] cx, float[][][] cy)
           
static void cexp(float[][] cx, float[][] cy)
           
static void cexp(float[] cx, float[] cy)
           
static void cfill(Cdouble ca, double[] cx)
          Fills the specified array with a specified value.
static void cfill(Cdouble ca, double[][] cx)
          Fills the specified array with a specified value.
static void cfill(Cdouble ca, double[][][] cx)
          Fills the specified array with a specified value.
static void cfill(Cfloat ca, float[] cx)
          Fills the specified array with a specified value.
static void cfill(Cfloat ca, float[][] cx)
          Fills the specified array with a specified value.
static void cfill(Cfloat ca, float[][][] cx)
          Fills the specified array with a specified value.
static double[] cfilldouble(Cdouble ca, int n1)
          Returns an array initialized to a specified value.
static double[][] cfilldouble(Cdouble ca, int n1, int n2)
          Returns an array initialized to a specified value.
static double[][][] cfilldouble(Cdouble ca, int n1, int n2, int n3)
          Returns an array initialized to a specified value.
static float[] cfillfloat(Cfloat ca, int n1)
          Returns an array initialized to a specified value.
static float[][] cfillfloat(Cfloat ca, int n1, int n2)
          Returns an array initialized to a specified value.
static float[][][] cfillfloat(Cfloat ca, int n1, int n2, int n3)
          Returns an array initialized to a specified value.
static double[] cflatten(double[][] cx)
          Flattens a specified 2-D array into a 1-D array.
static double[] cflatten(double[][][] cx)
          Flattens a specified 3-D array into a 1-D array.
static float[] cflatten(float[][] cx)
          Flattens a specified 2-D array into a 1-D array.
static float[] cflatten(float[][][] cx)
          Flattens a specified 3-D array into a 1-D array.
static double[] cimag(double[] cx)
           
static double[][] cimag(double[][] cx)
           
static double[][][] cimag(double[][][] cx)
           
static void cimag(double[][][] cx, double[][][] cy)
           
static void cimag(double[][] cx, double[][] cy)
           
static void cimag(double[] cx, double[] cy)
           
static float[] cimag(float[] cx)
           
static float[][] cimag(float[][] cx)
           
static float[][][] cimag(float[][][] cx)
           
static void cimag(float[][][] cx, float[][][] cy)
           
static void cimag(float[][] cx, float[][] cy)
           
static void cimag(float[] cx, float[] cy)
           
static double[] clip(double rxmin, double rxmax, double[] rx)
           
static double[][] clip(double rxmin, double rxmax, double[][] rx)
           
static double[][][] clip(double rxmin, double rxmax, double[][][] rx)
           
static void clip(double rxmin, double rxmax, double[][][] rx, double[][][] ry)
           
static void clip(double rxmin, double rxmax, double[][] rx, double[][] ry)
           
static void clip(double rxmin, double rxmax, double[] rx, double[] ry)
           
static float[] clip(float rxmin, float rxmax, float[] rx)
           
static float[][] clip(float rxmin, float rxmax, float[][] rx)
           
static float[][][] clip(float rxmin, float rxmax, float[][][] rx)
           
static void clip(float rxmin, float rxmax, float[][][] rx, float[][][] ry)
           
static void clip(float rxmin, float rxmax, float[][] rx, float[][] ry)
           
static void clip(float rxmin, float rxmax, float[] rx, float[] ry)
           
static double[] clog(double[] cx)
           
static double[][] clog(double[][] cx)
           
static double[][][] clog(double[][][] cx)
           
static void clog(double[][][] cx, double[][][] cy)
           
static void clog(double[][] cx, double[][] cy)
           
static void clog(double[] cx, double[] cy)
           
static float[] clog(float[] cx)
           
static float[][] clog(float[][] cx)
           
static float[][][] clog(float[][][] cx)
           
static void clog(float[][][] cx, float[][][] cy)
           
static void clog(float[][] cx, float[][] cy)
           
static void clog(float[] cx, float[] cy)
           
static double[] clog10(double[] cx)
           
static double[][] clog10(double[][] cx)
           
static double[][][] clog10(double[][][] cx)
           
static void clog10(double[][][] cx, double[][][] cy)
           
static void clog10(double[][] cx, double[][] cy)
           
static void clog10(double[] cx, double[] cy)
           
static float[] clog10(float[] cx)
           
static float[][] clog10(float[][] cx)
           
static float[][][] clog10(float[][][] cx)
           
static void clog10(float[][][] cx, float[][][] cy)
           
static void clog10(float[][] cx, float[][] cy)
           
static void clog10(float[] cx, float[] cy)
           
static double[][][] cmplx(double[][][] rx, double[][][] ry)
           
static void cmplx(double[][][] rx, double[][][] ry, double[][][] cz)
           
static double[][] cmplx(double[][] rx, double[][] ry)
           
static void cmplx(double[][] rx, double[][] ry, double[][] cz)
           
static double[] cmplx(double[] rx, double[] ry)
           
static void cmplx(double[] rx, double[] ry, double[] cz)
           
static float[][][] cmplx(float[][][] rx, float[][][] ry)
           
static void cmplx(float[][][] rx, float[][][] ry, float[][][] cz)
           
static float[][] cmplx(float[][] rx, float[][] ry)
           
static void cmplx(float[][] rx, float[][] ry, float[][] cz)
           
static float[] cmplx(float[] rx, float[] ry)
           
static void cmplx(float[] rx, float[] ry, float[] cz)
           
static double[] cmul(Cdouble ca, double[] cy)
           
static double[][] cmul(Cdouble ca, double[][] cy)
           
static double[][][] cmul(Cdouble ca, double[][][] cy)
           
static void cmul(Cdouble ca, double[][][] cy, double[][][] cz)
           
static void cmul(Cdouble ca, double[][] cy, double[][] cz)
           
static void cmul(Cdouble ca, double[] cy, double[] cz)
           
static float[] cmul(Cfloat ca, float[] cy)
           
static float[][] cmul(Cfloat ca, float[][] cy)
           
static float[][][] cmul(Cfloat ca, float[][][] cy)
           
static void cmul(Cfloat ca, float[][][] cy, float[][][] cz)
           
static void cmul(Cfloat ca, float[][] cy, float[][] cz)
           
static void cmul(Cfloat ca, float[] cy, float[] cz)
           
static double[][][] cmul(double[][][] cx, Cdouble cb)
           
static void cmul(double[][][] cx, Cdouble cb, double[][][] cz)
           
static double[][][] cmul(double[][][] cx, double[][][] cy)
           
static void cmul(double[][][] cx, double[][][] cy, double[][][] cz)
           
static double[][] cmul(double[][] cx, Cdouble cb)
           
static void cmul(double[][] cx, Cdouble cb, double[][] cz)
           
static double[][] cmul(double[][] cx, double[][] cy)
           
static void cmul(double[][] cx, double[][] cy, double[][] cz)
           
static double[] cmul(double[] cx, Cdouble cb)
           
static void cmul(double[] cx, Cdouble cb, double[] cz)
           
static double[] cmul(double[] cx, double[] cy)
           
static void cmul(double[] cx, double[] cy, double[] cz)
           
static float[][][] cmul(float[][][] cx, Cfloat cb)
           
static void cmul(float[][][] cx, Cfloat cb, float[][][] cz)
           
static float[][][] cmul(float[][][] cx, float[][][] cy)
           
static void cmul(float[][][] cx, float[][][] cy, float[][][] cz)
           
static float[][] cmul(float[][] cx, Cfloat cb)
           
static void cmul(float[][] cx, Cfloat cb, float[][] cz)
           
static float[][] cmul(float[][] cx, float[][] cy)
           
static void cmul(float[][] cx, float[][] cy, float[][] cz)
           
static float[] cmul(float[] cx, Cfloat cb)
           
static void cmul(float[] cx, Cfloat cb, float[] cz)
           
static float[] cmul(float[] cx, float[] cy)
           
static void cmul(float[] cx, float[] cy, float[] cz)
           
static double[] cneg(double[] cx)
           
static double[][] cneg(double[][] cx)
           
static double[][][] cneg(double[][][] cx)
           
static void cneg(double[][][] cx, double[][][] cy)
           
static void cneg(double[][] cx, double[][] cy)
           
static void cneg(double[] cx, double[] cy)
           
static float[] cneg(float[] cx)
           
static float[][] cneg(float[][] cx)
           
static float[][][] cneg(float[][][] cx)
           
static void cneg(float[][][] cx, float[][][] cy)
           
static void cneg(float[][] cx, float[][] cy)
           
static void cneg(float[] cx, float[] cy)
           
static double[] cnorm(double[] cx)
           
static double[][] cnorm(double[][] cx)
           
static double[][][] cnorm(double[][][] cx)
           
static void cnorm(double[][][] cx, double[][][] cy)
           
static void cnorm(double[][] cx, double[][] cy)
           
static void cnorm(double[] cx, double[] cy)
           
static float[] cnorm(float[] cx)
           
static float[][] cnorm(float[][] cx)
           
static float[][][] cnorm(float[][][] cx)
           
static void cnorm(float[][][] cx, float[][][] cy)
           
static void cnorm(float[][] cx, float[][] cy)
           
static void cnorm(float[] cx, float[] cy)
           
static byte[] copy(byte[] rx)
          Returns array copy of elements from the specified array.
static byte[][] copy(byte[][] rx)
          Returns array copy of elements from the specified array.
static byte[][][] copy(byte[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(byte[][][] rx, byte[][][] ry)
          Copies elements from one specified array to another.
static void copy(byte[][] rx, byte[][] ry)
          Copies elements from one specified array to another.
static void copy(byte[] rx, byte[] ry)
          Copies elements from one specified array to another.
static double[] copy(double[] rx)
          Returns array copy of elements from the specified array.
static double[][] copy(double[][] rx)
          Returns array copy of elements from the specified array.
static double[][][] copy(double[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(double[][][] rx, double[][][] ry)
          Copies elements from one specified array to another.
static void copy(double[][] rx, double[][] ry)
          Copies elements from one specified array to another.
static void copy(double[] rx, double[] ry)
          Copies elements from one specified array to another.
static float[] copy(float[] rx)
          Returns array copy of elements from the specified array.
static float[][] copy(float[][] rx)
          Returns array copy of elements from the specified array.
static float[][][] copy(float[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(float[][][] rx, float[][][] ry)
          Copies elements from one specified array to another.
static void copy(float[][] rx, float[][] ry)
          Copies elements from one specified array to another.
static void copy(float[] rx, float[] ry)
          Copies elements from one specified array to another.
static int[] copy(int[] rx)
          Returns array copy of elements from the specified array.
static int[][] copy(int[][] rx)
          Returns array copy of elements from the specified array.
static int[][][] copy(int[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int[][][] rx, int[][][] ry)
          Copies elements from one specified array to another.
static void copy(int[][] rx, int[][] ry)
          Copies elements from one specified array to another.
static void copy(int[] rx, int[] ry)
          Copies elements from one specified array to another.
static byte[] copy(int n1, byte[] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, byte[] rx, byte[] ry)
          Copies elements from one specified array to another.
static double[] copy(int n1, double[] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, double[] rx, double[] ry)
          Copies elements from one specified array to another.
static float[] copy(int n1, float[] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, float[] rx, float[] ry)
          Copies elements from one specified array to another.
static int[] copy(int n1, int[] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int[] rx, int[] ry)
          Copies elements from one specified array to another.
static byte[] copy(int n1, int j1, byte[] rx)
          Returns array copy of elements from the specified array.
static byte[][] copy(int n1, int n2, byte[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, byte[][] rx, byte[][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, byte[] rx, int j1y, byte[] ry)
          Copies elements from one specified array to another.
static double[] copy(int n1, int j1, double[] rx)
          Returns array copy of elements from the specified array.
static double[][] copy(int n1, int n2, double[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, double[][] rx, double[][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, double[] rx, int j1y, double[] ry)
          Copies elements from one specified array to another.
static float[] copy(int n1, int j1, float[] rx)
          Returns array copy of elements from the specified array.
static float[][] copy(int n1, int n2, float[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, float[][] rx, float[][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, float[] rx, int j1y, float[] ry)
          Copies elements from one specified array to another.
static int[] copy(int n1, int j1, int[] rx)
          Returns array copy of elements from the specified array.
static int[][] copy(int n1, int n2, int[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int[][] rx, int[][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, int[] rx, int j1y, int[] ry)
          Copies elements from one specified array to another.
static byte[] copy(int n1, int j1, int k1, byte[] rx)
          Returns array copy of elements from the specified array.
static byte[][][] copy(int n1, int n2, int n3, byte[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, byte[][][] rx, byte[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, int k1x, byte[] rx, int j1y, int k1y, byte[] ry)
          Copies elements from one specified array to another.
static double[] copy(int n1, int j1, int k1, double[] rx)
          Returns array copy of elements from the specified array.
static double[][][] copy(int n1, int n2, int n3, double[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, double[][][] rx, double[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, int k1x, double[] rx, int j1y, int k1y, double[] ry)
          Copies elements from one specified array to another.
static float[] copy(int n1, int j1, int k1, float[] rx)
          Returns array copy of elements from the specified array.
static float[][][] copy(int n1, int n2, int n3, float[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, float[][][] rx, float[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, int k1x, float[] rx, int j1y, int k1y, float[] ry)
          Copies elements from one specified array to another.
static int[] copy(int n1, int j1, int k1, int[] rx)
          Returns array copy of elements from the specified array.
static int[][][] copy(int n1, int n2, int n3, int[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int[][][] rx, int[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, int k1x, int[] rx, int j1y, int k1y, int[] ry)
          Copies elements from one specified array to another.
static byte[][] copy(int n1, int n2, int j1, int j2, byte[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int j1x, int j2x, byte[][] rx, int j1y, int j2y, byte[][] ry)
          Copies elements from one specified array to another.
static double[][] copy(int n1, int n2, int j1, int j2, double[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int j1x, int j2x, double[][] rx, int j1y, int j2y, double[][] ry)
          Copies elements from one specified array to another.
static float[][] copy(int n1, int n2, int j1, int j2, float[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int j1x, int j2x, float[][] rx, int j1y, int j2y, float[][] ry)
          Copies elements from one specified array to another.
static int[][] copy(int n1, int n2, int j1, int j2, int[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int j1x, int j2x, int[][] rx, int j1y, int j2y, int[][] ry)
          Copies elements from one specified array to another.
static byte[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, byte[][] rx)
          Returns array copy of elements from the specified array.
static byte[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, byte[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, byte[][][] rx, int j1y, int j2y, int j3y, byte[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int n2, int j1x, int j2x, int k1x, int k2x, byte[][] rx, int j1y, int j2y, int k1y, int k2y, byte[][] ry)
          Copies elements from one specified array to another.
static double[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, double[][] rx)
          Returns array copy of elements from the specified array.
static double[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, double[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, double[][][] rx, int j1y, int j2y, int j3y, double[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int n2, int j1x, int j2x, int k1x, int k2x, double[][] rx, int j1y, int j2y, int k1y, int k2y, double[][] ry)
          Copies elements from one specified array to another.
static float[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, float[][] rx)
          Returns array copy of elements from the specified array.
static float[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, float[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, float[][][] rx, int j1y, int j2y, int j3y, float[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int n2, int j1x, int j2x, int k1x, int k2x, float[][] rx, int j1y, int j2y, int k1y, int k2y, float[][] ry)
          Copies elements from one specified array to another.
static int[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, int[][] rx)
          Returns array copy of elements from the specified array.
static int[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, int[][][] rx, int j1y, int j2y, int j3y, int[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int n2, int j1x, int j2x, int k1x, int k2x, int[][] rx, int j1y, int j2y, int k1y, int k2y, int[][] ry)
          Copies elements from one specified array to another.
static byte[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, byte[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, int k1x, int k2x, int k3x, byte[][][] rx, int j1y, int j2y, int j3y, int k1y, int k2y, int k3y, byte[][][] ry)
          Copies elements from one specified array to another.
static double[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, double[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, int k1x, int k2x, int k3x, double[][][] rx, int j1y, int j2y, int j3y, int k1y, int k2y, int k3y, double[][][] ry)
          Copies elements from one specified array to another.
static float[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, float[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, int k1x, int k2x, int k3x, float[][][] rx, int j1y, int j2y, int j3y, int k1y, int k2y, int k3y, float[][][] ry)
          Copies elements from one specified array to another.
static int[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, int[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, int k1x, int k2x, int k3x, int[][][] rx, int j1y, int j2y, int j3y, int k1y, int k2y, int k3y, int[][][] ry)
          Copies elements from one specified array to another.
static long[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, long[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, int k1x, int k2x, int k3x, long[][][] rx, int j1y, int j2y, int j3y, int k1y, int k2y, int k3y, long[][][] ry)
          Copies elements from one specified array to another.
static short[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, short[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, int k1x, int k2x, int k3x, short[][][] rx, int j1y, int j2y, int j3y, int k1y, int k2y, int k3y, short[][][] ry)
          Copies elements from one specified array to another.
static long[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, long[][] rx)
          Returns array copy of elements from the specified array.
static long[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, long[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, long[][][] rx, int j1y, int j2y, int j3y, long[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int n2, int j1x, int j2x, int k1x, int k2x, long[][] rx, int j1y, int j2y, int k1y, int k2y, long[][] ry)
          Copies elements from one specified array to another.
static short[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, short[][] rx)
          Returns array copy of elements from the specified array.
static short[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, short[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, int j1x, int j2x, int j3x, short[][][] rx, int j1y, int j2y, int j3y, short[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int n2, int j1x, int j2x, int k1x, int k2x, short[][] rx, int j1y, int j2y, int k1y, int k2y, short[][] ry)
          Copies elements from one specified array to another.
static long[][] copy(int n1, int n2, int j1, int j2, long[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int j1x, int j2x, long[][] rx, int j1y, int j2y, long[][] ry)
          Copies elements from one specified array to another.
static short[][] copy(int n1, int n2, int j1, int j2, short[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int j1x, int j2x, short[][] rx, int j1y, int j2y, short[][] ry)
          Copies elements from one specified array to another.
static long[] copy(int n1, int j1, int k1, long[] rx)
          Returns array copy of elements from the specified array.
static long[][][] copy(int n1, int n2, int n3, long[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, long[][][] rx, long[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, int k1x, long[] rx, int j1y, int k1y, long[] ry)
          Copies elements from one specified array to another.
static short[] copy(int n1, int j1, int k1, short[] rx)
          Returns array copy of elements from the specified array.
static short[][][] copy(int n1, int n2, int n3, short[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, int n3, short[][][] rx, short[][][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, int k1x, short[] rx, int j1y, int k1y, short[] ry)
          Copies elements from one specified array to another.
static long[] copy(int n1, int j1, long[] rx)
          Returns array copy of elements from the specified array.
static long[][] copy(int n1, int n2, long[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, long[][] rx, long[][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, long[] rx, int j1y, long[] ry)
          Copies elements from one specified array to another.
static short[] copy(int n1, int j1, short[] rx)
          Returns array copy of elements from the specified array.
static short[][] copy(int n1, int n2, short[][] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, int n2, short[][] rx, short[][] ry)
          Copies elements from one specified array to another.
static void copy(int n1, int j1x, short[] rx, int j1y, short[] ry)
          Copies elements from one specified array to another.
static long[] copy(int n1, long[] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, long[] rx, long[] ry)
          Copies elements from one specified array to another.
static short[] copy(int n1, short[] rx)
          Returns array copy of elements from the specified array.
static void copy(int n1, short[] rx, short[] ry)
          Copies elements from one specified array to another.
static long[] copy(long[] rx)
          Returns array copy of elements from the specified array.
static long[][] copy(long[][] rx)
          Returns array copy of elements from the specified array.
static long[][][] copy(long[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(long[][][] rx, long[][][] ry)
          Copies elements from one specified array to another.
static void copy(long[][] rx, long[][] ry)
          Copies elements from one specified array to another.
static void copy(long[] rx, long[] ry)
          Copies elements from one specified array to another.
static short[] copy(short[] rx)
          Returns array copy of elements from the specified array.
static short[][] copy(short[][] rx)
          Returns array copy of elements from the specified array.
static short[][][] copy(short[][][] rx)
          Returns array copy of elements from the specified array.
static void copy(short[][][] rx, short[][][] ry)
          Copies elements from one specified array to another.
static void copy(short[][] rx, short[][] ry)
          Copies elements from one specified array to another.
static void copy(short[] rx, short[] ry)
          Copies elements from one specified array to another.
static double[] cos(double[] rx)
           
static double[][] cos(double[][] rx)
           
static double[][][] cos(double[][][] rx)
           
static void cos(double[][][] rx, double[][][] ry)
           
static void cos(double[][] rx, double[][] ry)
           
static void cos(double[] rx, double[] ry)
           
static float[] cos(float[] rx)
           
static float[][] cos(float[][] rx)
           
static float[][][] cos(float[][][] rx)
           
static void cos(float[][][] rx, float[][][] ry)
           
static void cos(float[][] rx, float[][] ry)
           
static void cos(float[] rx, float[] ry)
           
static double[][][] cpow(double[][][] cx, Cdouble ca)
           
static void cpow(double[][][] cx, Cdouble ca, double[][][] cy)
           
static double[][][] cpow(double[][][] cx, double ra)
           
static void cpow(double[][][] cx, double ra, double[][][] cy)
           
static double[][] cpow(double[][] cx, Cdouble ca)
           
static void cpow(double[][] cx, Cdouble ca, double[][] cy)
           
static double[][] cpow(double[][] cx, double ra)
           
static void cpow(double[][] cx, double ra, double[][] cy)
           
static double[] cpow(double[] cx, Cdouble ca)
           
static void cpow(double[] cx, Cdouble ca, double[] cy)
           
static double[] cpow(double[] cx, double ra)
           
static void cpow(double[] cx, double ra, double[] cy)
           
static float[][][] cpow(float[][][] cx, Cfloat ca)
           
static void cpow(float[][][] cx, Cfloat ca, float[][][] cy)
           
static float[][][] cpow(float[][][] cx, float ra)
           
static void cpow(float[][][] cx, float ra, float[][][] cy)
           
static float[][] cpow(float[][] cx, Cfloat ca)
           
static void cpow(float[][] cx, Cfloat ca, float[][] cy)
           
static float[][] cpow(float[][] cx, float ra)
           
static void cpow(float[][] cx, float ra, float[][] cy)
           
static float[] cpow(float[] cx, Cfloat ca)
           
static void cpow(float[] cx, Cfloat ca, float[] cy)
           
static float[] cpow(float[] cx, float ra)
           
static void cpow(float[] cx, float ra, float[] cy)
           
static void cramp(Cdouble ca, Cdouble cb1, Cdouble cb2, Cdouble cb3, double[][][] cx)
          Sets the specified array with a specified linear ramp.
static void cramp(Cdouble ca, Cdouble cb1, Cdouble cb2, double[][] cx)
          Sets the specified array with a specified linear ramp.
static void cramp(Cdouble ca, Cdouble cb1, double[] cx)
          Sets the specified array with a specified linear ramp.
static void cramp(Cfloat ca, Cfloat cb1, Cfloat cb2, Cfloat cb3, float[][][] cx)
          Sets the specified array with a specified linear ramp.
static void cramp(Cfloat ca, Cfloat cb1, Cfloat cb2, float[][] cx)
          Sets the specified array with a specified linear ramp.
static void cramp(Cfloat ca, Cfloat cb1, float[] cx)
          Sets the specified array with a specified linear ramp.
static double[][][] crampdouble(Cdouble ca, Cdouble cb1, Cdouble cb2, Cdouble cb3, int n1, int n2, int n3)
          Returns an array initialized to a specified linear ramp.
static double[][] crampdouble(Cdouble ca, Cdouble cb1, Cdouble cb2, int n1, int n2)
          Returns an array initialized to a specified linear ramp.
static double[] crampdouble(Cdouble ca, Cdouble cb1, int n1)
          Returns an array initialized to a specified linear ramp.
static float[][][] crampfloat(Cfloat ca, Cfloat cb1, Cfloat cb2, Cfloat cb3, int n1, int n2, int n3)
          Returns an array initialized to a specified linear ramp.
static float[][] crampfloat(Cfloat ca, Cfloat cb1, Cfloat cb2, int n1, int n2)
          Returns an array initialized to a specified linear ramp.
static float[] crampfloat(Cfloat ca, Cfloat cb1, int n1)
          Returns an array initialized to a specified linear ramp.
static void crand(double[] cx)
          Fills the specified array with random values.
static void crand(double[][] cx)
          Fills the specified array with random values.
static void crand(double[][][] cx)
          Fills the specified array with random values.
static void crand(float[] cx)
          Fills the specified array with random values.
static void crand(float[][] cx)
          Fills the specified array with random values.
static void crand(float[][][] cx)
          Fills the specified array with random values.
static void crand(java.util.Random random, double[] cx)
          Fills the specified array with random values.
static void crand(java.util.Random random, double[][] cx)
          Fills the specified array with random values.
static void crand(java.util.Random random, double[][][] cx)
          Fills the specified array with random values.
static void crand(java.util.Random random, float[] cx)
          Fills the specified array with random values.
static void crand(java.util.Random random, float[][] cx)
          Fills the specified array with random values.
static void crand(java.util.Random random, float[][][] cx)
          Fills the specified array with random values.
static double[] cranddouble(int n1)
          Returns a new array of random values.
static double[][] cranddouble(int n1, int n2)
          Returns a new array of random values.
static double[][][] cranddouble(int n1, int n2, int n3)
          Returns a new array of random values.
static double[] cranddouble(java.util.Random random, int n1)
          Returns a new array of random values.
static double[][] cranddouble(java.util.Random random, int n1, int n2)
          Returns a new array of random values.
static double[][][] cranddouble(java.util.Random random, int n1, int n2, int n3)
          Returns a new array of random values.
static float[] crandfloat(int n1)
          Returns a new array of random values.
static float[][] crandfloat(int n1, int n2)
          Returns a new array of random values.
static float[][][] crandfloat(int n1, int n2, int n3)
          Returns a new array of random values.
static float[] crandfloat(java.util.Random random, int n1)
          Returns a new array of random values.
static float[][] crandfloat(java.util.Random random, int n1, int n2)
          Returns a new array of random values.
static float[][][] crandfloat(java.util.Random random, int n1, int n2, int n3)
          Returns a new array of random values.
static double[] creal(double[] cx)
           
static double[][] creal(double[][] cx)
           
static double[][][] creal(double[][][] cx)
           
static void creal(double[][][] cx, double[][][] cy)
           
static void creal(double[][] cx, double[][] cy)
           
static void creal(double[] cx, double[] cy)
           
static float[] creal(float[] cx)
           
static float[][] creal(float[][] cx)
           
static float[][][] creal(float[][][] cx)
           
static void creal(float[][][] cx, float[][][] cy)
           
static void creal(float[][] cx, float[][] cy)
           
static void creal(float[] cx, float[] cy)
           
static double[][] creshape(int n1, int n2, double[] cx)
          Reshapes a 1-D array into a 2-D array with specified dimensions.
static float[][] creshape(int n1, int n2, float[] cx)
          Reshapes a 1-D array into a 2-D array with specified dimensions.
static double[][][] creshape(int n1, int n2, int n3, double[] cx)
          Reshapes a 1-D array into a 3-D array with specified dimensions.
static float[][][] creshape(int n1, int n2, int n3, float[] cx)
          Reshapes a 1-D array into a 3-D array with specified dimensions.
static double[] creverse(double[] rx)
           
static void creverse(double[] rx, double[] ry)
           
static float[] creverse(float[] rx)
           
static void creverse(float[] rx, float[] ry)
           
static double[] csin(double[] cx)
           
static double[][] csin(double[][] cx)
           
static double[][][] csin(double[][][] cx)
           
static void csin(double[][][] cx, double[][][] cy)
           
static void csin(double[][] cx, double[][] cy)
           
static void csin(double[] cx, double[] cy)
           
static float[] csin(float[] cx)
           
static float[][] csin(float[][] cx)
           
static float[][][] csin(float[][][] cx)
           
static void csin(float[][][] cx, float[][][] cy)
           
static void csin(float[][] cx, float[][] cy)
           
static void csin(float[] cx, float[] cy)
           
static double[] csqrt(double[] cx)
           
static double[][] csqrt(double[][] cx)
           
static double[][][] csqrt(double[][][] cx)
           
static void csqrt(double[][][] cx, double[][][] cy)
           
static void csqrt(double[][] cx, double[][] cy)
           
static void csqrt(double[] cx, double[] cy)
           
static float[] csqrt(float[] cx)
           
static float[][] csqrt(float[][] cx)
           
static float[][][] csqrt(float[][][] cx)
           
static void csqrt(float[][][] cx, float[][][] cy)
           
static void csqrt(float[][] cx, float[][] cy)
           
static void csqrt(float[] cx, float[] cy)
           
static double[] csub(Cdouble ca, double[] cy)
           
static double[][] csub(Cdouble ca, double[][] cy)
           
static double[][][] csub(Cdouble ca, double[][][] cy)
           
static void csub(Cdouble ca, double[][][] cy, double[][][] cz)
           
static void csub(Cdouble ca, double[][] cy, double[][] cz)
           
static void csub(Cdouble ca, double[] cy, double[] cz)
           
static float[] csub(Cfloat ca, float[] cy)
           
static float[][] csub(Cfloat ca, float[][] cy)
           
static float[][][] csub(Cfloat ca, float[][][] cy)
           
static void csub(Cfloat ca, float[][][] cy, float[][][] cz)
           
static void csub(Cfloat ca, float[][] cy, float[][] cz)
           
static void csub(Cfloat ca, float[] cy, float[] cz)
           
static double[][][] csub(double[][][] cx, Cdouble cb)
           
static void csub(double[][][] cx, Cdouble cb, double[][][] cz)
           
static double[][][] csub(double[][][] cx, double[][][] cy)
           
static void csub(double[][][] cx, double[][][] cy, double[][][] cz)
           
static double[][] csub(double[][] cx, Cdouble cb)
           
static void csub(double[][] cx, Cdouble cb, double[][] cz)
           
static double[][] csub(double[][] cx, double[][] cy)
           
static void csub(double[][] cx, double[][] cy, double[][] cz)
           
static double[] csub(double[] cx, Cdouble cb)
           
static void csub(double[] cx, Cdouble cb, double[] cz)
           
static double[] csub(double[] cx, double[] cy)
           
static void csub(double[] cx, double[] cy, double[] cz)
           
static float[][][] csub(float[][][] cx, Cfloat cb)
           
static void csub(float[][][] cx, Cfloat cb, float[][][] cz)
           
static float[][][] csub(float[][][] cx, float[][][] cy)
           
static void csub(float[][][] cx, float[][][] cy, float[][][] cz)
           
static float[][] csub(float[][] cx, Cfloat cb)
           
static void csub(float[][] cx, Cfloat cb, float[][] cz)
           
static float[][] csub(float[][] cx, float[][] cy)
           
static void csub(float[][] cx, float[][] cy, float[][] cz)
           
static float[] csub(float[] cx, Cfloat cb)
           
static void csub(float[] cx, Cfloat cb, float[] cz)
           
static float[] csub(float[] cx, float[] cy)
           
static void csub(float[] cx, float[] cy, float[] cz)
           
static Cdouble csum(double[] cx)
           
static Cdouble csum(double[][] cx)
           
static Cdouble csum(double[][][] cx)
           
static Cfloat csum(float[] cx)
           
static Cfloat csum(float[][] cx)
           
static Cfloat csum(float[][][] cx)
           
static double[][] ctranspose(double[][] cx)
          Transpose the specified 2-D array.
static float[][] ctranspose(float[][] cx)
          Transpose the specified 2-D array.
static void czero(double[] cx)
          Zeros the the specified array.
static void czero(double[][] cx)
          Zeros the the specified array.
static void czero(double[][][] cx)
          Zeros the the specified array.
static void czero(float[] cx)
          Zeros the the specified array.
static void czero(float[][] cx)
          Zeros the the specified array.
static void czero(float[][][] cx)
          Zeros the the specified array.
static double[] czerodouble(int n1)
          Returns a new array of zeros.
static double[][] czerodouble(int n1, int n2)
          Returns a new array of zeros.
static double[][][] czerodouble(int n1, int n2, int n3)
          Returns a new array of zeros.
static float[] czerofloat(int n1)
          Returns a new array of zeros.
static float[][] czerofloat(int n1, int n2)
          Returns a new array of zeros.
static float[][][] czerofloat(int n1, int n2, int n3)
          Returns a new array of zeros.
static double[][][] div(double[][][] rx, double rb)
           
static double[][][] div(double[][][] rx, double[][][] ry)
           
static void div(double[][][] rx, double[][][] ry, double[][][] rz)
           
static void div(double[][][] rx, double rb, double[][][] rz)
           
static double[][] div(double[][] rx, double rb)
           
static double[][] div(double[][] rx, double[][] ry)
           
static void div(double[][] rx, double[][] ry, double[][] rz)
           
static void div(double[][] rx, double rb, double[][] rz)
           
static double[] div(double[] rx, double rb)
           
static double[] div(double[] rx, double[] ry)
           
static void div(double[] rx, double[] ry, double[] rz)
           
static void div(double[] rx, double rb, double[] rz)
           
static double[] div(double ra, double[] ry)
           
static double[][] div(double ra, double[][] ry)
           
static double[][][] div(double ra, double[][][] ry)
           
static void div(double ra, double[][][] ry, double[][][] rz)
           
static void div(double ra, double[][] ry, double[][] rz)
           
static void div(double ra, double[] ry, double[] rz)
           
static float[][][] div(float[][][] rx, float rb)
           
static float[][][] div(float[][][] rx, float[][][] ry)
           
static void div(float[][][] rx, float[][][] ry, float[][][] rz)
           
static void div(float[][][] rx, float rb, float[][][] rz)
           
static float[][] div(float[][] rx, float rb)
           
static float[][] div(float[][] rx, float[][] ry)
           
static void div(float[][] rx, float[][] ry, float[][] rz)
           
static void div(float[][] rx, float rb, float[][] rz)
           
static float[] div(float[] rx, float rb)
           
static float[] div(float[] rx, float[] ry)
           
static void div(float[] rx, float[] ry, float[] rz)
           
static void div(float[] rx, float rb, float[] rz)
           
static float[] div(float ra, float[] ry)
           
static float[][] div(float ra, float[][] ry)
           
static float[][][] div(float ra, float[][][] ry)
           
static void div(float ra, float[][][] ry, float[][][] rz)
           
static void div(float ra, float[][] ry, float[][] rz)
           
static void div(float ra, float[] ry, float[] rz)
           
static void dump(byte[] rx)
           
static void dump(byte[][] rx)
           
static void dump(byte[][][] rx)
           
static void dump(double[] rx)
           
static void dump(double[][] rx)
           
static void dump(double[][][] rx)
           
static void dump(float[] rx)
           
static void dump(float[][] rx)
           
static void dump(float[][][] rx)
           
static void dump(int[] rx)
           
static void dump(int[][] rx)
           
static void dump(int[][][] rx)
           
static void dump(long[] rx)
           
static void dump(long[][] rx)
           
static void dump(long[][][] rx)
           
static void dump(short[] rx)
           
static void dump(short[][] rx)
           
static void dump(short[][][] rx)
           
static boolean equal(byte[][][] rx, byte[][][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(byte[][] rx, byte[][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(byte[] rx, byte[] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(double[][][] rx, double[][][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(double[][] rx, double[][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(double[] rx, double[] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(double tolerance, double[][][] rx, double[][][] ry)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean equal(double tolerance, double[][] rx, double[][] ry)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean equal(double tolerance, double[] rx, double[] ry)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean equal(float[][][] rx, float[][][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(float[][] rx, float[][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(float[] rx, float[] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(float tolerance, float[][][] rx, float[][][] ry)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean equal(float tolerance, float[][] rx, float[][] ry)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean equal(float tolerance, float[] rx, float[] ry)
          Determines whether all elements in two specified arrays are equal, to within a specified tolerance.
static boolean equal(int[][][] rx, int[][][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(int[][] rx, int[][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(int[] rx, int[] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(long[][][] rx, long[][][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(long[][] rx, long[][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(long[] rx, long[] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(short[][][] rx, short[][][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(short[][] rx, short[][] ry)
          Determines whether all elements in two specified arrays are equal.
static boolean equal(short[] rx, short[] ry)
          Determines whether all elements in two specified arrays are equal.
static double[] exp(double[] rx)
           
static double[][] exp(double[][] rx)
           
static double[][][] exp(double[][][] rx)
           
static void exp(double[][][] rx, double[][][] ry)
           
static void exp(double[][] rx, double[][] ry)
           
static void exp(double[] rx, double[] ry)
           
static float[] exp(float[] rx)
           
static float[][] exp(float[][] rx)
           
static float[][][] exp(float[][][] rx)
           
static void exp(float[][][] rx, float[][][] ry)
           
static void exp(float[][] rx, float[][] ry)
           
static void exp(float[] rx, float[] ry)
           
static void fill(byte ra, byte[] rx)
          Fills the specified array with a specified value.
static void fill(byte ra, byte[][] rx)
          Fills the specified array with a specified value.
static void fill(byte ra, byte[][][] rx)
          Fills the specified array with a specified value.
static void fill(double ra, double[] rx)
          Fills the specified array with a specified value.
static void fill(double ra, double[][] rx)
          Fills the specified array with a specified value.
static void fill(double ra, double[][][] rx)
          Fills the specified array with a specified value.
static void fill(float ra, float[] rx)
          Fills the specified array with a specified value.
static void fill(float ra, float[][] rx)
          Fills the specified array with a specified value.
static void fill(float ra, float[][][] rx)
          Fills the specified array with a specified value.
static void fill(int ra, int[] rx)
          Fills the specified array with a specified value.
static void fill(int ra, int[][] rx)
          Fills the specified array with a specified value.
static void fill(int ra, int[][][] rx)
          Fills the specified array with a specified value.
static void fill(long ra, long[] rx)
          Fills the specified array with a specified value.
static void fill(long ra, long[][] rx)
          Fills the specified array with a specified value.
static void fill(long ra, long[][][] rx)
          Fills the specified array with a specified value.
static void fill(short ra, short[] rx)
          Fills the specified array with a specified value.
static void fill(short ra, short[][] rx)
          Fills the specified array with a specified value.
static void fill(short ra, short[][][] rx)
          Fills the specified array with a specified value.
static byte[] fillbyte(byte ra, int n1)
          Returns an array initialized to a specified value.
static byte[][] fillbyte(byte ra, int n1, int n2)
          Returns an array initialized to a specified value.
static byte[][][] fillbyte(byte ra, int n1, int n2, int n3)
          Returns an array initialized to a specified value.
static double[] filldouble(double ra, int n1)
          Returns an array initialized to a specified value.
static double[][] filldouble(double ra, int n1, int n2)
          Returns an array initialized to a specified value.
static double[][][] filldouble(double ra, int n1, int n2, int n3)
          Returns an array initialized to a specified value.
static float[] fillfloat(float ra, int n1)
          Returns an array initialized to a specified value.
static float[][] fillfloat(float ra, int n1, int n2)
          Returns an array initialized to a specified value.
static float[][][] fillfloat(float ra, int n1, int n2, int n3)
          Returns an array initialized to a specified value.
static int[] fillint(int ra, int n1)
          Returns an array initialized to a specified value.
static int[][] fillint(int ra, int n1, int n2)
          Returns an array initialized to a specified value.
static int[][][] fillint(int ra, int n1, int n2, int n3)
          Returns an array initialized to a specified value.
static long[] filllong(long ra, int n1)
          Returns an array initialized to a specified value.
static long[][] filllong(long ra, int n1, int n2)
          Returns an array initialized to a specified value.
static long[][][] filllong(long ra, int n1, int n2, int n3)
          Returns an array initialized to a specified value.
static short[] fillshort(short ra, int n1)
          Returns an array initialized to a specified value.
static short[][] fillshort(short ra, int n1, int n2)
          Returns an array initialized to a specified value.
static short[][][] fillshort(short ra, int n1, int n2, int n3)
          Returns an array initialized to a specified value.
static byte[] flatten(byte[][] rx)
          Flattens a specified 2-D array into a 1-D array.
static byte[] flatten(byte[][][] rx)
          Flattens a specified 3-D array into a 1-D array.
static double[] flatten(double[][] rx)
          Flattens a specified 2-D array into a 1-D array.
static double[] flatten(double[][][] rx)
          Flattens a specified 3-D array into a 1-D array.
static float[] flatten(float[][] rx)
          Flattens a specified 2-D array into a 1-D array.
static float[] flatten(float[][][] rx)
          Flattens a specified 3-D array into a 1-D array.
static int[] flatten(int[][] rx)
          Flattens a specified 2-D array into a 1-D array.
static int[] flatten(int[][][] rx)
          Flattens a specified 3-D array into a 1-D array.
static long[] flatten(long[][] rx)
          Flattens a specified 2-D array into a 1-D array.
static long[] flatten(long[][][] rx)
          Flattens a specified 3-D array into a 1-D array.
static short[] flatten(short[][] rx)
          Flattens a specified 2-D array into a 1-D array.
static short[] flatten(short[][][] rx)
          Flattens a specified 3-D array into a 1-D array.
static boolean isDecreasing(byte[] a)
          Determines whether the specified array is decreasing.
static boolean isDecreasing(double[] a)
          Determines whether the specified array is decreasing.
static boolean isDecreasing(float[] a)
          Determines whether the specified array is decreasing.
static boolean isDecreasing(int[] a)
          Determines whether the specified array is decreasing.
static boolean isDecreasing(long[] a)
          Determines whether the specified array is decreasing.
static boolean isDecreasing(short[] a)
          Determines whether the specified array is decreasing.
static boolean isIncreasing(byte[] a)
          Determines whether the specified array is increasing.
static boolean isIncreasing(double[] a)
          Determines whether the specified array is increasing.
static boolean isIncreasing(float[] a)
          Determines whether the specified array is increasing.
static boolean isIncreasing(int[] a)
          Determines whether the specified array is increasing.
static boolean isIncreasing(long[] a)
          Determines whether the specified array is increasing.
static boolean isIncreasing(short[] a)
          Determines whether the specified array is increasing.
static boolean isMonotonic(byte[] a)
          Determines whether the specified array is monotonic.
static boolean isMonotonic(double[] a)
          Determines whether the specified array is monotonic.
static boolean isMonotonic(float[] a)
          Determines whether the specified array is monotonic.
static boolean isMonotonic(int[] a)
          Determines whether the specified array is monotonic.
static boolean isMonotonic(long[] a)
          Determines whether the specified array is monotonic.
static boolean isMonotonic(short[] a)
          Determines whether the specified array is monotonic.
static boolean isRegular(byte[][] a)
          Determines whether the specified array of arrays is regular.
static boolean isRegular(byte[][][] a)
          Determines whether the specified array of arrays of arrays is regular.
static boolean isRegular(double[][] a)
          Determines whether the specified array of arrays is regular.
static boolean isRegular(double[][][] a)
          Determines whether the specified array of arrays of arrays is regular.
static boolean isRegular(float[][] a)
          Determines whether the specified array of arrays is regular.
static boolean isRegular(float[][][] a)
          Determines whether the specified array of arrays of arrays is regular.
static boolean isRegular(int[][] a)
          Determines whether the specified array of arrays is regular.
static boolean isRegular(int[][][] a)
          Determines whether the specified array of arrays of arrays is regular.
static boolean isRegular(short[][] a)
          Determines whether the specified array of arrays is regular.
static boolean isRegular(short[][][] a)
          Determines whether the specified array of arrays of arrays is regular.
static double[] log(double[] rx)
           
static double[][] log(double[][] rx)
           
static double[][][] log(double[][][] rx)
           
static void log(double[][][] rx, double[][][] ry)
           
static void log(double[][] rx, double[][] ry)
           
static void log(double[] rx, double[] ry)
           
static float[] log(float[] rx)
           
static float[][] log(float[][] rx)
           
static float[][][] log(float[][][] rx)
           
static void log(float[][][] rx, float[][][] ry)
           
static void log(float[][] rx, float[][] ry)
           
static void log(float[] rx, float[] ry)
           
static double[] log10(double[] rx)
           
static double[][] log10(double[][] rx)
           
static double[][][] log10(double[][][] rx)
           
static void log10(double[][][] rx, double[][][] ry)
           
static void log10(double[][] rx, double[][] ry)
           
static void log10(double[] rx, double[] ry)
           
static float[] log10(float[] rx)
           
static float[][] log10(float[][] rx)
           
static float[][][] log10(float[][][] rx)
           
static void log10(float[][][] rx, float[][][] ry)
           
static void log10(float[][] rx, float[][] ry)
           
static void log10(float[] rx, float[] ry)
           
static byte max(byte[] rx)
           
static byte max(byte[][] rx)
           
static byte max(byte[][][] rx)
           
static byte max(byte[][][] rx, int[] index)
           
static byte max(byte[][] rx, int[] index)
           
static byte max(byte[] rx, int[] index)
           
static double max(double[] rx)
           
static double max(double[][] rx)
           
static double max(double[][][] rx)
           
static double max(double[][][] rx, int[] index)
           
static double max(double[][] rx, int[] index)
           
static double max(double[] rx, int[] index)
           
static float max(float[] rx)
           
static float max(float[][] rx)
           
static float max(float[][][] rx)
           
static float max(float[][][] rx, int[] index)
           
static float max(float[][] rx, int[] index)
           
static float max(float[] rx, int[] index)
           
static int max(int[] rx)
           
static int max(int[][] rx)
           
static int max(int[][][] rx)
           
static int max(int[][][] rx, int[] index)
           
static int max(int[][] rx, int[] index)
           
static int max(int[] rx, int[] index)
           
static long max(long[] rx)
           
static long max(long[][] rx)
           
static long max(long[][][] rx)
           
static long max(long[][][] rx, int[] index)
           
static long max(long[][] rx, int[] index)
           
static long max(long[] rx, int[] index)
           
static short max(short[] rx)
           
static short max(short[][] rx)
           
static short max(short[][][] rx)
           
static short max(short[][][] rx, int[] index)
           
static short max(short[][] rx, int[] index)
           
static short max(short[] rx, int[] index)
           
static byte min(byte[] rx)
           
static byte min(byte[][] rx)
           
static byte min(byte[][][] rx)
           
static byte min(byte[][][] rx, int[] index)
           
static byte min(byte[][] rx, int[] index)
           
static byte min(byte[] rx, int[] index)
           
static double min(double[] rx)
           
static double min(double[][] rx)
           
static double min(double[][][] rx)
           
static double min(double[][][] rx, int[] index)
           
static double min(double[][] rx, int[] index)
           
static double min(double[] rx, int[] index)
           
static float min(float[] rx)
           
static float min(float[][] rx)
           
static float min(float[][][] rx)
           
static float min(float[][][] rx, int[] index)
           
static float min(float[][] rx, int[] index)
           
static float min(float[] rx, int[] index)
           
static int min(int[] rx)
           
static int min(int[][] rx)
           
static int min(int[][][] rx)
           
static int min(int[][][] rx, int[] index)
           
static int min(int[][] rx, int[] index)
           
static int min(int[] rx, int[] index)
           
static long min(long[] rx)
           
static long min(long[][] rx)
           
static long min(long[][][] rx)
           
static long min(long[][][] rx, int[] index)
           
static long min(long[][] rx, int[] index)
           
static long min(long[] rx, int[] index)
           
static short min(short[] rx)
           
static short min(short[][] rx)
           
static short min(short[][][] rx)
           
static short min(short[][][] rx, int[] index)
           
static short min(short[][] rx, int[] index)
           
static short min(short[] rx, int[] index)
           
static double[][][] mul(double[][][] rx, double rb)
           
static double[][][] mul(double[][][] rx, double[][][] ry)
           
static void mul(double[][][] rx, double[][][] ry, double[][][] rz)
           
static void mul(double[][][] rx, double rb, double[][][] rz)
           
static double[][] mul(double[][] rx, double rb)
           
static double[][] mul(double[][] rx, double[][] ry)
           
static void mul(double[][] rx, double[][] ry, double[][] rz)
           
static void mul(double[][] rx, double rb, double[][] rz)
           
static double[] mul(double[] rx, double rb)
           
static double[] mul(double[] rx, double[] ry)
           
static void mul(double[] rx, double[] ry, double[] rz)
           
static void mul(double[] rx, double rb, double[] rz)
           
static double[] mul(double ra, double[] ry)
           
static double[][] mul(double ra, double[][] ry)
           
static double[][][] mul(double ra, double[][][] ry)
           
static void mul(double ra, double[][][] ry, double[][][] rz)
           
static void mul(double ra, double[][] ry, double[][] rz)
           
static void mul(double ra, double[] ry, double[] rz)
           
static float[][][] mul(float[][][] rx, float rb)
           
static float[][][] mul(float[][][] rx, float[][][] ry)
           
static void mul(float[][][] rx, float[][][] ry, float[][][] rz)
           
static void mul(float[][][] rx, float rb, float[][][] rz)
           
static float[][] mul(float[][] rx, float rb)
           
static float[][] mul(float[][] rx, float[][] ry)
           
static void mul(float[][] rx, float[][] ry, float[][] rz)
           
static void mul(float[][] rx, float rb, float[][] rz)
           
static float[] mul(float[] rx, float rb)
           
static float[] mul(float[] rx, float[] ry)
           
static void mul(float[] rx, float[] ry, float[] rz)
           
static void mul(float[] rx, float rb, float[] rz)
           
static float[] mul(float ra, float[] ry)
           
static float[][] mul(float ra, float[][] ry)
           
static float[][][] mul(float ra, float[][][] ry)
           
static void mul(float ra, float[][][] ry, float[][][] rz)
           
static void mul(float ra, float[][] ry, float[][] rz)
           
static void mul(float ra, float[] ry, float[] rz)
           
static double[] neg(double[] rx)
           
static double[][] neg(double[][] rx)
           
static double[][][] neg(double[][][] rx)
           
static void neg(double[][][] rx, double[][][] ry)
           
static void neg(double[][] rx, double[][] ry)
           
static void neg(double[] rx, double[] ry)
           
static float[] neg(float[] rx)
           
static float[][] neg(float[][] rx)
           
static float[][][] neg(float[][][] rx)
           
static void neg(float[][][] rx, float[][][] ry)
           
static void neg(float[][] rx, float[][] ry)
           
static void neg(float[] rx, float[] ry)
           
static double[][][] polar(double[][][] rx, double[][][] ry)
           
static void polar(double[][][] rx, double[][][] ry, double[][][] cz)
           
static double[][] polar(double[][] rx, double[][] ry)
           
static void polar(double[][] rx, double[][] ry, double[][] cz)
           
static double[] polar(double[] rx, double[] ry)
           
static void polar(double[] rx, double[] ry, double[] cz)
           
static float[][][] polar(float[][][] rx, float[][][] ry)
           
static void polar(float[][][] rx, float[][][] ry, float[][][] cz)
           
static float[][] polar(float[][] rx, float[][] ry)
           
static void polar(float[][] rx, float[][] ry, float[][] cz)
           
static float[] polar(float[] rx, float[] ry)
           
static void polar(float[] rx, float[] ry, float[] cz)
           
static double[][][] pow(double[][][] rx, double ra)
           
static void pow(double[][][] rx, double ra, double[][][] ry)
           
static double[][] pow(double[][] rx, double ra)
           
static void pow(double[][] rx, double ra, double[][] ry)
           
static double[] pow(double[] rx, double ra)
           
static void pow(double[] rx, double ra, double[] ry)
           
static float[][][] pow(float[][][] rx, float ra)
           
static void pow(float[][][] rx, float ra, float[][][] ry)
           
static float[][] pow(float[][] rx, float ra)
           
static void pow(float[][] rx, float ra, float[][] ry)
           
static float[] pow(float[] rx, float ra)
           
static void pow(float[] rx, float ra, float[] ry)
           
static void quickIndexSort(byte[] a, int[] i)
          Sorts indices of the elements of the specified array in ascending order.
static void quickIndexSort(double[] a, int[] i)
          Sorts indices of the elements of the specified array in ascending order.
static void quickIndexSort(float[] a, int[] i)
          Sorts indices of the elements of the specified array in ascending order.
static void quickIndexSort(int[] a, int[] i)
          Sorts indices of the elements of the specified array in ascending order.
static void quickIndexSort(long[] a, int[] i)
          Sorts indices of the elements of the specified array in ascending order.
static void quickIndexSort(short[] a, int[] i)
          Sorts indices of the elements of the specified array in ascending order.
static void quickPartialIndexSort(int k, byte[] a, int[] i)
          Partially sorts indices of the elements of the specified array.
static void quickPartialIndexSort(int k, double[] a, int[] i)
          Partially sorts indices of the elements of the specified array.
static void quickPartialIndexSort(int k, float[] a, int[] i)
          Partially sorts indices of the elements of the specified array.
static void quickPartialIndexSort(int k, int[] a, int[] i)
          Partially sorts indices of the elements of the specified array.
static void quickPartialIndexSort(int k, long[] a, int[] i)
          Partially sorts indices of the elements of the specified array.
static void quickPartialIndexSort(int k, short[] a, int[] i)
          Partially sorts indices of the elements of the specified array.
static void quickPartialSort(int k, byte[] a)
          Partially sorts the elements of the specified array in ascending order.
static void quickPartialSort(int k, double[] a)
          Partially sorts the elements of the specified array in ascending order.
static void quickPartialSort(int k, float[] a)
          Partially sorts the elements of the specified array in ascending order.
static void quickPartialSort(int k, int[] a)
          Partially sorts the elements of the specified array in ascending order.
static void quickPartialSort(int k, long[] a)
          Partially sorts the elements of the specified array in ascending order.
static void quickPartialSort(int k, short[] a)
          Partially sorts the elements of the specified array in ascending order.
static void quickSort(byte[] a)
          Sorts the elements of the specified array in ascending order.
static void quickSort(double[] a)
          Sorts the elements of the specified array in ascending order.
static void quickSort(float[] a)
          Sorts the elements of the specified array in ascending order.
static void quickSort(int[] a)
          Sorts the elements of the specified array in ascending order.
static void quickSort(long[] a)
          Sorts the elements of the specified array in ascending order.
static void quickSort(short[] a)
          Sorts the elements of the specified array in ascending order.
static void ramp(byte ra, byte rb1, byte[] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(byte ra, byte rb1, byte rb2, byte[][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(byte ra, byte rb1, byte rb2, byte rb3, byte[][][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(double ra, double rb1, double[] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(double ra, double rb1, double rb2, double[][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(double ra, double rb1, double rb2, double rb3, double[][][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(float ra, float rb1, float[] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(float ra, float rb1, float rb2, float[][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(float ra, float rb1, float rb2, float rb3, float[][][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(int ra, int rb1, int[] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(int ra, int rb1, int rb2, int[][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(int ra, int rb1, int rb2, int rb3, int[][][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(long ra, long rb1, long[] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(long ra, long rb1, long rb2, long[][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(long ra, long rb1, long rb2, long rb3, long[][][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(short ra, short rb1, short[] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(short ra, short rb1, short rb2, short[][] rx)
          Sets the specified array with a specified linear ramp.
static void ramp(short ra, short rb1, short rb2, short rb3, short[][][] rx)
          Sets the specified array with a specified linear ramp.
static byte[][][] rampbyte(byte ra, byte rb1, byte rb2, byte rb3, int n1, int n2, int n3)
          Returns an array initialized to a specified linear ramp.
static byte[][] rampbyte(byte ra, byte rb1, byte rb2, int n1, int n2)
          Returns an array initialized to a specified linear ramp.
static byte[] rampbyte(byte ra, byte rb1, int n1)
          Returns an array initialized to a specified linear ramp.
static double[][][] rampdouble(double ra, double rb1, double rb2, double rb3, int n1, int n2, int n3)
          Returns an array initialized to a specified linear ramp.
static double[][] rampdouble(double ra, double rb1, double rb2, int n1, int n2)
          Returns an array initialized to a specified linear ramp.
static double[] rampdouble(double ra, double rb1, int n1)
          Returns an array initialized to a specified linear ramp.
static float[][][] rampfloat(float ra, float rb1, float rb2, float rb3, int n1, int n2, int n3)
          Returns an array initialized to a specified linear ramp.
static float[][] rampfloat(float ra, float rb1, float rb2, int n1, int n2)
          Returns an array initialized to a specified linear ramp.
static float[] rampfloat(float ra, float rb1, int n1)
          Returns an array initialized to a specified linear ramp.
static int[] rampint(int ra, int rb1, int n1)
          Returns an array initialized to a specified linear ramp.
static int[][] rampint(int ra, int rb1, int rb2, int n1, int n2)
          Returns an array initialized to a specified linear ramp.
static int[][][] rampint(int ra, int rb1, int rb2, int rb3, int n1, int n2, int n3)
          Returns an array initialized to a specified linear ramp.
static long[] ramplong(long ra, long rb1, int n1)
          Returns an array initialized to a specified linear ramp.
static long[][] ramplong(long ra, long rb1, long rb2, int n1, int n2)
          Returns an array initialized to a specified linear ramp.
static long[][][] ramplong(long ra, long rb1, long rb2, long rb3, int n1, int n2, int n3)
          Returns an array initialized to a specified linear ramp.
static short[] rampshort(short ra, short rb1, int n1)
          Returns an array initialized to a specified linear ramp.
static short[][] rampshort(short ra, short rb1, short rb2, int n1, int n2)
          Returns an array initialized to a specified linear ramp.
static short[][][] rampshort(short ra, short rb1, short rb2, short rb3, int n1, int n2, int n3)
          Returns an array initialized to a specified linear ramp.
static void rand(double[] rx)
          Fills the specified array with random values.
static void rand(double[][] rx)
          Fills the specified array with random values.
static void rand(double[][][] rx)
          Fills the specified array with random values.
static void rand(float[] rx)
          Fills the specified array with random values.
static void rand(float[][] rx)
          Fills the specified array with random values.
static void rand(float[][][] rx)
          Fills the specified array with random values.
static void rand(int[] rx)
          Fills the specified array with random values.
static void rand(int[][] rx)
          Fills the specified array with random values.
static void rand(int[][][] rx)
          Fills the specified array with random values.
static void rand(long[] rx)
          Fills the specified array with random values.
static void rand(long[][] rx)
          Fills the specified array with random values.
static void rand(long[][][] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, double[] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, double[][] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, double[][][] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, float[] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, float[][] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, float[][][] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, int[] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, int[][] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, int[][][] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, long[] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, long[][] rx)
          Fills the specified array with random values.
static void rand(java.util.Random random, long[][][] rx)
          Fills the specified array with random values.
static double[] randdouble(int n1)
          Returns a new array of random values.
static double[][] randdouble(int n1, int n2)
          Returns a new array of random values.
static double[][][] randdouble(int n1, int n2, int n3)
          Returns a new array of random values.
static double[] randdouble(java.util.Random random, int n1)
          Returns a new array of random values.
static double[][] randdouble(java.util.Random random, int n1, int n2)
          Returns a new array of random values.
static double[][][] randdouble(java.util.Random random, int n1, int n2, int n3)
          Returns a new array of random values.
static float[] randfloat(int n1)
          Returns a new array of random values.
static float[][] randfloat(int n1, int n2)
          Returns a new array of random values.
static float[][][] randfloat(int n1, int n2, int n3)
          Returns a new array of random values.
static float[] randfloat(java.util.Random random, int n1)
          Returns a new array of random values.
static float[][] randfloat(java.util.Random random, int n1, int n2)
          Returns a new array of random values.
static float[][][] randfloat(java.util.Random random, int n1, int n2, int n3)
          Returns a new array of random values.
static int[] randint(int n1)
          Returns a new array of random values.
static int[][] randint(int n1, int n2)
          Returns a new array of random values.
static int[][][] randint(int n1, int n2, int n3)
          Returns a new array of random values.
static int[] randint(java.util.Random random, int n1)
          Returns a new array of random values.
static int[][] randint(java.util.Random random, int n1, int n2)
          Returns a new array of random values.
static int[][][] randint(java.util.Random random, int n1, int n2, int n3)
          Returns a new array of random values.
static long[] randlong(int n1)
          Returns a new array of random values.
static long[][] randlong(int n1, int n2)
          Returns a new array of random values.
static long[][][] randlong(int n1, int n2, int n3)
          Returns a new array of random values.
static long[] randlong(java.util.Random random, int n1)
          Returns a new array of random values.
static long[][] randlong(java.util.Random random, int n1, int n2)
          Returns a new array of random values.
static long[][][] randlong(java.util.Random random, int n1, int n2, int n3)
          Returns a new array of random values.
static byte[][] reshape(int n1, int n2, byte[] rx)
          Reshapes a 1-D array into a 2-D array with specified dimensions.
static double[][] reshape(int n1, int n2, double[] rx)
          Reshapes a 1-D array into a 2-D array with specified dimensions.
static float[][] reshape(int n1, int n2, float[] rx)
          Reshapes a 1-D array into a 2-D array with specified dimensions.
static int[][] reshape(int n1, int n2, int[] rx)
          Reshapes a 1-D array into a 2-D array with specified dimensions.
static byte[][][] reshape(int n1, int n2, int n3, byte[] rx)
          Reshapes a 1-D array into a 3-D array with specified dimensions.
static double[][][] reshape(int n1, int n2, int n3, double[] rx)
          Reshapes a 1-D array into a 3-D array with specified dimensions.
static float[][][] reshape(int n1, int n2, int n3, float[] rx)
          Reshapes a 1-D array into a 3-D array with specified dimensions.
static int[][][] reshape(int n1, int n2, int n3, int[] rx)
          Reshapes a 1-D array into a 3-D array with specified dimensions.
static long[][][] reshape(int n1, int n2, int n3, long[] rx)
          Reshapes a 1-D array into a 3-D array with specified dimensions.
static short[][][] reshape(int n1, int n2, int n3, short[] rx)
          Reshapes a 1-D array into a 3-D array with specified dimensions.
static long[][] reshape(int n1, int n2, long[] rx)
          Reshapes a 1-D array into a 2-D array with specified dimensions.
static short[][] reshape(int n1, int n2, short[] rx)
          Reshapes a 1-D array into a 2-D array with specified dimensions.
static byte[] reverse(byte[] rx)
           
static void reverse(byte[] rx, byte[] ry)
           
static double[] reverse(double[] rx)
           
static void reverse(double[] rx, double[] ry)
           
static float[] reverse(float[] rx)
           
static void reverse(float[] rx, float[] ry)
           
static int[] reverse(int[] rx)
           
static void reverse(int[] rx, int[] ry)
           
static long[] reverse(long[] rx)
           
static void reverse(long[] rx, long[] ry)
           
static short[] reverse(short[] rx)
           
static void reverse(short[] rx, short[] ry)
           
static double[] sgn(double[] rx)
           
static double[][] sgn(double[][] rx)
           
static double[][][] sgn(double[][][] rx)
           
static void sgn(double[][][] rx, double[][][] ry)
           
static void sgn(double[][] rx, double[][] ry)
           
static void sgn(double[] rx, double[] ry)
           
static float[] sgn(float[] rx)
           
static float[][] sgn(float[][] rx)
           
static float[][][] sgn(float[][][] rx)
           
static void sgn(float[][][] rx, float[][][] ry)
           
static void sgn(float[][] rx, float[][] ry)