public class ArrayMath
extends java.lang.Object
The math methods mirror those in the standard Math
,
but include overloaded methods that return floats when passed float
arguments. This eliminates tedious and ugly casts when using floats.
This class also provides utility functions for working with arrays of primitive types, including arrays of real numbers (floats and doubles) and complex numbers (pairs of floats and doubles). Many of the array methods (e.g., sqrt) overload scalar math methods.
Here is an example of using this class:
import static edu.mines.jtk.util.ArrayMath.*;
...
float[] x = randfloat(10); // an array of 10 random floats
System.out.println("x="); dump(x); // print x
float[] y = sqrt(x); // an array of square roots of those floats
System.out.println("y="); dump(y); // print y
float z = sqrt(x[0]); // no (float) cast required
System.out.println("z="); // print z
...
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, methods mul that multiply two arrays of real numbers have corresponding methods cmul that 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 outputMany more utility methods are included as well, for sorting, searching, etc.
Math
Modifier and Type | Field and Description |
---|---|
static double |
DBL_E
The double value that is closer than any other to e,
the base of the natural logarithm.
|
static double |
DBL_EPSILON
The smallest double value e such that (1+e) does not equal 1.
|
static double |
DBL_MAX
The maximum positive double value.
|
static double |
DBL_MIN
The minimum positive double value.
|
static double |
DBL_PI
The double value that is closer than any other to pi,
the ratio of the circumference of a circle to its diameter.
|
static double |
E
The double value that is closer than any other to e,
the base of the natural logarithm.
|
static float |
FLT_E
The float value that is closer than any other to e,
the base of the natural logarithm.
|
static float |
FLT_EPSILON
The smallest float value e such that (1+e) does not equal 1.
|
static float |
FLT_MAX
The maximum positive float value.
|
static float |
FLT_MIN
The minimum positive float value.
|
static float |
FLT_PI
The float value that is closer than any other to pi,
the ratio of the circumference of a circle to its diameter.
|
static double |
PI
The double value that is closer than any other to pi,
the ratio of the circumference of a circle to its diameter.
|
Modifier and Type | Method and Description |
---|---|
static double |
abs(double x)
Returns the absolute value of the specified value.
|
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 x)
Returns the absolute value of the specified value.
|
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 int |
abs(int x)
Returns the absolute value of the specified value.
|
static long |
abs(long x)
Returns the absolute value of the specified value.
|
static double |
acos(double x)
Returns the arc cosine of the specified value, in the range
0.0 through pi.
|
static float |
acos(float x)
Returns the arc cosine of the specified value, in the range
0.0 through pi.
|
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 double |
asin(double x)
Returns the arc sine of the specified value, in the range
-pi/2 through pi/2.
|
static float |
asin(float x)
Returns the arc sine of the specified value, in the range
-pi/2 through pi/2.
|
static double |
atan(double x)
Returns the arc tangent of the specified value, in the range
-pi/2 through pi/2.
|
static float |
atan(float x)
Returns the arc tangent of the specified value, in the range
-pi/2 through pi/2.
|
static double |
atan2(double y,
double x)
Computes the arc tangent of the specified y/x, in the range
-pi to pi.
|
static float |
atan2(float y,
float x)
Computes the arc tangent of the specified y/x, in the range
-pi to pi.
|
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 |
cbrt(double a)
Returns the cube root of the specified value.
|
static float |
cbrt(float a)
Returns the cube root of the specified value.
|
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 double |
ceil(double x)
Returns the smallest (closest to negative infinity) value that is greater
than or equal to the argument and is equal to a mathematical integer.
|
static float |
ceil(float x)
Returns the smallest (closest to negative infinity) value that is greater
than or equal to the argument and is equal to a mathematical integer.
|
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 x)
Returns the trigonometric cosine of an angle.
|
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 x)
Returns the trigonometric cosine of an angle.
|
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 |
cosh(double x)
Returns the hyperbolic cosine of the specified value.
|
static float |
cosh(float x)
Returns the hyperbolic cosine of the specified value.
|
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 boolean |
distinct(byte[][][] x,
byte[][][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(byte[][] x,
byte[][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(byte[] x,
byte[] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(double[][][] x,
double[][][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(double[][] x,
double[][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(double[] x,
double[] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(float[][][] x,
float[][][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(float[][] x,
float[][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(float[] x,
float[] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(int[][][] x,
int[][][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(int[][] x,
int[][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(int[] x,
int[] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(long[][][] x,
long[][][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(long[][] x,
long[][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(long[] x,
long[] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(short[][][] x,
short[][][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(short[][] x,
short[][] y)
Determines whether the two specified arrays are distinct.
|
static boolean |
distinct(short[] x,
short[] y)
Determines whether the two specified arrays are distinct.
|
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 x)
Returns the value of e raised to the specified power.
|
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 x)
Returns the value of e raised to the specified power.
|
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 double |
expm1(double x)
Returns ex-1.
|
static float |
expm1(float x)
Returns ex-1.
|
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 double |
floor(double x)
Returns the largest (closest to positive infinity) value that is less
than or equal to the argument and is equal to a mathematical integer.
|
static float |
floor(float x)
Returns the largest (closest to positive infinity) value that is less
than or equal to the argument and is equal to a mathematical integer.
|
static double |
hypot(double x,
double y)
Returns the hypotenuse for two given values.
|
static float |
hypot(float x,
float y)
Returns the hypotenuse for two given values.
|
static double |
IEEEremainder(double f1,
double f2)
Computes the remainder operation on two arguments as prescribed by the
IEEE 754 standard.
|
static float |
IEEEremainder(float f1,
float f2)
Computes the remainder operation on two arguments as prescribed by the
IEEE 754 standard.
|
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 x)
Returns the natural logarithm (base e) of the specified value.
|
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 x)
Returns the natural logarithm (base e) of the specified value.
|
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 x)
Returns the logarithm base 10 of the specified value.
|
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 x)
Returns the logarithm base 10 of the specified value.
|
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 double |
log1p(double x)
Returns the natural logarithm of the sum of the argument and 1.
|
static float |
log1p(float x)
Returns the natural logarithm of the sum of the argument and 1.
|
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 double |
max(double a,
double b)
Returns the maximum of the specified values.
|
static double |
max(double a,
double b,
double c)
Returns the maximum of the specified values.
|
static double |
max(double a,
double b,
double c,
double d)
Returns the maximum of the specified values.
|
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 float |
max(float a,
float b)
Returns the maximum of the specified values.
|
static float |
max(float a,
float b,
float c)
Returns the maximum of the specified values.
|
static float |
max(float a,
float b,
float c,
float d)
Returns the maximum of the specified values.
|
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 int |
max(int a,
int b)
Returns the maximum of the specified values.
|
static int |
max(int a,
int b,
int c)
Returns the maximum of the specified values.
|
static int |
max(int a,
int b,
int c,
int d)
Returns the maximum of the specified values.
|
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 long |
max(long a,
long b)
Returns the maximum of the specified values.
|
static long |
max(long a,
long b,
long c)
Returns the maximum of the specified values.
|
static long |
max(long a,
long b,
long c,
long d)
Returns the maximum of the specified values.
|
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 double |
min(double a,
double b)
Returns the minimum of the specified values.
|
static double |
min(double a,
double b,
double c)
Returns the minimum of the specified values.
|
static double |
min(double a,
double b,
double c,
double d)
Returns the minimum of the specified values.
|
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 float |
min(float a,
float b)
Returns the minimum of the specified values.
|
static float |
min(float a,
float b,
float c)
Returns the minimum of the specified values.
|
static float |
min(float a,
float b,
float c,
float d)
Returns the minimum of the specified values.
|
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 int |
min(int a,
int b)
Returns the minimum of the specified values.
|
static int |
min(int a,
int b,
int c)
Returns the minimum of the specified values.
|
static int |
min(int a,
int b,
int c,
int d)
Returns the minimum of the specified values.
|
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 long |
min(long a,
long b)
Returns the minimum of the specified values.
|
static long |
min(long a,
long b,
long c)
Returns the minimum of the specified values.
|
static long |
min(long a,
long b,
long c,
long d)
Returns the minimum of the specified values.
|
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 double |
pow(double x,
double y)
Returns the value of x raised to the y'th power.
|
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 float |
pow(float x,
float y)
Returns the value of x raised to the y'th power.
|
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 double |
random()
Returns a positive number that is greater than or equal to 0.0, and
less than 1.0.
|
static double |
randomDouble()
Returns a positive number that is greater than or equal to 0.0, and
less than 1.0.
|
static float |
randomFloat()
Returns a positive number that is greater than or equal to 0.0, and
less than 1.0.
|
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 |
rint(double x)
Returns the value that is closest to the specified value and is equal
to a mathematical integer.
|
static float |
rint(float x)
Returns the value that is closest to the specified value and is equal
to a mathematical integer.
|
static long |
round(double x)
Returns the closest long to the specified value.
|
static int |
round(float x)
Returns the closest int to the specified value.
|
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) |
static void |
sgn(float[] rx,
float[] ry) |
static double |
signum(double x)
Returns the signum of the specified value.
|
static float |
signum(float x)
Returns the signum of the specified value.
|
static double |
sin(double x)
Returns the trigonometric sine of an angle.
|
static double[] |
sin(double[] rx) |
static double[][] |
sin(double[][] rx) |
static double[][][] |
sin(double[][][] rx) |
static void |
sin(double[][][] rx,
double[][][] ry) |
static void |
sin(double[][] rx,
double[][] ry) |
static void |
sin(double[] rx,
double[] ry) |
static float |
sin(float x)
Returns the trigonometric sine of an angle.
|
static float[] |
sin(float[] rx) |
static float[][] |
sin(float[][] rx) |
static float[][][] |
sin(float[][][] rx) |
static void |
sin(float[][][] rx,
float[][][] ry) |
static void |
sin(float[][] rx,
float[][] ry) |
static void |
sin(float[] rx,
float[] ry) |
static double |
sinh(double x)
Returns the hyperbolic sine of the specified value.
|
static float |
sinh(float x)
Returns the hyperbolic sine of the specified value.
|
static double |
sqrt(double x)
Returns the positive square root of a the specified value.
|
static double[] |
sqrt(double[] rx) |
static double[][] |
sqrt(double[][] rx) |
static double[][][] |
sqrt(double[][][] rx) |
static void |
sqrt(double[][][] rx,
double[][][] ry) |
static void |
sqrt(double[][] rx,
double[][] ry) |
static void |
sqrt(double[] rx,
double[] ry) |
static float |
sqrt(float x)
Returns the positive square root of a the specified value.
|
static float[] |
sqrt(float[] rx) |
static float[][] |
sqrt(float[][] rx) |
static float[][][] |
sqrt(float[][][] rx) |
static void |
sqrt(float[][][] rx,
float[][][] ry) |
static void |
sqrt(float[][] rx,
float[][] ry) |
static void |
sqrt(float[] rx,
float[] ry) |
static double[][][] |
sub(double[][][] rx,
double rb) |
static double[][][] |
sub(double[][][] rx,
double[][][] ry) |
static void |
sub(double[][][] rx,
double[][][] ry,
double[][][] rz) |
static void |
sub(double[][][] rx,
double rb,
double[][][] rz) |
static double[][] |
sub(double[][] rx,
double rb) |
static double[][] |
sub(double[][] rx,
double[][] ry) |
static void |
sub(double[][] rx,
double[][] ry,
double[][] rz) |
static void |
sub(double[][] rx,
double rb,
double[][] rz) |
static double[] |
sub(double[] rx,
double rb) |
static double[] |
sub(double[] rx,
double[] ry) |
static void |
sub(double[] rx,
double[] ry,
double[] rz) |
static void |
sub(double[] rx,
double rb,
double[] rz) |
static double[] |
sub(double ra,
double[] ry) |
static double[][] |
sub(double ra,
double[][] ry) |
static double[][][] |
sub(double ra,
double[][][] ry) |
static void |
sub(double ra,
double[][][] ry,
double[][][] rz) |
static void |
sub(double ra,
double[][] ry,
double[][] rz) |
static void |
sub(double ra,
double[] ry,
double[] rz) |
static float[][][] |
sub(float[][][] rx,
float rb) |
static float[][][] |
sub(float[][][] rx,
float[][][] ry) |
static void |
sub(float[][][] rx,
float[][][] ry,
float[][][] rz) |
static void |
sub(float[][][] rx,
float rb,
float[][][] rz) |
static float[][] |
sub(float[][] rx,
float rb) |
static float[][] |
sub(float[][] rx,
float[][] ry) |
static void |
sub(float[][] rx,
float[][] ry,
float[][] rz) |
static void |
sub(float[][] rx,
float rb,
float[][] rz) |
static float[] |
sub(float[] rx,
float rb) |
static float[] |
sub(float[] rx,
float[] ry) |
static void |
sub(float[] rx,
float[] ry,
float[] rz) |
static void |
sub(float[] rx,
float rb,
float[] rz) |
static float[] |
sub(float ra,
float[] ry) |
static float[][] |
sub(float ra,
float[][] ry) |
static float[][][] |
sub(float ra,
float[][][] ry) |
static void |
sub(float ra,
float[][][] ry,
float[][][] rz) |
static void |
sub(float ra,
float[][] ry,
float[][] rz) |
static void |
sub(float ra,
float[] ry,
float[] rz) |
static byte |
sum(byte[] rx) |
static byte |
sum(byte[][] rx) |
static byte |
sum(byte[][][] rx) |
static double |
sum(double[] rx) |
static double |
sum(double[][] rx) |
static double |
sum(double[][][] rx) |
static float |
sum(float[] rx) |
static float |
sum(float[][] rx) |
static float |
sum(float[][][] rx) |
static int |
sum(int[] rx) |
static int |
sum(int[][] rx) |
static int |
sum(int[][][] rx) |
static long |
sum(long[] rx) |
static long |
sum(long[][] rx) |
static long |
sum(long[][][] rx) |
static short |
sum(short[] rx) |
static short |
sum(short[][] rx) |
static short |
sum(short[][][] rx) |
static double |
tan(double x)
Returns the trigonometric tangent of an angle.
|
static float |
tan(float x)
Returns the trigonometric tangent of an angle.
|
static double |
tanh(double x)
Returns the hyperbolic tangent of the specified value.
|
static float |
tanh(float x)
Returns the hyperbolic tangent of the specified value.
|
static double |
toDegrees(double angrad)
Converts an angle measured in radians to degrees.
|
static float |
toDegrees(float angrad)
Converts an angle measured in radians to degrees.
|
static float[] |
tofloat(byte[] rx) |
static float[][] |
tofloat(byte[][] rx) |
static float[][][] |
tofloat(byte[][][] rx) |
static double |
toRadians(double angdeg)
Converts an angle measured in degrees to radians.
|
static float |
toRadians(float angdeg)
Converts an angle measured in degrees to radians.
|
static byte[][] |
transpose(byte[][] rx)
Transpose the specified 2-D array.
|
static double[][] |
transpose(double[][] rx)
Transpose the specified 2-D array.
|
static float[][] |
transpose(float[][] rx)
Transpose the specified 2-D array.
|
static int[][] |
transpose(int[][] rx)
Transpose the specified 2-D array.
|
static long[][] |
transpose(long[][] rx)
Transpose the specified 2-D array.
|
static short[][] |
transpose(short[][] rx)
Transpose the specified 2-D array.
|
static double |
ulp(double d)
Returns the size of an ulp of the argument.
|
static float |
ulp(float d)
Returns the size of an ulp of the argument.
|
static void |
zero(byte[] rx)
Zeros the the specified array.
|
static void |
zero(byte[][] rx)
Zeros the the specified array.
|
static void |
zero(byte[][][] rx)
Zeros the the specified array.
|
static void |
zero(double[] rx)
Zeros the the specified array.
|
static void |
zero(double[][] rx)
Zeros the the specified array.
|
static void |
zero(double[][][] rx)
Zeros the the specified array.
|
static void |
zero(float[] rx)
Zeros the the specified array.
|
static void |
zero(float[][] rx)
Zeros the the specified array.
|
static void |
zero(float[][][] rx)
Zeros the the specified array.
|
static void |
zero(int[] rx)
Zeros the the specified array.
|
static void |
zero(int[][] rx)
Zeros the the specified array.
|
static void |
zero(int[][][] rx)
Zeros the the specified array.
|
static void |
zero(long[] rx)
Zeros the the specified array.
|
static void |
zero(long[][] rx)
Zeros the the specified array.
|
static void |
zero(long[][][] rx)
Zeros the the specified array.
|
static void |
zero(short[] rx)
Zeros the the specified array.
|
static void |
zero(short[][] rx)
Zeros the the specified array.
|
static void |
zero(short[][][] rx)
Zeros the the specified array.
|
static byte[] |
zerobyte(int n1)
Returns a new array of zeros.
|
static byte[][] |
zerobyte(int n1,
int n2)
Returns a new array of zeros.
|
static byte[][][] |
zerobyte(int n1,
int n2,
int n3)
Returns a new array of zeros.
|
static double[] |
zerodouble(int n1)
Returns a new array of zeros.
|
static double[][] |
zerodouble(int n1,
int n2)
Returns a new array of zeros.
|
static double[][][] |
zerodouble(int n1,
int n2,
int n3)
Returns a new array of zeros.
|
static float[] |
zerofloat(int n1)
Returns a new array of zeros.
|
static float[][] |
zerofloat(int n1,
int n2)
Returns a new array of zeros.
|
static float[][][] |
zerofloat(int n1,
int n2,
int n3)
Returns a new array of zeros.
|
static int[] |
zeroint(int n1)
Returns a new array of zeros.
|
static int[][] |
zeroint(int n1,
int n2)
Returns a new array of zeros.
|
static int[][][] |
zeroint(int n1,
int n2,
int n3)
Returns a new array of zeros.
|
static long[] |
zerolong(int n1)
Returns a new array of zeros.
|
static long[][] |
zerolong(int n1,
int n2)
Returns a new array of zeros.
|
static long[][][] |
zerolong(int n1,
int n2,
int n3)
Returns a new array of zeros.
|
static short[] |
zeroshort(int n1)
Returns a new array of zeros.
|
static short[][] |
zeroshort(int n1,
int n2)
Returns a new array of zeros.
|
static short[][][] |
zeroshort(int n1,
int n2,
int n3)
Returns a new array of zeros.
|
public static final double E
public static final float FLT_E
public static final double DBL_E
public static final double PI
public static final float FLT_PI
public static final double DBL_PI
public static final float FLT_MAX
public static final float FLT_MIN
public static final float FLT_EPSILON
public static final double DBL_MAX
public static final double DBL_MIN
public static final double DBL_EPSILON
public static float sin(float x)
x
- the angle, in radians.public static double sin(double x)
x
- the angle, in radians.public static float cos(float x)
x
- the angle, in radians.public static double cos(double x)
x
- the angle, in radians.public static float tan(float x)
x
- the angle, in radians.public static double tan(double x)
x
- the angle, in radians.public static float asin(float x)
x
- the value.public static double asin(double x)
x
- the value.public static float acos(float x)
x
- the value.public static double acos(double x)
x
- the value.public static float atan(float x)
x
- the value.public static double atan(double x)
x
- the value.public static float atan2(float y, float x)
y
- the ordinate coordinate y.x
- the abscissa coordinate x.public static double atan2(double y, double x)
y
- the ordinate coordinate y.x
- the abscissa coordinate x.public static float toRadians(float angdeg)
angdeg
- an angle, in degrees.public static double toRadians(double angdeg)
angdeg
- an angle, in degrees.public static float toDegrees(float angrad)
angrad
- an angle, in radians.public static double toDegrees(double angrad)
angrad
- an angle, in radians.public static float exp(float x)
x
- the exponent.public static double exp(double x)
x
- the exponent.public static float log(float x)
x
- the value.public static double log(double x)
x
- the value.public static float log10(float x)
x
- the value.public static double log10(double x)
x
- the value.public static float sqrt(float x)
x
- the value.public static double sqrt(double x)
x
- the value.public static float pow(float x, float y)
x
- the base.y
- the exponent.public static double pow(double x, double y)
x
- the base.y
- the exponent.public static float sinh(float x)
x
- the value.public static double sinh(double x)
x
- the value.public static float cosh(float x)
x
- the value.public static double cosh(double x)
x
- the value.public static float tanh(float x)
x
- the value.public static double tanh(double x)
x
- the value.public static float ceil(float x)
x
- a value.public static double ceil(double x)
x
- a value.public static float floor(float x)
x
- a value.public static double floor(double x)
x
- a value.public static float rint(float x)
x
- the value.public static double rint(double x)
x
- the value.public static int round(float x)
(int)Math.floor(a+0.5f)
.x
- the value.public static long round(double x)
(long)Math.floor(a+0.5)
.x
- the value.public static float signum(float x)
x
- the value.public static double signum(double x)
x
- the value.public static int abs(int x)
x
- the value.public static long abs(long x)
x
- the value.public static float abs(float x)
abs(-0.0f)
returns -0.0f
;
the sign bit is not cleared.
If this is a problem, use Math.abs
.x
- the value.public static double abs(double x)
abs(-0.0d)
returns -0.0d
;
the sign bit is not cleared.
If this is a problem, use Math.abs
.x
- the value.public static int max(int a, int b)
a
- a value.b
- a value.public static int max(int a, int b, int c)
a
- a value.b
- a value.c
- a value.public static int max(int a, int b, int c, int d)
a
- a value.b
- a value.c
- a value.d
- a value.public static long max(long a, long b)
a
- a value.b
- a value.public static long max(long a, long b, long c)
a
- a value.b
- a value.c
- a value.public static long max(long a, long b, long c, long d)
a
- a value.b
- a value.c
- a value.d
- a value.public static float max(float a, float b)
a
- a value.b
- a value.public static float max(float a, float b, float c)
a
- a value.b
- a value.c
- a value.public static float max(float a, float b, float c, float d)
a
- a value.b
- a value.c
- a value.d
- a value.public static double max(double a, double b)
a
- a value.b
- a value.public static double max(double a, double b, double c)
a
- a value.b
- a value.c
- a value.public static double max(double a, double b, double c, double d)
a
- a value.b
- a value.c
- a value.d
- a value.public static int min(int a, int b)
a
- a value.b
- a value.public static int min(int a, int b, int c)
a
- a value.b
- a value.c
- a value.public static int min(int a, int b, int c, int d)
a
- a value.b
- a value.c
- a value.d
- a value.public static long min(long a, long b)
a
- a value.b
- a value.public static long min(long a, long b, long c)
a
- a value.b
- a value.c
- a value.public static long min(long a, long b, long c, long d)
a
- a value.b
- a value.c
- a value.d
- a value.public static float min(float a, float b)
a
- a value.b
- a value.public static float min(float a, float b, float c)
a
- a value.b
- a value.c
- a value.public static float min(float a, float b, float c, float d)
a
- a value.b
- a value.c
- a value.d
- a value.public static double min(double a, double b)
a
- a value.b
- a value.public static double min(double a, double b, double c)
a
- a value.b
- a value.c
- a value.public static double min(double a, double b, double c, double d)
a
- a value.b
- a value.c
- a value.d
- a value.public static double cbrt(double a)
a
- a value.public static float cbrt(float a)
a
- a value.public static double IEEEremainder(double f1, double f2)
f1
- the dividend.f2
- the divisor.public static float IEEEremainder(float f1, float f2)
f1
- the dividend.f2
- the divisor.public static double random()
public static double randomDouble()
public static float randomFloat()
public static double ulp(double d)
d
- the value whose ulp is to be returned.public static float ulp(float d)
d
- the value whose ulp is to be returned.public static double hypot(double x, double y)
x
- a value.y
- a value.public static float hypot(float x, float y)
x
- a value.y
- a value.public static double expm1(double x)
x
- the exponent.public static float expm1(float x)
x
- the exponent.public static double log1p(double x)
x
- a value.public static float log1p(float x)
x
- a value.public static byte[] zerobyte(int n1)
n1
- 1st array dimension.public static byte[][] zerobyte(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static byte[][][] zerobyte(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void zero(byte[] rx)
rx
- the array.public static void zero(byte[][] rx)
rx
- the array.public static void zero(byte[][][] rx)
rx
- the array.public static short[] zeroshort(int n1)
n1
- 1st array dimension.public static short[][] zeroshort(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static short[][][] zeroshort(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void zero(short[] rx)
rx
- the array.public static void zero(short[][] rx)
rx
- the array.public static void zero(short[][][] rx)
rx
- the array.public static int[] zeroint(int n1)
n1
- 1st array dimension.public static int[][] zeroint(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static int[][][] zeroint(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void zero(int[] rx)
rx
- the array.public static void zero(int[][] rx)
rx
- the array.public static void zero(int[][][] rx)
rx
- the array.public static long[] zerolong(int n1)
n1
- 1st array dimension.public static long[][] zerolong(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static long[][][] zerolong(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void zero(long[] rx)
rx
- the array.public static void zero(long[][] rx)
rx
- the array.public static void zero(long[][][] rx)
rx
- the array.public static float[] zerofloat(int n1)
n1
- 1st array dimension.public static float[][] zerofloat(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] zerofloat(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void zero(float[] rx)
rx
- the array.public static void zero(float[][] rx)
rx
- the array.public static void zero(float[][][] rx)
rx
- the array.public static float[] czerofloat(int n1)
n1
- 1st array dimension.public static float[][] czerofloat(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] czerofloat(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void czero(float[] cx)
cx
- the array.public static void czero(float[][] cx)
cx
- the array.public static void czero(float[][][] cx)
cx
- the array.public static double[] zerodouble(int n1)
n1
- 1st array dimension.public static double[][] zerodouble(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] zerodouble(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void zero(double[] rx)
rx
- the array.public static void zero(double[][] rx)
rx
- the array.public static void zero(double[][][] rx)
rx
- the array.public static double[] czerodouble(int n1)
n1
- 1st array dimension.public static double[][] czerodouble(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] czerodouble(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void czero(double[] cx)
cx
- the array.public static void czero(double[][] cx)
cx
- the array.public static void czero(double[][][] cx)
cx
- the array.public static int[] randint(int n1)
n1
- 1st array dimension.public static int[][] randint(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static int[][][] randint(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static int[] randint(java.util.Random random, int n1)
random
- random number generator.n1
- 1st array dimension.public static int[][] randint(java.util.Random random, int n1, int n2)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.public static int[][][] randint(java.util.Random random, int n1, int n2, int n3)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void rand(int[] rx)
rx
- the array.public static void rand(int[][] rx)
rx
- the array.public static void rand(int[][][] rx)
rx
- the array.public static void rand(java.util.Random random, int[] rx)
random
- random number generator.rx
- the array.public static void rand(java.util.Random random, int[][] rx)
random
- random number generator.rx
- the array.public static void rand(java.util.Random random, int[][][] rx)
random
- random number generator.rx
- the array.public static long[] randlong(int n1)
n1
- 1st array dimension.public static long[][] randlong(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static long[][][] randlong(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static long[] randlong(java.util.Random random, int n1)
random
- random number generator.n1
- 1st array dimension.public static long[][] randlong(java.util.Random random, int n1, int n2)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.public static long[][][] randlong(java.util.Random random, int n1, int n2, int n3)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void rand(long[] rx)
rx
- the array.public static void rand(long[][] rx)
rx
- the array.public static void rand(long[][][] rx)
rx
- the array.public static void rand(java.util.Random random, long[] rx)
random
- random number generator.rx
- the array.public static void rand(java.util.Random random, long[][] rx)
random
- random number generator.rx
- the array.public static void rand(java.util.Random random, long[][][] rx)
random
- random number generator.rx
- the array.public static float[] randfloat(int n1)
n1
- 1st array dimension.public static float[][] randfloat(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] randfloat(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static float[] randfloat(java.util.Random random, int n1)
random
- random number generator.n1
- 1st array dimension.public static float[][] randfloat(java.util.Random random, int n1, int n2)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] randfloat(java.util.Random random, int n1, int n2, int n3)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void rand(float[] rx)
rx
- the array.public static void rand(float[][] rx)
rx
- the array.public static void rand(float[][][] rx)
rx
- the array.public static void rand(java.util.Random random, float[] rx)
random
- random number generator.rx
- the array.public static void rand(java.util.Random random, float[][] rx)
random
- random number generator.rx
- the array.public static void rand(java.util.Random random, float[][][] rx)
random
- random number generator.rx
- the array.public static float[] crandfloat(int n1)
n1
- 1st array dimension.public static float[][] crandfloat(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] crandfloat(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static float[] crandfloat(java.util.Random random, int n1)
random
- random number generator.n1
- 1st array dimension.public static float[][] crandfloat(java.util.Random random, int n1, int n2)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] crandfloat(java.util.Random random, int n1, int n2, int n3)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void crand(float[] cx)
cx
- the array.public static void crand(float[][] cx)
cx
- the array.public static void crand(float[][][] cx)
cx
- the array.public static void crand(java.util.Random random, float[] cx)
random
- random number generator.cx
- the array.public static void crand(java.util.Random random, float[][] cx)
random
- random number generator.cx
- the array.public static void crand(java.util.Random random, float[][][] cx)
random
- random number generator.cx
- the array.public static double[] randdouble(int n1)
n1
- 1st array dimension.public static double[][] randdouble(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] randdouble(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static double[] randdouble(java.util.Random random, int n1)
random
- random number generator.n1
- 1st array dimension.public static double[][] randdouble(java.util.Random random, int n1, int n2)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] randdouble(java.util.Random random, int n1, int n2, int n3)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void rand(double[] rx)
rx
- the array.public static void rand(double[][] rx)
rx
- the array.public static void rand(double[][][] rx)
rx
- the array.public static void rand(java.util.Random random, double[] rx)
random
- random number generator.rx
- the array.public static void rand(java.util.Random random, double[][] rx)
random
- random number generator.rx
- the array.public static void rand(java.util.Random random, double[][][] rx)
random
- random number generator.rx
- the array.public static double[] cranddouble(int n1)
n1
- 1st array dimension.public static double[][] cranddouble(int n1, int n2)
n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] cranddouble(int n1, int n2, int n3)
n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static double[] cranddouble(java.util.Random random, int n1)
random
- random number generator.n1
- 1st array dimension.public static double[][] cranddouble(java.util.Random random, int n1, int n2)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] cranddouble(java.util.Random random, int n1, int n2, int n3)
random
- random number generator.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void crand(double[] cx)
cx
- the array.public static void crand(double[][] cx)
cx
- the array.public static void crand(double[][][] cx)
cx
- the array.public static void crand(java.util.Random random, double[] cx)
random
- random number generator.cx
- the array.public static void crand(java.util.Random random, double[][] cx)
random
- random number generator.cx
- the array.public static void crand(java.util.Random random, double[][][] cx)
random
- random number generator.cx
- the array.public static byte[] fillbyte(byte ra, int n1)
ra
- the value.n1
- 1st array dimension.public static byte[][] fillbyte(byte ra, int n1, int n2)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.public static byte[][][] fillbyte(byte ra, int n1, int n2, int n3)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void fill(byte ra, byte[] rx)
ra
- the value.rx
- the array.public static void fill(byte ra, byte[][] rx)
ra
- the value.rx
- the array.public static void fill(byte ra, byte[][][] rx)
ra
- the value.rx
- the array.public static short[] fillshort(short ra, int n1)
ra
- the value.n1
- 1st array dimension.public static short[][] fillshort(short ra, int n1, int n2)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.public static short[][][] fillshort(short ra, int n1, int n2, int n3)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void fill(short ra, short[] rx)
ra
- the value.rx
- the array.public static void fill(short ra, short[][] rx)
ra
- the value.rx
- the array.public static void fill(short ra, short[][][] rx)
ra
- the value.rx
- the array.public static int[] fillint(int ra, int n1)
ra
- the value.n1
- 1st array dimension.public static int[][] fillint(int ra, int n1, int n2)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.public static int[][][] fillint(int ra, int n1, int n2, int n3)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void fill(int ra, int[] rx)
ra
- the value.rx
- the array.public static void fill(int ra, int[][] rx)
ra
- the value.rx
- the array.public static void fill(int ra, int[][][] rx)
ra
- the value.rx
- the array.public static long[] filllong(long ra, int n1)
ra
- the value.n1
- 1st array dimension.public static long[][] filllong(long ra, int n1, int n2)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.public static long[][][] filllong(long ra, int n1, int n2, int n3)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void fill(long ra, long[] rx)
ra
- the value.rx
- the array.public static void fill(long ra, long[][] rx)
ra
- the value.rx
- the array.public static void fill(long ra, long[][][] rx)
ra
- the value.rx
- the array.public static float[] fillfloat(float ra, int n1)
ra
- the value.n1
- 1st array dimension.public static float[][] fillfloat(float ra, int n1, int n2)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] fillfloat(float ra, int n1, int n2, int n3)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void fill(float ra, float[] rx)
ra
- the value.rx
- the array.public static void fill(float ra, float[][] rx)
ra
- the value.rx
- the array.public static void fill(float ra, float[][][] rx)
ra
- the value.rx
- the array.public static float[] cfillfloat(Cfloat ca, int n1)
ca
- the value.n1
- 1st array dimension.public static float[][] cfillfloat(Cfloat ca, int n1, int n2)
ca
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] cfillfloat(Cfloat ca, int n1, int n2, int n3)
ca
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void cfill(Cfloat ca, float[] cx)
ca
- the value.cx
- the array.public static void cfill(Cfloat ca, float[][] cx)
ca
- the value.cx
- the array.public static void cfill(Cfloat ca, float[][][] cx)
ca
- the value.cx
- the array.public static double[] filldouble(double ra, int n1)
ra
- the value.n1
- 1st array dimension.public static double[][] filldouble(double ra, int n1, int n2)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] filldouble(double ra, int n1, int n2, int n3)
ra
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void fill(double ra, double[] rx)
ra
- the value.rx
- the array.public static void fill(double ra, double[][] rx)
ra
- the value.rx
- the array.public static void fill(double ra, double[][][] rx)
ra
- the value.rx
- the array.public static double[] cfilldouble(Cdouble ca, int n1)
ca
- the value.n1
- 1st array dimension.public static double[][] cfilldouble(Cdouble ca, int n1, int n2)
ca
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] cfilldouble(Cdouble ca, int n1, int n2, int n3)
ca
- the value.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void cfill(Cdouble ca, double[] cx)
ca
- the value.cx
- the array.public static void cfill(Cdouble ca, double[][] cx)
ca
- the value.cx
- the array.public static void cfill(Cdouble ca, double[][][] cx)
ca
- the value.cx
- the array.public static byte[] rampbyte(byte ra, byte rb1, int n1)
ra
- value of the first element.rb1
- gradient in 1st dimension.n1
- 1st array dimension.public static byte[][] rampbyte(byte ra, byte rb1, byte rb2, int n1, int n2)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.public static byte[][][] rampbyte(byte ra, byte rb1, byte rb2, byte rb3, int n1, int n2, int n3)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void ramp(byte ra, byte rb1, byte[] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rx
- the array.public static void ramp(byte ra, byte rb1, byte rb2, byte[][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rx
- the array.public static void ramp(byte ra, byte rb1, byte rb2, byte rb3, byte[][][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.rx
- the array.public static short[] rampshort(short ra, short rb1, int n1)
ra
- value of the first element.rb1
- gradient in 1st dimension.n1
- 1st array dimension.public static short[][] rampshort(short ra, short rb1, short rb2, int n1, int n2)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.public static short[][][] rampshort(short ra, short rb1, short rb2, short rb3, int n1, int n2, int n3)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void ramp(short ra, short rb1, short[] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rx
- the array.public static void ramp(short ra, short rb1, short rb2, short[][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rx
- the array.public static void ramp(short ra, short rb1, short rb2, short rb3, short[][][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.rx
- the array.public static int[] rampint(int ra, int rb1, int n1)
ra
- value of the first element.rb1
- gradient in 1st dimension.n1
- 1st array dimension.public static int[][] rampint(int ra, int rb1, int rb2, int n1, int n2)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.public static int[][][] rampint(int ra, int rb1, int rb2, int rb3, int n1, int n2, int n3)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void ramp(int ra, int rb1, int[] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rx
- the array.public static void ramp(int ra, int rb1, int rb2, int[][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rx
- the array.public static void ramp(int ra, int rb1, int rb2, int rb3, int[][][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.rx
- the array.public static long[] ramplong(long ra, long rb1, int n1)
ra
- value of the first element.rb1
- gradient in 1st dimension.n1
- 1st array dimension.public static long[][] ramplong(long ra, long rb1, long rb2, int n1, int n2)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.public static long[][][] ramplong(long ra, long rb1, long rb2, long rb3, int n1, int n2, int n3)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void ramp(long ra, long rb1, long[] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rx
- the array.public static void ramp(long ra, long rb1, long rb2, long[][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rx
- the array.public static void ramp(long ra, long rb1, long rb2, long rb3, long[][][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.rx
- the array.public static float[] rampfloat(float ra, float rb1, int n1)
ra
- value of the first element.rb1
- gradient in 1st dimension.n1
- 1st array dimension.public static float[][] rampfloat(float ra, float rb1, float rb2, int n1, int n2)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] rampfloat(float ra, float rb1, float rb2, float rb3, int n1, int n2, int n3)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void ramp(float ra, float rb1, float[] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rx
- the array.public static void ramp(float ra, float rb1, float rb2, float[][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rx
- the array.public static void ramp(float ra, float rb1, float rb2, float rb3, float[][][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.rx
- the array.public static float[] crampfloat(Cfloat ca, Cfloat cb1, int n1)
ca
- value of the first element.cb1
- gradient in 1st dimension.n1
- 1st array dimension.public static float[][] crampfloat(Cfloat ca, Cfloat cb1, Cfloat cb2, int n1, int n2)
ca
- value of the first element.cb1
- gradient in 1st dimension.cb2
- gradient in 2nd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.public static float[][][] crampfloat(Cfloat ca, Cfloat cb1, Cfloat cb2, Cfloat cb3, int n1, int n2, int n3)
ca
- value of the first element.cb1
- gradient in 1st dimension.cb2
- gradient in 2nd dimension.cb3
- gradient in 3rd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void cramp(Cfloat ca, Cfloat cb1, float[] cx)
ca
- value of the first element.cb1
- gradient in 1st dimension.cx
- the array.public static void cramp(Cfloat ca, Cfloat cb1, Cfloat cb2, float[][] cx)
ca
- value of the first element.cb1
- gradient in 1st dimension.cb2
- gradient in 2nd dimension.cx
- the array.public static void cramp(Cfloat ca, Cfloat cb1, Cfloat cb2, Cfloat cb3, float[][][] cx)
ca
- value of the first element.cb1
- gradient in 1st dimension.cb2
- gradient in 2nd dimension.cb3
- gradient in 3rd dimension.cx
- the array.public static double[] rampdouble(double ra, double rb1, int n1)
ra
- value of the first element.rb1
- gradient in 1st dimension.n1
- 1st array dimension.public static double[][] rampdouble(double ra, double rb1, double rb2, int n1, int n2)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] rampdouble(double ra, double rb1, double rb2, double rb3, int n1, int n2, int n3)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void ramp(double ra, double rb1, double[] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rx
- the array.public static void ramp(double ra, double rb1, double rb2, double[][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rx
- the array.public static void ramp(double ra, double rb1, double rb2, double rb3, double[][][] rx)
ra
- value of the first element.rb1
- gradient in 1st dimension.rb2
- gradient in 2nd dimension.rb3
- gradient in 3rd dimension.rx
- the array.public static double[] crampdouble(Cdouble ca, Cdouble cb1, int n1)
ca
- value of the first element.cb1
- gradient in 1st dimension.n1
- 1st array dimension.public static double[][] crampdouble(Cdouble ca, Cdouble cb1, Cdouble cb2, int n1, int n2)
ca
- value of the first element.cb1
- gradient in 1st dimension.cb2
- gradient in 2nd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.public static double[][][] crampdouble(Cdouble ca, Cdouble cb1, Cdouble cb2, Cdouble cb3, int n1, int n2, int n3)
ca
- value of the first element.cb1
- gradient in 1st dimension.cb2
- gradient in 2nd dimension.cb3
- gradient in 3rd dimension.n1
- 1st array dimension.n2
- 2nd array dimension.n3
- 3rd array dimension.public static void cramp(Cdouble ca, Cdouble cb1, double[] cx)
ca
- value of the first element.cb1
- gradient in 1st dimension.cx
- the array.public static void cramp(Cdouble ca, Cdouble cb1, Cdouble cb2, double[][] cx)
ca
- value of the first element.cb1
- gradient in 1st dimension.cb2
- gradient in 2nd dimension.cx
- the array.public static void cramp(Cdouble ca, Cdouble cb1, Cdouble cb2, Cdouble cb3, double[][][] cx)
ca
- value of the first element.cb1
- gradient in 1st dimension.cb2
- gradient in 2nd dimension.cb3
- gradient in 3rd dimension.cx
- the array.public static byte[] copy(byte[] rx)
rx
- source array.public static byte[][] copy(byte[][] rx)
rx
- source array.public static byte[][][] copy(byte[][][] rx)
rx
- source array.public static void copy(byte[] rx, byte[] ry)
rx
- source array.ry
- destination array.public static void copy(byte[][] rx, byte[][] ry)
rx
- source array.ry
- destination array.public static void copy(byte[][][] rx, byte[][][] ry)
rx
- source array.ry
- destination array.public static byte[] copy(int n1, byte[] rx)
n1
- number of elements to copy in 1st dimension.rx
- source array.public static byte[][] copy(int n1, int n2, byte[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.public static byte[][][] copy(int n1, int n2, int n3, byte[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.public static void copy(int n1, byte[] rx, byte[] ry)
n1
- number of elements to copy in 1st dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, byte[][] rx, byte[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, int n3, byte[][][] rx, byte[][][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.ry
- destination array.public static byte[] copy(int n1, int j1, byte[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.rx
- source array.public static byte[][] copy(int n1, int n2, int j1, int j2, byte[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.rx
- source array.public static byte[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, byte[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.rx
- source array.public static byte[] copy(int n1, int j1, int k1, byte[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.k1
- stride in 1st dimension of rx.rx
- source array.public static byte[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, byte[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.rx
- source array.public static byte[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, byte[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.k3
- stride in 3rd dimension of rx.rx
- source array.public static void copy(int n1, int j1x, byte[] rx, int j1y, byte[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.ry
- destination array.public static void copy(int n1, int n2, int j1x, int j2x, byte[][] rx, int j1y, int j2y, byte[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.ry
- destination array.public static void copy(int n1, int j1x, int k1x, byte[] rx, int j1y, int k1y, byte[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.k1x
- stride in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.k1y
- stride in 1st dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.k3x
- stride in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.k3y
- stride in 3rd dimension of ry.ry
- destination array.public static short[] copy(short[] rx)
rx
- source array.public static short[][] copy(short[][] rx)
rx
- source array.public static short[][][] copy(short[][][] rx)
rx
- source array.public static void copy(short[] rx, short[] ry)
rx
- source array.ry
- destination array.public static void copy(short[][] rx, short[][] ry)
rx
- source array.ry
- destination array.public static void copy(short[][][] rx, short[][][] ry)
rx
- source array.ry
- destination array.public static short[] copy(int n1, short[] rx)
n1
- number of elements to copy in 1st dimension.rx
- source array.public static short[][] copy(int n1, int n2, short[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.public static short[][][] copy(int n1, int n2, int n3, short[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.public static void copy(int n1, short[] rx, short[] ry)
n1
- number of elements to copy in 1st dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, short[][] rx, short[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, int n3, short[][][] rx, short[][][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.ry
- destination array.public static short[] copy(int n1, int j1, short[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.rx
- source array.public static short[][] copy(int n1, int n2, int j1, int j2, short[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.rx
- source array.public static short[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, short[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.rx
- source array.public static short[] copy(int n1, int j1, int k1, short[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.k1
- stride in 1st dimension of rx.rx
- source array.public static short[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, short[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.rx
- source array.public static short[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, short[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.k3
- stride in 3rd dimension of rx.rx
- source array.public static void copy(int n1, int j1x, short[] rx, int j1y, short[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.ry
- destination array.public static void copy(int n1, int n2, int j1x, int j2x, short[][] rx, int j1y, int j2y, short[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.ry
- destination array.public static void copy(int n1, int j1x, int k1x, short[] rx, int j1y, int k1y, short[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.k1x
- stride in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.k1y
- stride in 1st dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.k3x
- stride in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.k3y
- stride in 3rd dimension of ry.ry
- destination array.public static int[] copy(int[] rx)
rx
- source array.public static int[][] copy(int[][] rx)
rx
- source array.public static int[][][] copy(int[][][] rx)
rx
- source array.public static void copy(int[] rx, int[] ry)
rx
- source array.ry
- destination array.public static void copy(int[][] rx, int[][] ry)
rx
- source array.ry
- destination array.public static void copy(int[][][] rx, int[][][] ry)
rx
- source array.ry
- destination array.public static int[] copy(int n1, int[] rx)
n1
- number of elements to copy in 1st dimension.rx
- source array.public static int[][] copy(int n1, int n2, int[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.public static int[][][] copy(int n1, int n2, int n3, int[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.public static void copy(int n1, int[] rx, int[] ry)
n1
- number of elements to copy in 1st dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, int[][] rx, int[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, int n3, int[][][] rx, int[][][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.ry
- destination array.public static int[] copy(int n1, int j1, int[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.rx
- source array.public static int[][] copy(int n1, int n2, int j1, int j2, int[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.rx
- source array.public static int[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.rx
- source array.public static int[] copy(int n1, int j1, int k1, int[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.k1
- stride in 1st dimension of rx.rx
- source array.public static int[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, int[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.rx
- source array.public static int[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, int[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.k3
- stride in 3rd dimension of rx.rx
- source array.public static void copy(int n1, int j1x, int[] rx, int j1y, int[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.ry
- destination array.public static void copy(int n1, int n2, int j1x, int j2x, int[][] rx, int j1y, int j2y, int[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.ry
- destination array.public static void copy(int n1, int j1x, int k1x, int[] rx, int j1y, int k1y, int[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.k1x
- stride in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.k1y
- stride in 1st dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.k3x
- stride in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.k3y
- stride in 3rd dimension of ry.ry
- destination array.public static long[] copy(long[] rx)
rx
- source array.public static long[][] copy(long[][] rx)
rx
- source array.public static long[][][] copy(long[][][] rx)
rx
- source array.public static void copy(long[] rx, long[] ry)
rx
- source array.ry
- destination array.public static void copy(long[][] rx, long[][] ry)
rx
- source array.ry
- destination array.public static void copy(long[][][] rx, long[][][] ry)
rx
- source array.ry
- destination array.public static long[] copy(int n1, long[] rx)
n1
- number of elements to copy in 1st dimension.rx
- source array.public static long[][] copy(int n1, int n2, long[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.public static long[][][] copy(int n1, int n2, int n3, long[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.public static void copy(int n1, long[] rx, long[] ry)
n1
- number of elements to copy in 1st dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, long[][] rx, long[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, int n3, long[][][] rx, long[][][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.ry
- destination array.public static long[] copy(int n1, int j1, long[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.rx
- source array.public static long[][] copy(int n1, int n2, int j1, int j2, long[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.rx
- source array.public static long[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, long[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.rx
- source array.public static long[] copy(int n1, int j1, int k1, long[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.k1
- stride in 1st dimension of rx.rx
- source array.public static long[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, long[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.rx
- source array.public static long[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, long[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.k3
- stride in 3rd dimension of rx.rx
- source array.public static void copy(int n1, int j1x, long[] rx, int j1y, long[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.ry
- destination array.public static void copy(int n1, int n2, int j1x, int j2x, long[][] rx, int j1y, int j2y, long[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.ry
- destination array.public static void copy(int n1, int j1x, int k1x, long[] rx, int j1y, int k1y, long[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.k1x
- stride in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.k1y
- stride in 1st dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.k3x
- stride in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.k3y
- stride in 3rd dimension of ry.ry
- destination array.public static float[] copy(float[] rx)
rx
- source array.public static float[][] copy(float[][] rx)
rx
- source array.public static float[][][] copy(float[][][] rx)
rx
- source array.public static void copy(float[] rx, float[] ry)
rx
- source array.ry
- destination array.public static void copy(float[][] rx, float[][] ry)
rx
- source array.ry
- destination array.public static void copy(float[][][] rx, float[][][] ry)
rx
- source array.ry
- destination array.public static float[] copy(int n1, float[] rx)
n1
- number of elements to copy in 1st dimension.rx
- source array.public static float[][] copy(int n1, int n2, float[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.public static float[][][] copy(int n1, int n2, int n3, float[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.public static void copy(int n1, float[] rx, float[] ry)
n1
- number of elements to copy in 1st dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, float[][] rx, float[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, int n3, float[][][] rx, float[][][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.ry
- destination array.public static float[] copy(int n1, int j1, float[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.rx
- source array.public static float[][] copy(int n1, int n2, int j1, int j2, float[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.rx
- source array.public static float[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, float[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.rx
- source array.public static float[] copy(int n1, int j1, int k1, float[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.k1
- stride in 1st dimension of rx.rx
- source array.public static float[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, float[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.rx
- source array.public static float[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, float[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.k3
- stride in 3rd dimension of rx.rx
- source array.public static void copy(int n1, int j1x, float[] rx, int j1y, float[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.ry
- destination array.public static void copy(int n1, int n2, int j1x, int j2x, float[][] rx, int j1y, int j2y, float[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.ry
- destination array.public static void copy(int n1, int j1x, int k1x, float[] rx, int j1y, int k1y, float[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.k1x
- stride in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.k1y
- stride in 1st dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.k3x
- stride in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.k3y
- stride in 3rd dimension of ry.ry
- destination array.public static float[] ccopy(float[] cx)
cx
- source array.public static float[][] ccopy(float[][] cx)
cx
- source array.public static float[][][] ccopy(float[][][] cx)
cx
- source array.public static void ccopy(float[] cx, float[] cy)
cx
- source array.cy
- destination array.public static void ccopy(float[][] cx, float[][] cy)
cx
- source array.cy
- destination array.public static void ccopy(float[][][] cx, float[][][] cy)
cx
- source array.cy
- destination array.public static float[] ccopy(int n1, float[] cx)
n1
- number of elements to copy in 1st dimension.cx
- source array.public static float[][] ccopy(int n1, int n2, float[][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.cx
- source array.public static float[][][] ccopy(int n1, int n2, int n3, float[][][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.cx
- source array.public static void ccopy(int n1, float[] cx, float[] cy)
n1
- number of elements to copy in 1st dimension.cx
- source array.cy
- destination array.public static void ccopy(int n1, int n2, float[][] cx, float[][] cy)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.cx
- source array.cy
- destination array.public static void ccopy(int n1, int n2, int n3, float[][][] cx, float[][][] cy)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.cx
- source array.cy
- destination array.public static float[] ccopy(int n1, int j1, float[] cx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of cx.cx
- source array.public static float[][] ccopy(int n1, int n2, int j1, int j2, float[][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of cx.j2
- offset in 2nd dimension of cx.cx
- source array.public static float[][][] ccopy(int n1, int n2, int n3, int j1, int j2, int j3, float[][][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of cx.j2
- offset in 2nd dimension of cx.j3
- offset in 3rd dimension of cx.cx
- source array.public static float[] ccopy(int n1, int j1, int k1, float[] cx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of cx.k1
- stride in 1st dimension of cx.cx
- source array.public static float[][] ccopy(int n1, int n2, int j1, int j2, int k1, int k2, float[][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of cx.j2
- offset in 2nd dimension of cx.k1
- stride in 1st dimension of cx.k2
- stride in 2nd dimension of cx.cx
- source array.public static float[][][] ccopy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, float[][][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of cx.j2
- offset in 2nd dimension of cx.j3
- offset in 3rd dimension of cx.k1
- stride in 1st dimension of cx.k2
- stride in 2nd dimension of cx.k3
- stride in 3rd dimension of cx.cx
- source array.public static void ccopy(int n1, int j1x, float[] cx, int j1y, float[] cy)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.cy
- destination array.public static void ccopy(int n1, int n2, int j1x, int j2x, float[][] cx, int j1y, int j2y, float[][] cy)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of cx.j2x
- offset in 2nd dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.j2y
- offset in 2nd dimension of cy.cy
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of cx.j2x
- offset in 2nd dimension of cx.j3x
- offset in 3rd dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.j2y
- offset in 2nd dimension of cy.j3y
- offset in 3rd dimension of cy.cy
- destination array.public static void ccopy(int n1, int j1x, int k1x, float[] cx, int j1y, int k1y, float[] cy)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of cx.k1x
- stride in 1st dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.k1y
- stride in 1st dimension of cy.cy
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of cx.j2x
- offset in 2nd dimension of cx.k1x
- stride in 1st dimension of cx.k2x
- stride in 2nd dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.j2y
- offset in 2nd dimension of cy.k1y
- stride in 1st dimension of cy.k2y
- stride in 2nd dimension of cy.cy
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of cx.j2x
- offset in 2nd dimension of cx.j3x
- offset in 3rd dimension of cx.k1x
- stride in 1st dimension of cx.k2x
- stride in 2nd dimension of cx.k3x
- stride in 3rd dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.j2y
- offset in 2nd dimension of cy.j3y
- offset in 3rd dimension of cy.k1y
- stride in 1st dimension of cy.k2y
- stride in 2nd dimension of cy.k3y
- stride in 3rd dimension of cy.cy
- destination array.public static double[] copy(double[] rx)
rx
- source array.public static double[][] copy(double[][] rx)
rx
- source array.public static double[][][] copy(double[][][] rx)
rx
- source array.public static void copy(double[] rx, double[] ry)
rx
- source array.ry
- destination array.public static void copy(double[][] rx, double[][] ry)
rx
- source array.ry
- destination array.public static void copy(double[][][] rx, double[][][] ry)
rx
- source array.ry
- destination array.public static double[] copy(int n1, double[] rx)
n1
- number of elements to copy in 1st dimension.rx
- source array.public static double[][] copy(int n1, int n2, double[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.public static double[][][] copy(int n1, int n2, int n3, double[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.public static void copy(int n1, double[] rx, double[] ry)
n1
- number of elements to copy in 1st dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, double[][] rx, double[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.rx
- source array.ry
- destination array.public static void copy(int n1, int n2, int n3, double[][][] rx, double[][][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.rx
- source array.ry
- destination array.public static double[] copy(int n1, int j1, double[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.rx
- source array.public static double[][] copy(int n1, int n2, int j1, int j2, double[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.rx
- source array.public static double[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, double[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.rx
- source array.public static double[] copy(int n1, int j1, int k1, double[] rx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of rx.k1
- stride in 1st dimension of rx.rx
- source array.public static double[][] copy(int n1, int n2, int j1, int j2, int k1, int k2, double[][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.rx
- source array.public static double[][][] copy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, double[][][] rx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of rx.j2
- offset in 2nd dimension of rx.j3
- offset in 3rd dimension of rx.k1
- stride in 1st dimension of rx.k2
- stride in 2nd dimension of rx.k3
- stride in 3rd dimension of rx.rx
- source array.public static void copy(int n1, int j1x, double[] rx, int j1y, double[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.ry
- destination array.public static void copy(int n1, int n2, int j1x, int j2x, double[][] rx, int j1y, int j2y, double[][] ry)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.ry
- destination array.public static void copy(int n1, int j1x, int k1x, double[] rx, int j1y, int k1y, double[] ry)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of rx.k1x
- stride in 1st dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.k1y
- stride in 1st dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.ry
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of rx.j2x
- offset in 2nd dimension of rx.j3x
- offset in 3rd dimension of rx.k1x
- stride in 1st dimension of rx.k2x
- stride in 2nd dimension of rx.k3x
- stride in 3rd dimension of rx.rx
- source array.j1y
- offset in 1st dimension of ry.j2y
- offset in 2nd dimension of ry.j3y
- offset in 3rd dimension of ry.k1y
- stride in 1st dimension of ry.k2y
- stride in 2nd dimension of ry.k3y
- stride in 3rd dimension of ry.ry
- destination array.public static double[] ccopy(double[] cx)
cx
- source array.public static double[][] ccopy(double[][] cx)
cx
- source array.public static double[][][] ccopy(double[][][] cx)
cx
- source array.public static void ccopy(double[] cx, double[] cy)
cx
- source array.cy
- destination array.public static void ccopy(double[][] cx, double[][] cy)
cx
- source array.cy
- destination array.public static void ccopy(double[][][] cx, double[][][] cy)
cx
- source array.cy
- destination array.public static double[] ccopy(int n1, double[] cx)
n1
- number of elements to copy in 1st dimension.cx
- source array.public static double[][] ccopy(int n1, int n2, double[][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.cx
- source array.public static double[][][] ccopy(int n1, int n2, int n3, double[][][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.cx
- source array.public static void ccopy(int n1, double[] cx, double[] cy)
n1
- number of elements to copy in 1st dimension.cx
- source array.cy
- destination array.public static void ccopy(int n1, int n2, double[][] cx, double[][] cy)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.cx
- source array.cy
- destination array.public static void ccopy(int n1, int n2, int n3, double[][][] cx, double[][][] cy)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.cx
- source array.cy
- destination array.public static double[] ccopy(int n1, int j1, double[] cx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of cx.cx
- source array.public static double[][] ccopy(int n1, int n2, int j1, int j2, double[][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of cx.j2
- offset in 2nd dimension of cx.cx
- source array.public static double[][][] ccopy(int n1, int n2, int n3, int j1, int j2, int j3, double[][][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of cx.j2
- offset in 2nd dimension of cx.j3
- offset in 3rd dimension of cx.cx
- source array.public static double[] ccopy(int n1, int j1, int k1, double[] cx)
n1
- number of elements to copy in 1st dimension.j1
- offset in 1st dimension of cx.k1
- stride in 1st dimension of cx.cx
- source array.public static double[][] ccopy(int n1, int n2, int j1, int j2, int k1, int k2, double[][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1
- offset in 1st dimension of cx.j2
- offset in 2nd dimension of cx.k1
- stride in 1st dimension of cx.k2
- stride in 2nd dimension of cx.cx
- source array.public static double[][][] ccopy(int n1, int n2, int n3, int j1, int j2, int j3, int k1, int k2, int k3, double[][][] cx)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1
- offset in 1st dimension of cx.j2
- offset in 2nd dimension of cx.j3
- offset in 3rd dimension of cx.k1
- stride in 1st dimension of cx.k2
- stride in 2nd dimension of cx.k3
- stride in 3rd dimension of cx.cx
- source array.public static void ccopy(int n1, int j1x, double[] cx, int j1y, double[] cy)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.cy
- destination array.public static void ccopy(int n1, int n2, int j1x, int j2x, double[][] cx, int j1y, int j2y, double[][] cy)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of cx.j2x
- offset in 2nd dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.j2y
- offset in 2nd dimension of cy.cy
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of cx.j2x
- offset in 2nd dimension of cx.j3x
- offset in 3rd dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.j2y
- offset in 2nd dimension of cy.j3y
- offset in 3rd dimension of cy.cy
- destination array.public static void ccopy(int n1, int j1x, int k1x, double[] cx, int j1y, int k1y, double[] cy)
n1
- number of elements to copy in 1st dimension.j1x
- offset in 1st dimension of cx.k1x
- stride in 1st dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.k1y
- stride in 1st dimension of cy.cy
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.j1x
- offset in 1st dimension of cx.j2x
- offset in 2nd dimension of cx.k1x
- stride in 1st dimension of cx.k2x
- stride in 2nd dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.j2y
- offset in 2nd dimension of cy.k1y
- stride in 1st dimension of cy.k2y
- stride in 2nd dimension of cy.cy
- destination array.public 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)
n1
- number of elements to copy in 1st dimension.n2
- number of elements to copy in 2nd dimension.n3
- number of elements to copy in 3rd dimension.j1x
- offset in 1st dimension of cx.j2x
- offset in 2nd dimension of cx.j3x
- offset in 3rd dimension of cx.k1x
- stride in 1st dimension of cx.k2x
- stride in 2nd dimension of cx.k3x
- stride in 3rd dimension of cx.cx
- source array.j1y
- offset in 1st dimension of cy.j2y
- offset in 2nd dimension of cy.j3y
- offset in 3rd dimension of cy.k1y
- stride in 1st dimension of cy.k2y
- stride in 2nd dimension of cy.k3y
- stride in 3rd dimension of cy.cy
- destination array.public static byte[] reverse(byte[] rx)
public static void reverse(byte[] rx, byte[] ry)
public static short[] reverse(short[] rx)
public static void reverse(short[] rx, short[] ry)
public static int[] reverse(int[] rx)
public static void reverse(int[] rx, int[] ry)
public static long[] reverse(long[] rx)
public static void reverse(long[] rx, long[] ry)
public static float[] reverse(float[] rx)
public static void reverse(float[] rx, float[] ry)
public static float[] creverse(float[] rx)
public static void creverse(float[] rx, float[] ry)
public static double[] reverse(double[] rx)
public static void reverse(double[] rx, double[] ry)
public static double[] creverse(double[] rx)
public static void creverse(double[] rx, double[] ry)
public static byte[] flatten(byte[][] rx)
rx
- the array.public static byte[] flatten(byte[][][] rx)
rx
- the array.public static short[] flatten(short[][] rx)
rx
- the array.public static short[] flatten(short[][][] rx)
rx
- the array.public static int[] flatten(int[][] rx)
rx
- the array.public static int[] flatten(int[][][] rx)
rx
- the array.public static long[] flatten(long[][] rx)
rx
- the array.public static long[] flatten(long[][][] rx)
rx
- the array.public static float[] flatten(float[][] rx)
rx
- the array.public static float[] flatten(float[][][] rx)
rx
- the array.public static float[] cflatten(float[][] cx)
cx
- the array.public static float[] cflatten(float[][][] cx)
cx
- the array.public static double[] flatten(double[][] rx)
rx
- the array.public static double[] flatten(double[][][] rx)
rx
- the array.public static double[] cflatten(double[][] cx)
cx
- the array.public static double[] cflatten(double[][][] cx)
cx
- the array.public static byte[][] reshape(int n1, int n2, byte[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.rx
- the array.public static byte[][][] reshape(int n1, int n2, int n3, byte[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.n3
- the 3rd dimension of the reshaped array.rx
- the array.public static short[][] reshape(int n1, int n2, short[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.rx
- the array.public static short[][][] reshape(int n1, int n2, int n3, short[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.n3
- the 3rd dimension of the reshaped array.rx
- the array.public static int[][] reshape(int n1, int n2, int[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.rx
- the array.public static int[][][] reshape(int n1, int n2, int n3, int[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.n3
- the 3rd dimension of the reshaped array.rx
- the array.public static long[][] reshape(int n1, int n2, long[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.rx
- the array.public static long[][][] reshape(int n1, int n2, int n3, long[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.n3
- the 3rd dimension of the reshaped array.rx
- the array.public static float[][] reshape(int n1, int n2, float[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.rx
- the array.public static float[][][] reshape(int n1, int n2, int n3, float[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.n3
- the 3rd dimension of the reshaped array.rx
- the array.public static float[][] creshape(int n1, int n2, float[] cx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.cx
- the array.public static float[][][] creshape(int n1, int n2, int n3, float[] cx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.n3
- the 3rd dimension of the reshaped array.cx
- the array.public static double[][] reshape(int n1, int n2, double[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.rx
- the array.public static double[][][] reshape(int n1, int n2, int n3, double[] rx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.n3
- the 3rd dimension of the reshaped array.rx
- the array.public static double[][] creshape(int n1, int n2, double[] cx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.cx
- the array.public static double[][][] creshape(int n1, int n2, int n3, double[] cx)
n1
- the 1st dimension of the reshaped array.n2
- the 2nd dimension of the reshaped array.n3
- the 3rd dimension of the reshaped array.cx
- the array.public static byte[][] transpose(byte[][] rx)
rx
- the array; must be regular.public static short[][] transpose(short[][] rx)
rx
- the array; must be regular.public static int[][] transpose(int[][] rx)
rx
- the array; must be regular.public static long[][] transpose(long[][] rx)
rx
- the array; must be regular.public static float[][] transpose(float[][] rx)
rx
- the array; must be regular.public static float[][] ctranspose(float[][] cx)
cx
- the array; must be regular.public static double[][] transpose(double[][] rx)
rx
- the array; must be regular.public static double[][] ctranspose(double[][] cx)
cx
- the array; must be regular.public static boolean distinct(byte[] x, byte[] y)
x
- an array.y
- an array.public static boolean distinct(byte[][] x, byte[][] y)
x
- an array.y
- an array.public static boolean distinct(byte[][][] x, byte[][][] y)
x
- an array.y
- an array.public static boolean distinct(short[] x, short[] y)
x
- an array.y
- an array.public static boolean distinct(short[][] x, short[][] y)
x
- an array.y
- an array.public static boolean distinct(short[][][] x, short[][][] y)
x
- an array.y
- an array.public static boolean distinct(int[] x, int[] y)
x
- an array.y
- an array.public static boolean distinct(int[][] x, int[][] y)
x
- an array.y
- an array.public static boolean distinct(int[][][] x, int[][][] y)
x
- an array.y
- an array.public static boolean distinct(long[] x, long[] y)
x
- an array.y
- an array.public static boolean distinct(long[][] x, long[][] y)
x
- an array.y
- an array.public static boolean distinct(long[][][] x, long[][][] y)
x
- an array.y
- an array.public static boolean distinct(float[] x, float[] y)
x
- an array.y
- an array.public static boolean distinct(float[][] x, float[][] y)
x
- an array.y
- an array.public static boolean distinct(float[][][] x, float[][][] y)
x
- an array.y
- an array.public static boolean distinct(double[] x, double[] y)
x
- an array.y
- an array.public static boolean distinct(double[][] x, double[][] y)
x
- an array.y
- an array.public static boolean distinct(double[][][] x, double[][][] y)
x
- an array.y
- an array.public static boolean equal(byte[] rx, byte[] ry)
rx
- an array.ry
- an array.public static boolean equal(byte[][] rx, byte[][] ry)
rx
- an array.ry
- an array.public static boolean equal(byte[][][] rx, byte[][][] ry)
rx
- an array.ry
- an array.public static boolean equal(short[] rx, short[] ry)
rx
- an array.ry
- an array.public static boolean equal(short[][] rx, short[][] ry)
rx
- an array.ry
- an array.public static boolean equal(short[][][] rx, short[][][] ry)
rx
- an array.ry
- an array.public static boolean equal(int[] rx, int[] ry)
rx
- an array.ry
- an array.public static boolean equal(int[][] rx, int[][] ry)
rx
- an array.ry
- an array.public static boolean equal(int[][][] rx, int[][][] ry)
rx
- an array.ry
- an array.public static boolean equal(long[] rx, long[] ry)
rx
- an array.ry
- an array.public static boolean equal(long[][] rx, long[][] ry)
rx
- an array.ry
- an array.public static boolean equal(long[][][] rx, long[][][] ry)
rx
- an array.ry
- an array.public static boolean equal(float[] rx, float[] ry)
rx
- an array.ry
- an array.public static boolean equal(float[][] rx, float[][] ry)
rx
- an array.ry
- an array.public static boolean equal(float[][][] rx, float[][][] ry)
rx
- an array.ry
- an array.public static boolean equal(float tolerance, float[] rx, float[] ry)
tolerance
- the tolerance.rx
- an array.ry
- an array.public static boolean equal(float tolerance, float[][] rx, float[][] ry)
tolerance
- the tolerance.rx
- an array.ry
- an array.public static boolean equal(float tolerance, float[][][] rx, float[][][] ry)
tolerance
- the tolerance.rx
- an array.ry
- an array.public static boolean cequal(float[] cx, float[] cy)
cx
- an array.cy
- an array.public static boolean cequal(float[][] cx, float[][] cy)
cx
- an array.cy
- an array.public static boolean cequal(float[][][] cx, float[][][] cy)
cx
- an array.cy
- an array.public static boolean cequal(float tolerance, float[] cx, float[] cy)
tolerance
- the tolerance.cx
- an array.cy
- an array.public static boolean cequal(float tolerance, float[][] cx, float[][] cy)
tolerance
- the tolerance.cx
- an array.cy
- an array.public static boolean cequal(float tolerance, float[][][] cx, float[][][] cy)
tolerance
- the tolerance.cx
- an array.cy
- an array.public static boolean equal(double[] rx, double[] ry)
rx
- an array.ry
- an array.public static boolean equal(double[][] rx, double[][] ry)
rx
- an array.ry
- an array.public static boolean equal(double[][][] rx, double[][][] ry)
rx
- an array.ry
- an array.public static boolean equal(double tolerance, double[] rx, double[] ry)
tolerance
- the tolerance.rx
- an array.ry
- an array.public static boolean equal(double tolerance, double[][] rx, double[][] ry)
tolerance
- the tolerance.rx
- an array.ry
- an array.public static boolean equal(double tolerance, double[][][] rx, double[][][] ry)
tolerance
- the tolerance.rx
- an array.ry
- an array.public static boolean cequal(double[] cx, double[] cy)
cx
- an array.cy
- an array.public static boolean cequal(double[][] cx, double[][] cy)
cx
- an array.cy
- an array.public static boolean cequal(double[][][] cx, double[][][] cy)
cx
- an array.cy
- an array.public static boolean cequal(double tolerance, double[] cx, double[] cy)
tolerance
- the tolerance.cx
- an array.cy
- an array.public static boolean cequal(double tolerance, double[][] cx, double[][] cy)
tolerance
- the tolerance.cx
- an array.cy
- an array.public static boolean cequal(double tolerance, double[][][] cx, double[][][] cy)
tolerance
- the tolerance.cx
- an array.cy
- an array.public static boolean isRegular(byte[][] a)
a
- the array.public static boolean isRegular(byte[][][] a)
a
- the array.public static boolean isRegular(short[][] a)
a
- the array.public static boolean isRegular(short[][][] a)
a
- the array.public static boolean isRegular(int[][] a)
a
- the array.public static boolean isRegular(int[][][] a)
a
- the array.public static boolean isRegular(float[][] a)
a
- the array.public static boolean isRegular(float[][][] a)
a
- the array.public static boolean isRegular(double[][] a)
a
- the array.public static boolean isRegular(double[][][] a)
a
- the array.public static boolean isIncreasing(byte[] a)
a
- the array.public static boolean isDecreasing(byte[] a)
a
- the array.public static boolean isMonotonic(byte[] a)
a
- the array.public static boolean isIncreasing(short[] a)
a
- the array.public static boolean isDecreasing(short[] a)
a
- the array.public static boolean isMonotonic(short[] a)
a
- the array.public static boolean isIncreasing(int[] a)
a
- the array.public static boolean isDecreasing(int[] a)
a
- the array.public static boolean isMonotonic(int[] a)
a
- the array.public static boolean isIncreasing(long[] a)
a
- the array.public static boolean isDecreasing(long[] a)
a
- the array.public static boolean isMonotonic(long[] a)
a
- the array.public static boolean isIncreasing(float[] a)
a
- the array.public static boolean isDecreasing(float[] a)
a
- the array.public static boolean isMonotonic(float[] a)
a
- the array.public static boolean isIncreasing(double[] a)
a
- the array.public static boolean isDecreasing(double[] a)
a
- the array.public static boolean isMonotonic(double[] a)
a
- the array.public static void quickSort(byte[] a)
a
- the array to be sorted.public static void quickIndexSort(byte[] a, int[] i)
a
- the array.i
- the indices to be sorted.public static void quickPartialSort(int k, byte[] a)
k
- the index.a
- the array to be partially sorted.public static void quickPartialIndexSort(int k, byte[] a, int[] i)
k
- the index.a
- the array.i
- the indices to be partially sorted.public static void quickSort(short[] a)
a
- the array to be sorted.public static void quickIndexSort(short[] a, int[] i)
a
- the array.i
- the indices to be sorted.public static void quickPartialSort(int k, short[] a)
k
- the index.a
- the array to be partially sorted.public static void quickPartialIndexSort(int k, short[] a, int[] i)
k
- the index.a
- the array.i
- the indices to be partially sorted.public static void quickSort(int[] a)
a
- the array to be sorted.public static void quickIndexSort(int[] a, int[] i)
a
- the array.i
- the indices to be sorted.public static void quickPartialSort(int k, int[] a)
k
- the index.a
- the array to be partially sorted.public static void quickPartialIndexSort(int k, int[] a, int[] i)
k
- the index.a
- the array.i
- the indices to be partially sorted.public static void quickSort(long[] a)
a
- the array to be sorted.public static void quickIndexSort(long[] a, int[] i)
a
- the array.i
- the indices to be sorted.public static void quickPartialSort(int k, long[] a)
k
- the index.a
- the array to be partially sorted.public static void quickPartialIndexSort(int k, long[] a, int[] i)
k
- the index.a
- the array.i
- the indices to be partially sorted.public static void quickSort(float[] a)
a
- the array to be sorted.public static void quickIndexSort(float[] a, int[] i)
a
- the array.i
- the indices to be sorted.public static void quickPartialSort(int k, float[] a)
k
- the index.a
- the array to be partially sorted.public static void quickPartialIndexSort(int k, float[] a, int[] i)
k
- the index.a
- the array.i
- the indices to be partially sorted.public static void quickSort(double[] a)
a
- the array to be sorted.public static void quickIndexSort(double[] a, int[] i)
a
- the array.i
- the indices to be sorted.public static void quickPartialSort(int k, double[] a)
k
- the index.a
- the array to be partially sorted.public static void quickPartialIndexSort(int k, double[] a, int[] i)
k
- the index.a
- the array.i
- the indices to be partially sorted.public static int binarySearch(byte[] a, byte x)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.public static int binarySearch(byte[] a, byte x, int i)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.i
- the index at which to begin the search. If negative, this
method interprets this index as if returned from a previous call.public static int binarySearch(short[] a, short x)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.public static int binarySearch(short[] a, short x, int i)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.i
- the index at which to begin the search. If negative, this
method interprets this index as if returned from a previous call.public static int binarySearch(int[] a, int x)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.public static int binarySearch(int[] a, int x, int i)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.i
- the index at which to begin the search. If negative, this
method interprets this index as if returned from a previous call.public static int binarySearch(long[] a, long x)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.public static int binarySearch(long[] a, long x, int i)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.i
- the index at which to begin the search. If negative, this
method interprets this index as if returned from a previous call.public static int binarySearch(float[] a, float x)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.public static int binarySearch(float[] a, float x, int i)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.i
- the index at which to begin the search. If negative, this
method interprets this index as if returned from a previous call.public static int binarySearch(double[] a, double x)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.public static int binarySearch(double[] a, double x, int i)
Warning: this method does not ensure that the specified array is monotonic; that check would be more costly than this search.
a
- the array of values, assumed to be monotonic.x
- the value for which to search.i
- the index at which to begin the search. If negative, this
method interprets this index as if returned from a previous call.public static float[] add(float[] rx, float[] ry)
public static float[] add(float ra, float[] ry)
public static float[] add(float[] rx, float rb)
public static float[][] add(float[][] rx, float[][] ry)
public static float[][] add(float ra, float[][] ry)
public static float[][] add(float[][] rx, float rb)
public static float[][][] add(float[][][] rx, float[][][] ry)
public static float[][][] add(float ra, float[][][] ry)
public static float[][][] add(float[][][] rx, float rb)
public static void add(float[] rx, float[] ry, float[] rz)
public static void add(float ra, float[] ry, float[] rz)
public static void add(float[] rx, float rb, float[] rz)
public static void add(float[][] rx, float[][] ry, float[][] rz)
public static void add(float ra, float[][] ry, float[][] rz)
public static void add(float[][] rx, float rb, float[][] rz)
public static void add(float[][][] rx, float[][][] ry, float[][][] rz)
public static void add(float ra, float[][][] ry, float[][][] rz)
public static void add(float[][][] rx, float rb, float[][][] rz)
public static float[] sub(float[] rx, float[] ry)
public static float[] sub(float ra, float[] ry)
public static float[] sub(float[] rx, float rb)
public static float[][] sub(float[][] rx, float[][] ry)
public static float[][] sub(float ra, float[][] ry)
public static float[][] sub(float[][] rx, float rb)
public static float[][][] sub(float[][][] rx, float[][][] ry)
public static float[][][] sub(float ra, float[][][] ry)
public static float[][][] sub(float[][][] rx, float rb)
public static void sub(float[] rx, float[] ry, float[] rz)
public static void sub(float ra, float[] ry, float[] rz)
public static void sub(float[] rx, float rb, float[] rz)
public static void sub(float[][] rx, float[][] ry, float[][] rz)
public static void sub(float ra, float[][] ry, float[][] rz)
public static void sub(float[][] rx, float rb, float[][] rz)
public static void sub(float[][][] rx, float[][][] ry, float[][][] rz)
public static void sub(float ra, float[][][] ry, float[][][] rz)
public static void sub(float[][][] rx, float rb, float[][][] rz)
public static float[] mul(float[] rx, float[] ry)
public static float[] mul(float ra, float[] ry)
public static float[] mul(float[] rx, float rb)
public static float[][] mul(float[][] rx, float[][] ry)
public static float[][] mul(float ra, float[][] ry)
public static float[][] mul(float[][] rx, float rb)
public static float[][][] mul(float[][][] rx, float[][][] ry)
public static float[][][] mul(float ra, float[][][] ry)
public static float[][][] mul(float[][][] rx, float rb)
public static void mul(float[] rx, float[] ry, float[] rz)
public static void mul(float ra, float[] ry, float[] rz)
public static void mul(float[] rx, float rb, float[] rz)
public static void mul(float[][] rx, float[][] ry, float[][] rz)
public static void mul(float ra, float[][] ry, float[][] rz)
public static void mul(float[][] rx, float rb, float[][] rz)
public static void mul(float[][][] rx, float[][][] ry, float[][][] rz)
public static void mul(float ra, float[][][] ry, float[][][] rz)
public static void mul(float[][][] rx, float rb, float[][][] rz)
public static float[] div(float[] rx, float[] ry)
public static float[] div(float ra, float[] ry)
public static float[] div(float[] rx, float rb)
public static float[][] div(float[][] rx, float[][] ry)
public static float[][] div(float ra, float[][] ry)
public static float[][] div(float[][] rx, float rb)
public static float[][][] div(float[][][] rx, float[][][] ry)
public static float[][][] div(float ra, float[][][] ry)
public static float[][][] div(float[][][] rx, float rb)
public static void div(float[] rx, float[] ry, float[] rz)
public static void div(float ra, float[] ry, float[] rz)
public static void div(float[] rx, float rb, float[] rz)
public static void div(float[][] rx, float[][] ry, float[][] rz)
public static void div(float ra, float[][] ry, float[][] rz)
public static void div(float[][] rx, float rb, float[][] rz)
public static void div(float[][][] rx, float[][][] ry, float[][][] rz)
public static void div(float ra, float[][][] ry, float[][][] rz)
public static void div(float[][][] rx, float rb, float[][][] rz)
public static double[] add(double[] rx, double[] ry)
public static double[] add(double ra, double[] ry)
public static double[] add(double[] rx, double rb)
public static double[][] add(double[][] rx, double[][] ry)
public static double[][] add(double ra, double[][] ry)
public static double[][] add(double[][] rx, double rb)
public static double[][][] add(double[][][] rx, double[][][] ry)
public static double[][][] add(double ra, double[][][] ry)
public static double[][][] add(double[][][] rx, double rb)
public static void add(double[] rx, double[] ry, double[] rz)
public static void add(double ra, double[] ry, double[] rz)
public static void add(double[] rx, double rb, double[] rz)
public static void add(double[][] rx, double[][] ry, double[][] rz)
public static void add(double ra, double[][] ry, double[][] rz)
public static void add(double[][] rx, double rb, double[][] rz)
public static void add(double[][][] rx, double[][][] ry, double[][][] rz)
public static void add(double ra, double[][][] ry, double[][][] rz)
public static void add(double[][][] rx, double rb, double[][][] rz)
public static double[] sub(double[] rx, double[] ry)
public static double[] sub(double ra, double[] ry)
public static double[] sub(double[] rx, double rb)
public static double[][] sub(double[][] rx, double[][] ry)
public static double[][] sub(double ra, double[][] ry)
public static double[][] sub(double[][] rx, double rb)
public static double[][][] sub(double[][][] rx, double[][][] ry)
public static double[][][] sub(double ra, double[][][] ry)
public static double[][][] sub(double[][][] rx, double rb)
public static void sub(double[] rx, double[] ry, double[] rz)
public static void sub(double ra, double[] ry, double[] rz)
public static void sub(double[] rx, double rb, double[] rz)
public static void sub(double[][] rx, double[][] ry, double[][] rz)
public static void sub(double ra, double[][] ry, double[][] rz)
public static void sub(double[][] rx, double rb, double[][] rz)
public static void sub(double[][][] rx, double[][][] ry, double[][][] rz)
public static void sub(double ra, double[][][] ry, double[][][] rz)
public static void sub(double[][][] rx, double rb, double[][][] rz)
public static double[] mul(double[] rx, double[] ry)
public static double[] mul(double ra, double[] ry)
public static double[] mul(double[] rx, double rb)
public static double[][] mul(double[][] rx, double[][] ry)
public static double[][] mul(double ra, double[][] ry)
public static double[][] mul(double[][] rx, double rb)
public static double[][][] mul(double[][][] rx, double[][][] ry)
public static double[][][] mul(double ra, double[][][] ry)
public static double[][][] mul(double[][][] rx, double rb)
public static void mul(double[] rx, double[] ry, double[] rz)
public static void mul(double ra, double[] ry, double[] rz)
public static void mul(double[] rx, double rb, double[] rz)
public static void mul(double[][] rx, double[][] ry, double[][] rz)
public static void mul(double ra, double[][] ry, double[][] rz)
public static void mul(double[][] rx, double rb, double[][] rz)
public static void mul(double[][][] rx, double[][][] ry, double[][][] rz)
public static void mul(double ra, double[][][] ry, double[][][] rz)
public static void mul(double[][][] rx, double rb, double[][][] rz)
public static double[] div(double[] rx, double[] ry)
public static double[] div(double ra, double[] ry)
public static double[] div(double[] rx, double rb)
public static double[][] div(double[][] rx, double[][] ry)
public static double[][] div(double ra, double[][] ry)
public static double[][] div(double[][] rx, double rb)
public static double[][][] div(double[][][] rx, double[][][] ry)
public static double[][][] div(double ra, double[][][] ry)
public static double[][][] div(double[][][] rx, double rb)
public static void div(double[] rx, double[] ry, double[] rz)
public static void div(double ra, double[] ry, double[] rz)
public static void div(double[] rx, double rb, double[] rz)
public static void div(double[][] rx, double[][] ry, double[][] rz)
public static void div(double ra, double[][] ry, double[][] rz)
public static void div(double[][] rx, double rb, double[][] rz)
public static void div(double[][][] rx, double[][][] ry, double[][][] rz)
public static void div(double ra, double[][][] ry, double[][][] rz)
public static void div(double[][][] rx, double rb, double[][][] rz)
public static float[] abs(float[] rx)
public static float[][] abs(float[][] rx)
public static float[][][] abs(float[][][] rx)
public static void abs(float[] rx, float[] ry)
public static void abs(float[][] rx, float[][] ry)
public static void abs(float[][][] rx, float[][][] ry)
public static float[] neg(float[] rx)
public static float[][] neg(float[][] rx)
public static float[][][] neg(float[][][] rx)
public static void neg(float[] rx, float[] ry)
public static void neg(float[][] rx, float[][] ry)
public static void neg(float[][][] rx, float[][][] ry)
public static float[] cos(float[] rx)
public static float[][] cos(float[][] rx)
public static float[][][] cos(float[][][] rx)
public static void cos(float[] rx, float[] ry)
public static void cos(float[][] rx, float[][] ry)
public static void cos(float[][][] rx, float[][][] ry)
public static float[] sin(float[] rx)
public static float[][] sin(float[][] rx)
public static float[][][] sin(float[][][] rx)
public static void sin(float[] rx, float[] ry)
public static void sin(float[][] rx, float[][] ry)
public static void sin(float[][][] rx, float[][][] ry)
public static float[] exp(float[] rx)
public static float[][] exp(float[][] rx)
public static float[][][] exp(float[][][] rx)
public static void exp(float[] rx, float[] ry)
public static void exp(float[][] rx, float[][] ry)
public static void exp(float[][][] rx, float[][][] ry)
public static float[] log(float[] rx)
public static float[][] log(float[][] rx)
public static float[][][] log(float[][][] rx)
public static void log(float[] rx, float[] ry)
public static void log(float[][] rx, float[][] ry)
public static void log(float[][][] rx, float[][][] ry)
public static float[] log10(float[] rx)
public static float[][] log10(float[][] rx)
public static float[][][] log10(float[][][] rx)
public static void log10(float[] rx, float[] ry)
public static void log10(float[][] rx, float[][] ry)
public static void log10(float[][][] rx, float[][][] ry)
public static float[] sqrt(float[] rx)
public static float[][] sqrt(float[][] rx)
public static float[][][] sqrt(float[][][] rx)
public static void sqrt(float[] rx, float[] ry)
public static void sqrt(float[][] rx, float[][] ry)
public static void sqrt(float[][][] rx, float[][][] ry)
public static float[] sgn(float[] rx)
public static float[][] sgn(float[][] rx)
public static float[][][] sgn(float[][][] rx)
public static void sgn(float[] rx, float[] ry)
public static void sgn(float[][] rx, float[][] ry)
public static void sgn(float[][][] rx, float[][][] ry)
public static double[] abs(double[] rx)
public static double[][] abs(double[][] rx)
public static double[][][] abs(double[][][] rx)
public static void abs(double[] rx, double[] ry)
public static void abs(double[][] rx, double[][] ry)
public static void abs(double[][][] rx, double[][][] ry)
public static double[] neg(double[] rx)
public static double[][] neg(double[][] rx)
public static double[][][] neg(double[][][] rx)
public static void neg(double[] rx, double[] ry)
public static void neg(double[][] rx, double[][] ry)
public static void neg(double[][][] rx, double[][][] ry)
public static double[] cos(double[] rx)
public static double[][] cos(double[][] rx)
public static double[][][] cos(double[][][] rx)
public static void cos(double[] rx, double[] ry)
public static void cos(double[][] rx, double[][] ry)
public static void cos(double[][][] rx, double[][][] ry)
public static double[] sin(double[] rx)
public static double[][] sin(double[][] rx)
public static double[][][] sin(double[][][] rx)
public static void sin(double[] rx, double[] ry)
public static void sin(double[][] rx, double[][] ry)
public static void sin(double[][][] rx, double[][][] ry)
public static double[] exp(double[] rx)
public static double[][] exp(double[][] rx)
public static double[][][] exp(double[][][] rx)
public static void exp(double[] rx, double[] ry)
public static void exp(double[][] rx, double[][] ry)
public static void exp(double[][][] rx, double[][][] ry)
public static double[] log(double[] rx)
public static double[][] log(double[][] rx)
public static double[][][] log(double[][][] rx)
public static void log(double[] rx, double[] ry)
public static void log(double[][] rx, double[][] ry)
public static void log(double[][][] rx, double[][][] ry)
public static double[] log10(double[] rx)
public static double[][] log10(double[][] rx)
public static double[][][] log10(double[][][] rx)
public static void log10(double[] rx, double[] ry)
public static void log10(double[][] rx, double[][] ry)
public static void log10(double[][][] rx, double[][][] ry)
public static double[] sqrt(double[] rx)
public static double[][] sqrt(double[][] rx)
public static double[][][] sqrt(double[][][] rx)
public static void sqrt(double[] rx, double[] ry)
public static void sqrt(double[][] rx, double[][] ry)
public static void sqrt(double[][][] rx, double[][][] ry)
public static double[] sgn(double[] rx)
public static double[][] sgn(double[][] rx)
public static double[][][] sgn(double[][][] rx)
public static void sgn(double[] rx, double[] ry)
public static void sgn(double[][] rx, double[][] ry)
public static void sgn(double[][][] rx, double[][][] ry)
public static float[] clip(float rxmin, float rxmax, float[] rx)
public static float[][] clip(float rxmin, float rxmax, float[][] rx)
public static float[][][] clip(float rxmin, float rxmax, float[][][] rx)
public static void clip(float rxmin, float rxmax, float[] rx, float[] ry)
public static void clip(float rxmin, float rxmax, float[][] rx, float[][] ry)
public static void clip(float rxmin, float rxmax, float[][][] rx, float[][][] ry)
public static double[] clip(double rxmin, double rxmax, double[] rx)
public static double[][] clip(double rxmin, double rxmax, double[][] rx)
public static double[][][] clip(double rxmin, double rxmax, double[][][] rx)
public static void clip(double rxmin, double rxmax, double[] rx, double[] ry)
public static void clip(double rxmin, double rxmax, double[][] rx, double[][] ry)
public static void clip(double rxmin, double rxmax, double[][][] rx, double[][][] ry)
public static float[] pow(float[] rx, float ra)
public static float[][] pow(float[][] rx, float ra)
public static float[][][] pow(float[][][] rx, float ra)
public static void pow(float[] rx, float ra, float[] ry)
public static void pow(float[][] rx, float ra, float[][] ry)
public static void pow(float[][][] rx, float ra, float[][][] ry)
public static double[] pow(double[] rx, double ra)
public static double[][] pow(double[][] rx, double ra)
public static double[][][] pow(double[][][] rx, double ra)
public static void pow(double[] rx, double ra, double[] ry)
public static void pow(double[][] rx, double ra, double[][] ry)
public static void pow(double[][][] rx, double ra, double[][][] ry)
public static byte sum(byte[] rx)
public static byte sum(byte[][] rx)
public static byte sum(byte[][][] rx)
public static short sum(short[] rx)
public static short sum(short[][] rx)
public static short sum(short[][][] rx)
public static int sum(int[] rx)
public static int sum(int[][] rx)
public static int sum(int[][][] rx)
public static long sum(long[] rx)
public static long sum(long[][] rx)
public static long sum(long[][][] rx)
public static float sum(float[] rx)
public static float sum(float[][] rx)
public static float sum(float[][][] rx)
public static double sum(double[] rx)
public static double sum(double[][] rx)
public static double sum(double[][][] rx)
public static byte max(byte[] rx)
public static byte max(byte[][] rx)
public static byte max(byte[][][] rx)
public static byte max(byte[] rx, int[] index)
public static byte max(byte[][] rx, int[] index)
public static byte max(byte[][][] rx, int[] index)
public static byte min(byte[] rx)
public static byte min(byte[][] rx)
public static byte min(byte[][][] rx)
public static byte min(byte[] rx, int[] index)
public static byte min(byte[][] rx, int[] index)
public static byte min(byte[][][] rx, int[] index)
public static short max(short[] rx)
public static short max(short[][] rx)
public static short max(short[][][] rx)
public static short max(short[] rx, int[] index)
public static short max(short[][] rx, int[] index)
public static short max(short[][][] rx, int[] index)
public static short min(short[] rx)
public static short min(short[][] rx)
public static short min(short[][][] rx)
public static short min(short[] rx, int[] index)
public static short min(short[][] rx, int[] index)
public static short min(short[][][] rx, int[] index)
public static int max(int[] rx)
public static int max(int[][] rx)
public static int max(int[][][] rx)
public static int max(int[] rx, int[] index)
public static int max(int[][] rx, int[] index)
public static int max(int[][][] rx, int[] index)
public static int min(int[] rx)
public static int min(int[][] rx)
public static int min(int[][][] rx)
public static int min(int[] rx, int[] index)
public static int min(int[][] rx, int[] index)
public static int min(int[][][] rx, int[] index)
public static long max(long[] rx)
public static long max(long[][] rx)
public static long max(long[][][] rx)
public static long max(long[] rx, int[] index)
public static long max(long[][] rx, int[] index)
public static long max(long[][][] rx, int[] index)
public static long min(long[] rx)
public static long min(long[][] rx)
public static long min(long[][][] rx)
public static long min(long[] rx, int[] index)
public static long min(long[][] rx, int[] index)
public static long min(long[][][] rx, int[] index)
public static float max(float[] rx)
public static float max(float[][] rx)
public static float max(float[][][] rx)
public static float max(float[] rx, int[] index)
public static float max(float[][] rx, int[] index)
public static float max(float[][][] rx, int[] index)
public static float min(float[] rx)
public static float min(float[][] rx)
public static float min(float[][][] rx)
public static float min(float[] rx, int[] index)
public static float min(float[][] rx, int[] index)
public static float min(float[][][] rx, int[] index)
public static double max(double[] rx)
public static double max(double[][] rx)
public static double max(double[][][] rx)
public static double max(double[] rx, int[] index)
public static double max(double[][] rx, int[] index)
public static double max(double[][][] rx, int[] index)
public static double min(double[] rx)
public static double min(double[][] rx)
public static double min(double[][][] rx)
public static double min(double[] rx, int[] index)
public static double min(double[][] rx, int[] index)
public static double min(double[][][] rx, int[] index)
public static float[] cadd(float[] cx, float[] cy)
public static float[] cadd(Cfloat ca, float[] cy)
public static float[] cadd(float[] cx, Cfloat cb)
public static float[][] cadd(float[][] cx, float[][] cy)
public static float[][] cadd(Cfloat ca, float[][] cy)
public static float[][] cadd(float[][] cx, Cfloat cb)
public static float[][][] cadd(float[][][] cx, float[][][] cy)
public static float[][][] cadd(Cfloat ca, float[][][] cy)
public static float[][][] cadd(float[][][] cx, Cfloat cb)
public static void cadd(float[] cx, float[] cy, float[] cz)
public static void cadd(Cfloat ca, float[] cy, float[] cz)
public static void cadd(float[] cx, Cfloat cb, float[] cz)
public static void cadd(float[][] cx, float[][] cy, float[][] cz)
public static void cadd(Cfloat ca, float[][] cy, float[][] cz)
public static void cadd(float[][] cx, Cfloat cb, float[][] cz)
public static void cadd(float[][][] cx, float[][][] cy, float[][][] cz)
public static void cadd(Cfloat ca, float[][][] cy, float[][][] cz)
public static void cadd(float[][][] cx, Cfloat cb, float[][][] cz)
public static float[] csub(float[] cx, float[] cy)
public static float[] csub(Cfloat ca, float[] cy)
public static float[] csub(float[] cx, Cfloat cb)
public static float[][] csub(float[][] cx, float[][] cy)
public static float[][] csub(Cfloat ca, float[][] cy)
public static float[][] csub(float[][] cx, Cfloat cb)
public static float[][][] csub(float[][][] cx, float[][][] cy)
public static float[][][] csub(Cfloat ca, float[][][] cy)
public static float[][][] csub(float[][][] cx, Cfloat cb)
public static void csub(float[] cx, float[] cy, float[] cz)
public static void csub(Cfloat ca, float[] cy, float[] cz)
public static void csub(float[] cx, Cfloat cb, float[] cz)
public static void csub(float[][] cx, float[][] cy, float[][] cz)
public static void csub(Cfloat ca, float[][] cy, float[][] cz)
public static void csub(float[][] cx, Cfloat cb, float[][] cz)
public static void csub(float[][][] cx, float[][][] cy, float[][][] cz)
public static void csub(Cfloat ca, float[][][] cy, float[][][] cz)
public static void csub(float[][][] cx, Cfloat cb, float[][][] cz)
public static float[] cmul(float[] cx, float[] cy)
public static float[] cmul(Cfloat ca, float[] cy)
public static float[] cmul(float[] cx, Cfloat cb)
public static float[][] cmul(float[][] cx, float[][] cy)
public static float[][] cmul(Cfloat ca, float[][] cy)
public static float[][] cmul(float[][] cx, Cfloat cb)
public static float[][][] cmul(float[][][] cx, float[][][] cy)
public static float[][][] cmul(Cfloat ca, float[][][] cy)
public static float[][][] cmul(float[][][] cx, Cfloat cb)
public static void cmul(float[] cx, float[] cy, float[] cz)
public static void cmul(Cfloat ca, float[] cy, float[] cz)
public static void cmul(float[] cx, Cfloat cb, float[] cz)
public static void cmul(float[][] cx, float[][] cy, float[][] cz)
public static void cmul(Cfloat ca, float[][] cy, float[][] cz)
public static void cmul(float[][] cx, Cfloat cb, float[][] cz)
public static void cmul(float[][][] cx, float[][][] cy, float[][][] cz)
public static void cmul(Cfloat ca, float[][][] cy, float[][][] cz)
public static void cmul(float[][][] cx, Cfloat cb, float[][][] cz)
public static float[] cdiv(float[] cx, float[] cy)
public static float[] cdiv(Cfloat ca, float[] cy)
public static float[] cdiv(float[] cx, Cfloat cb)
public static float[][] cdiv(float[][] cx, float[][] cy)
public static float[][] cdiv(Cfloat ca, float[][] cy)
public static float[][] cdiv(float[][] cx, Cfloat cb)
public static float[][][] cdiv(float[][][] cx, float[][][] cy)
public static float[][][] cdiv(Cfloat ca, float[][][] cy)
public static float[][][] cdiv(float[][][] cx, Cfloat cb)
public static void cdiv(float[] cx, float[] cy, float[] cz)
public static void cdiv(Cfloat ca, float[] cy, float[] cz)
public static void cdiv(float[] cx, Cfloat cb, float[] cz)
public static void cdiv(float[][] cx, float[][] cy, float[][] cz)
public static void cdiv(Cfloat ca, float[][] cy, float[][] cz)
public static void cdiv(float[][] cx, Cfloat cb, float[][] cz)
public static void cdiv(float[][][] cx, float[][][] cy, float[][][] cz)
public static void cdiv(Cfloat ca, float[][][] cy, float[][][] cz)
public static void cdiv(float[][][] cx, Cfloat cb, float[][][] cz)
public static double[] cadd(double[] cx, double[] cy)
public static double[] cadd(Cdouble ca, double[] cy)
public static double[] cadd(double[] cx, Cdouble cb)
public static double[][] cadd(double[][] cx, double[][] cy)
public static double[][] cadd(Cdouble ca, double[][] cy)
public static double[][] cadd(double[][] cx, Cdouble cb)
public static double[][][] cadd(double[][][] cx, double[][][] cy)
public static double[][][] cadd(Cdouble ca, double[][][] cy)
public static double[][][] cadd(double[][][] cx, Cdouble cb)
public static void cadd(double[] cx, double[] cy, double[] cz)
public static void cadd(Cdouble ca, double[] cy, double[] cz)
public static void cadd(double[] cx, Cdouble cb, double[] cz)
public static void cadd(double[][] cx, double[][] cy, double[][] cz)
public static void cadd(Cdouble ca, double[][] cy, double[][] cz)
public static void cadd(double[][] cx, Cdouble cb, double[][] cz)
public static void cadd(double[][][] cx, double[][][] cy, double[][][] cz)
public static void cadd(Cdouble ca, double[][][] cy, double[][][] cz)
public static void cadd(double[][][] cx, Cdouble cb, double[][][] cz)
public static double[] csub(double[] cx, double[] cy)
public static double[] csub(Cdouble ca, double[] cy)
public static double[] csub(double[] cx, Cdouble cb)
public static double[][] csub(double[][] cx, double[][] cy)
public static double[][] csub(Cdouble ca, double[][] cy)
public static double[][] csub(double[][] cx, Cdouble cb)
public static double[][][] csub(double[][][] cx, double[][][] cy)
public static double[][][] csub(Cdouble ca, double[][][] cy)
public static double[][][] csub(double[][][] cx, Cdouble cb)
public static void csub(double[] cx, double[] cy, double[] cz)
public static void csub(Cdouble ca, double[] cy, double[] cz)
public static void csub(double[] cx, Cdouble cb, double[] cz)
public static void csub(double[][] cx, double[][] cy, double[][] cz)
public static void csub(Cdouble ca, double[][] cy, double[][] cz)
public static void csub(double[][] cx, Cdouble cb, double[][] cz)
public static void csub(double[][][] cx, double[][][] cy, double[][][] cz)
public static void csub(Cdouble ca, double[][][] cy, double[][][] cz)
public static void csub(double[][][] cx, Cdouble cb, double[][][] cz)
public static double[] cmul(double[] cx, double[] cy)
public static double[] cmul(Cdouble ca, double[] cy)
public static double[] cmul(double[] cx, Cdouble cb)
public static double[][] cmul(double[][] cx, double[][] cy)
public static double[][] cmul(Cdouble ca, double[][] cy)
public static double[][] cmul(double[][] cx, Cdouble cb)
public static double[][][] cmul(double[][][] cx, double[][][] cy)
public static double[][][] cmul(Cdouble ca, double[][][] cy)
public static double[][][] cmul(double[][][] cx, Cdouble cb)
public static void cmul(double[] cx, double[] cy, double[] cz)
public static void cmul(Cdouble ca, double[] cy, double[] cz)
public static void cmul(double[] cx, Cdouble cb, double[] cz)
public static void cmul(double[][] cx, double[][] cy, double[][] cz)
public static void cmul(Cdouble ca, double[][] cy, double[][] cz)
public static void cmul(double[][] cx, Cdouble cb, double[][] cz)
public static void cmul(double[][][] cx, double[][][] cy, double[][][] cz)
public static void cmul(Cdouble ca, double[][][] cy, double[][][] cz)
public static void cmul(double[][][] cx, Cdouble cb, double[][][] cz)
public static double[] cdiv(double[] cx, double[] cy)
public static double[] cdiv(Cdouble ca, double[] cy)
public static double[] cdiv(double[] cx, Cdouble cb)
public static double[][] cdiv(double[][] cx, double[][] cy)
public static double[][] cdiv(Cdouble ca, double[][] cy)
public static double[][] cdiv(double[][] cx, Cdouble cb)
public static double[][][] cdiv(double[][][] cx, double[][][] cy)
public static double[][][] cdiv(Cdouble ca, double[][][] cy)
public static double[][][] cdiv(double[][][] cx, Cdouble cb)
public static void cdiv(double[] cx, double[] cy, double[] cz)
public static void cdiv(Cdouble ca, double[] cy, double[] cz)
public static void cdiv(double[] cx, Cdouble cb, double[] cz)
public static void cdiv(double[][] cx, double[][] cy, double[][] cz)
public static void cdiv(Cdouble ca, double[][] cy, double[][] cz)
public static void cdiv(double[][] cx, Cdouble cb, double[][] cz)
public static void cdiv(double[][][] cx, double[][][] cy, double[][][] cz)
public static void cdiv(Cdouble ca, double[][][] cy, double[][][] cz)
public static void cdiv(double[][][] cx, Cdouble cb, double[][][] cz)
public static float[] cneg(float[] cx)
public static float[][] cneg(float[][] cx)
public static float[][][] cneg(float[][][] cx)
public static void cneg(float[] cx, float[] cy)
public static void cneg(float[][] cx, float[][] cy)
public static void cneg(float[][][] cx, float[][][] cy)
public static float[] cconj(float[] cx)
public static float[][] cconj(float[][] cx)
public static float[][][] cconj(float[][][] cx)
public static void cconj(float[] cx, float[] cy)
public static void cconj(float[][] cx, float[][] cy)
public static void cconj(float[][][] cx, float[][][] cy)
public static float[] ccos(float[] cx)
public static float[][] ccos(float[][] cx)
public static float[][][] ccos(float[][][] cx)
public static void ccos(float[] cx, float[] cy)
public static void ccos(float[][] cx, float[][] cy)
public static void ccos(float[][][] cx, float[][][] cy)
public static float[] csin(float[] cx)
public static float[][] csin(float[][] cx)
public static float[][][] csin(float[][][] cx)
public static void csin(float[] cx, float[] cy)
public static void csin(float[][] cx, float[][] cy)
public static void csin(float[][][] cx, float[][][] cy)
public static float[] csqrt(float[] cx)
public static float[][] csqrt(float[][] cx)
public static float[][][] csqrt(float[][][] cx)
public static void csqrt(float[] cx, float[] cy)
public static void csqrt(float[][] cx, float[][] cy)
public static void csqrt(float[][][] cx, float[][][] cy)
public static float[] cexp(float[] cx)
public static float[][] cexp(float[][] cx)
public static float[][][] cexp(float[][][] cx)
public static void cexp(float[] cx, float[] cy)
public static void cexp(float[][] cx, float[][] cy)
public static void cexp(float[][][] cx, float[][][] cy)
public static float[] clog(float[] cx)
public static float[][] clog(float[][] cx)
public static float[][][] clog(float[][][] cx)
public static void clog(float[] cx, float[] cy)
public static void clog(float[][] cx, float[][] cy)
public static void clog(float[][][] cx, float[][][] cy)
public static float[] clog10(float[] cx)
public static float[][] clog10(float[][] cx)
public static float[][][] clog10(float[][][] cx)
public static void clog10(float[] cx, float[] cy)
public static void clog10(float[][] cx, float[][] cy)
public static void clog10(float[][][] cx, float[][][] cy)
public static double[] cneg(double[] cx)
public static double[][] cneg(double[][] cx)
public static double[][][] cneg(double[][][] cx)
public static void cneg(double[] cx, double[] cy)
public static void cneg(double[][] cx, double[][] cy)
public static void cneg(double[][][] cx, double[][][] cy)
public static double[] cconj(double[] cx)
public static double[][] cconj(double[][] cx)
public static double[][][] cconj(double[][][] cx)
public static void cconj(double[] cx, double[] cy)
public static void cconj(double[][] cx, double[][] cy)
public static void cconj(double[][][] cx, double[][][] cy)
public static double[] ccos(double[] cx)
public static double[][] ccos(double[][] cx)
public static double[][][] ccos(double[][][] cx)
public static void ccos(double[] cx, double[] cy)
public static void ccos(double[][] cx, double[][] cy)
public static void ccos(double[][][] cx, double[][][] cy)
public static double[] csin(double[] cx)
public static double[][] csin(double[][] cx)
public static double[][][] csin(double[][][] cx)
public static void csin(double[] cx, double[] cy)
public static void csin(double[][] cx, double[][] cy)
public static void csin(double[][][] cx, double[][][] cy)
public static double[] csqrt(double[] cx)
public static double[][] csqrt(double[][] cx)
public static double[][][] csqrt(double[][][] cx)
public static void csqrt(double[] cx, double[] cy)
public static void csqrt(double[][] cx, double[][] cy)
public static void csqrt(double[][][] cx, double[][][] cy)
public static double[] cexp(double[] cx)
public static double[][] cexp(double[][] cx)
public static double[][][] cexp(double[][][] cx)
public static void cexp(double[] cx, double[] cy)
public static void cexp(double[][] cx, double[][] cy)
public static void cexp(double[][][] cx, double[][][] cy)
public static double[] clog(double[] cx)
public static double[][] clog(double[][] cx)
public static double[][][] clog(double[][][] cx)
public static void clog(double[] cx, double[] cy)
public static void clog(double[][] cx, double[][] cy)
public static void clog(double[][][] cx, double[][][] cy)
public static double[] clog10(double[] cx)
public static double[][] clog10(double[][] cx)
public static double[][][] clog10(double[][][] cx)
public static void clog10(double[] cx, double[] cy)
public static void clog10(double[][] cx, double[][] cy)
public static void clog10(double[][][] cx, double[][][] cy)
public static float[] cpow(float[] cx, float ra)
public static float[][] cpow(float[][] cx, float ra)
public static float[][][] cpow(float[][][] cx, float ra)
public static void cpow(float[] cx, float ra, float[] cy)
public static void cpow(float[][] cx, float ra, float[][] cy)
public static void cpow(float[][][] cx, float ra, float[][][] cy)
public static float[] cpow(float[] cx, Cfloat ca)
public static float[][] cpow(float[][] cx, Cfloat ca)
public static float[][][] cpow(float[][][] cx, Cfloat ca)
public static void cpow(float[] cx, Cfloat ca, float[] cy)
public static void cpow(float[][] cx, Cfloat ca, float[][] cy)
public static void cpow(float[][][] cx, Cfloat ca, float[][][] cy)
public static double[] cpow(double[] cx, double ra)
public static double[][] cpow(double[][] cx, double ra)
public static double[][][] cpow(double[][][] cx, double ra)
public static void cpow(double[] cx, double ra, double[] cy)
public static void cpow(double[][] cx, double ra, double[][] cy)
public static void cpow(double[][][] cx, double ra, double[][][] cy)
public static double[] cpow(double[] cx, Cdouble ca)
public static double[][] cpow(double[][] cx, Cdouble ca)
public static double[][][] cpow(double[][][] cx, Cdouble ca)
public static void cpow(double[] cx, Cdouble ca, double[] cy)
public static void cpow(double[][] cx, Cdouble ca, double[][] cy)
public static void cpow(double[][][] cx, Cdouble ca, double[][][] cy)
public static float[] creal(float[] cx)
public static float[][] creal(float[][] cx)
public static float[][][] creal(float[][][] cx)
public static void creal(float[] cx, float[] cy)
public static void creal(float[][] cx, float[][] cy)
public static void creal(float[][][] cx, float[][][] cy)
public static float[] cimag(float[] cx)
public static float[][] cimag(float[][] cx)
public static float[][][] cimag(float[][][] cx)
public static void cimag(float[] cx, float[] cy)
public static void cimag(float[][] cx, float[][] cy)
public static void cimag(float[][][] cx, float[][][] cy)
public static float[] cabs(float[] cx)
public static float[][] cabs(float[][] cx)
public static float[][][] cabs(float[][][] cx)
public static void cabs(float[] cx, float[] cy)
public static void cabs(float[][] cx, float[][] cy)
public static void cabs(float[][][] cx, float[][][] cy)
public static float[] carg(float[] cx)
public static float[][] carg(float[][] cx)
public static float[][][] carg(float[][][] cx)
public static void carg(float[] cx, float[] cy)
public static void carg(float[][] cx, float[][] cy)
public static void carg(float[][][] cx, float[][][] cy)
public static float[] cnorm(float[] cx)
public static float[][] cnorm(float[][] cx)
public static float[][][] cnorm(float[][][] cx)
public static void cnorm(float[] cx, float[] cy)
public static void cnorm(float[][] cx, float[][] cy)
public static void cnorm(float[][][] cx, float[][][] cy)
public static double[] creal(double[] cx)
public static double[][] creal(double[][] cx)
public static double[][][] creal(double[][][] cx)
public static void creal(double[] cx, double[] cy)
public static void creal(double[][] cx, double[][] cy)
public static void creal(double[][][] cx, double[][][] cy)
public static double[] cimag(double[] cx)
public static double[][] cimag(double[][] cx)
public static double[][][] cimag(double[][][] cx)
public static void cimag(double[] cx, double[] cy)
public static void cimag(double[][] cx, double[][] cy)
public static void cimag(double[][][] cx, double[][][] cy)
public static double[] cabs(double[] cx)
public static double[][] cabs(double[][] cx)
public static double[][][] cabs(double[][][] cx)
public static void cabs(double[] cx, double[] cy)
public static void cabs(double[][] cx, double[][] cy)
public static void cabs(double[][][] cx, double[][][] cy)
public static double[] carg(double[] cx)
public static double[][] carg(double[][] cx)
public static double[][][] carg(double[][][] cx)
public static void carg(double[] cx, double[] cy)
public static void carg(double[][] cx, double[][] cy)
public static void carg(double[][][] cx, double[][][] cy)
public static double[] cnorm(double[] cx)
public static double[][] cnorm(double[][] cx)
public static double[][][] cnorm(double[][][] cx)
public static void cnorm(double[] cx, double[] cy)
public static void cnorm(double[][] cx, double[][] cy)
public static void cnorm(double[][][] cx, double[][][] cy)
public static float[] cmplx(float[] rx, float[] ry)
public static float[][] cmplx(float[][] rx, float[][] ry)
public static float[][][] cmplx(float[][][] rx, float[][][] ry)
public static void cmplx(float[] rx, float[] ry, float[] cz)
public static void cmplx(float[][] rx, float[][] ry, float[][] cz)
public static void cmplx(float[][][] rx, float[][][] ry, float[][][] cz)
public static float[] polar(float[] rx, float[] ry)
public static float[][] polar(float[][] rx, float[][] ry)
public static float[][][] polar(float[][][] rx, float[][][] ry)
public static void polar(float[] rx, float[] ry, float[] cz)
public static void polar(float[][] rx, float[][] ry, float[][] cz)
public static void polar(float[][][] rx, float[][][] ry, float[][][] cz)
public static double[] cmplx(double[] rx, double[] ry)
public static double[][] cmplx(double[][] rx, double[][] ry)
public static double[][][] cmplx(double[][][] rx, double[][][] ry)
public static void cmplx(double[] rx, double[] ry, double[] cz)
public static void cmplx(double[][] rx, double[][] ry, double[][] cz)
public static void cmplx(double[][][] rx, double[][][] ry, double[][][] cz)
public static double[] polar(double[] rx, double[] ry)
public static double[][] polar(double[][] rx, double[][] ry)
public static double[][][] polar(double[][][] rx, double[][][] ry)
public static void polar(double[] rx, double[] ry, double[] cz)
public static void polar(double[][] rx, double[][] ry, double[][] cz)
public static void polar(double[][][] rx, double[][][] ry, double[][][] cz)
public static Cfloat csum(float[] cx)
public static Cfloat csum(float[][] cx)
public static Cfloat csum(float[][][] cx)
public static Cdouble csum(double[] cx)
public static Cdouble csum(double[][] cx)
public static Cdouble csum(double[][][] cx)
public static float[] tofloat(byte[] rx)
public static float[][] tofloat(byte[][] rx)
public static float[][][] tofloat(byte[][][] rx)
public static void dump(byte[] rx)
public static void dump(byte[][] rx)
public static void dump(byte[][][] rx)
public static void dump(short[] rx)
public static void dump(short[][] rx)
public static void dump(short[][][] rx)
public static void dump(int[] rx)
public static void dump(int[][] rx)
public static void dump(int[][][] rx)
public static void dump(long[] rx)
public static void dump(long[][] rx)
public static void dump(long[][][] rx)
public static void dump(float[] rx)
public static void dump(float[][] rx)
public static void dump(float[][][] rx)
public static void cdump(float[] cx)
public static void cdump(float[][] cx)
public static void cdump(float[][][] cx)
public static void dump(double[] rx)
public static void dump(double[][] rx)
public static void dump(double[][][] rx)
public static void cdump(double[] cx)
public static void cdump(double[][] cx)
public static void cdump(double[][][] cx)