Package smile.math

# Class MathEx

java.lang.Object
smile.math.MathEx

public class MathEx extends Object
Extra basic numeric functions. The following functions are included:
• scalar functions: sqr, factorial, lfactorial, choose, lchoose, log2 are provided.
• vector functions: min, max, mean, sum, var, sd, cov, L1 norm, L2 norm, L norm, normalize, unitize, cor, Spearman correlation, Kendall correlation, distance, dot product, histogram, vector (element-wise) copy, equal, plus, minus, times, and divide.
• matrix functions: min, max, rowSums, colSums, rowMeans, colMeans, transpose, cov, cor, matrix copy, equals.
• random functions: random, randomInt, and permutate.
• Find the root of a univariate function with or without derivative.
• ## Field Summary

Fields
Modifier and Type
Field
Description
`static final int`
`DIGITS`
The number of digits (in radix base) in the mantissa.
`static final double`
`EPSILON`
The machine precision for the double type, which is the difference between 1 and the smallest value greater than 1 that is representable for the double type.
`static final int`
`FLOAT_DIGITS`
The number of digits (in radix base) in the mantissa.
`static final float`
`FLOAT_EPSILON`
The machine precision for the float type, which is the difference between 1 and the smallest value greater than 1 that is representable for the float type.
`static final int`
`FLOAT_MACHEP`
The largest negative integer such that 1.0 + RADIXMACHEP ≠ 1.0, except that machep is bounded below by -(DIGITS+3)
`static final int`
`FLOAT_NEGEP`
The largest negative integer such that 1.0 - RADIXNEGEP ≠ 1.0, except that negeps is bounded below by -(DIGITS+3)
`static final int`
`MACHEP`
The largest negative integer such that 1.0 + RADIXMACHEP ≠ 1.0, except that machep is bounded below by -(DIGITS+3)
`static final int`
`NEGEP`
The largest negative integer such that 1.0 - RADIXNEGEP ≠ 1.0, except that negeps is bounded below by -(DIGITS+3)
`static final int`
`RADIX`
The base of the exponent of the double type.
`static final int`
`ROUND_STYLE`
Rounding style.
• ## Method Summary

Modifier and Type
Method
Description
`static void`
```add(double[] y, double[] x)```
Element-wise sum of two arrays y = x + y.
`static double[]`
```axpy(double a, double[] x, double[] y)```
Update an array by adding a multiple of another array y = a * x + y.
`static double[]`
`c(double... x)`
Combines the arguments to form a vector.
`static double[]`
`c(double[]... list)`
Concatenates multiple vectors into one.
`static float[]`
`c(float... x)`
Combines the arguments to form a vector.
`static float[]`
`c(float[]... list)`
Concatenates multiple vectors into one.
`static int[]`
`c(int... x)`
Combines the arguments to form a vector.
`static int[]`
`c(int[]... list)`
Concatenates multiple vectors into one.
`static String[]`
`c(String... x)`
Combines the arguments to form a vector.
`static String[]`
`c(String[]... list)`
Concatenates multiple vectors into one array of strings.
`static double[]`
`cbind(double[]... x)`
Concatenates vectors by columns.
`static float[]`
`cbind(float[]... x)`
Concatenates vectors by columns.
`static int[]`
`cbind(int[]... x)`
Concatenates vectors by columns.
`static String[]`
`cbind(String[]... x)`
Concatenates vectors by columns.
`static double`
```choose(int n, int k)```
The n choose k.
`static double[][]`
`clone(double[][] x)`
Deep clone a two-dimensional array.
`static float[][]`
`clone(float[][] x)`
Deep clone a two-dimensional array.
`static int[][]`
`clone(int[][] x)`
Deep clone a two-dimensional array.
`static double[]`
`colMax(double[][] matrix)`
Returns the column maximum of a matrix.
`static int[]`
`colMax(int[][] matrix)`
Returns the column maximum of a matrix.
`static double[]`
`colMeans(double[][] matrix)`
Returns the column means of a matrix.
`static double[]`
`colMin(double[][] matrix)`
Returns the column minimum of a matrix.
`static int[]`
`colMin(int[][] matrix)`
Returns the column minimum of a matrix.
`static double[]`
`colSds(double[][] matrix)`
Returns the column standard deviations of a matrix.
`static double[]`
`colSums(double[][] matrix)`
Returns the column sums of a matrix.
`static long[]`
`colSums(int[][] matrix)`
Returns the column sums of a matrix.
`static boolean`
```contains(double[][] polygon, double[] point)```
Determines if the polygon contains the point.
`static boolean`
```contains(double[][] polygon, double x, double y)```
Determines if the polygon contains the point.
`static void`
```copy(double[][] x, double[][] y)```
Deep copy x into y.
`static void`
```copy(float[][] x, float[][] y)```
Deep copy x into y.
`static void`
```copy(int[][] x, int[][] y)```
Copy x into y.
`static double[][]`
`cor(double[][] data)`
Returns the sample correlation matrix.
`static double[][]`
```cor(double[][] data, double[] mu)```
Returns the sample correlation matrix.
`static double`
```cor(double[] x, double[] y)```
Returns the correlation coefficient between two vectors.
`static double`
```cor(float[] x, float[] y)```
Returns the correlation coefficient between two vectors.
`static double`
```cor(int[] x, int[] y)```
Returns the correlation coefficient between two vectors.
`static double`
```cos(double[] x, double[] y)```
Returns the cosine similarity.
`static float`
```cos(float[] x, float[] y)```
Returns the cosine similarity.
`static double[][]`
`cov(double[][] data)`
Returns the sample covariance matrix.
`static double[][]`
```cov(double[][] data, double[] mu)```
Returns the sample covariance matrix.
`static double`
```cov(double[] x, double[] y)```
Returns the covariance between two vectors.
`static double`
```cov(float[] x, float[] y)```
Returns the covariance between two vectors.
`static double`
```cov(int[] x, int[] y)```
Returns the covariance between two vectors.
`static double`
```distance(double[] x, double[] y)```
The Euclidean distance.
`static double`
```distance(float[] x, float[] y)```
The Euclidean distance.
`static double`
```distance(int[] x, int[] y)```
The Euclidean distance on binary sparse arrays, which are the indices of nonzero elements in ascending order.
`static double`
```distance(SparseArray x, SparseArray y)```
The Euclidean distance.
`static double`
```dot(double[] x, double[] y)```
Returns the dot product between two vectors.
`static float`
```dot(float[] x, float[] y)```
Returns the dot product between two vectors.
`static int`
```dot(int[] x, int[] y)```
Returns the dot product between two binary sparse arrays, which are the indices of nonzero elements in ascending order.
`static double`
```dot(SparseArray x, SparseArray y)```
Returns the dot product between two sparse arrays.
`static double`
`entropy(double[] p)`
Shannon's entropy.
`static boolean`
```equals(double[][] x, double[][] y)```
Check if x element-wisely equals y with default epsilon 1E-10.
`static boolean`
```equals(double[][] x, double[][] y, double epsilon)```
Check if x element-wisely equals y in given precision.
`static boolean`
```equals(double[] x, double[] y)```
Check if x element-wisely equals y with default epsilon 1E-10.
`static boolean`
```equals(double[] x, double[] y, double epsilon)```
Check if x element-wisely equals y in given precision.
`static boolean`
```equals(double a, double b)```
Returns true if two double values equals to each other in the system precision.
`static boolean`
```equals(float[][] x, float[][] y)```
Check if x element-wisely equals y with default epsilon 1E-7.
`static boolean`
```equals(float[][] x, float[][] y, float epsilon)```
Check if x element-wisely equals y in given precision.
`static boolean`
```equals(float[] x, float[] y)```
Check if x element-wisely equals y with default epsilon 1E-7.
`static boolean`
```equals(float[] x, float[] y, float epsilon)```
Check if x element-wisely equals y in given precision.
`static double`
`factorial(int n)`
The factorial of n.
`static long`
`generateSeed()`
Returns a random number to seed other random number generators.
`static byte[]`
`generateSeed(int numBytes)`
Returns the given number of random bytes to seed other random number generators.
`static boolean`
`isInt(double x)`
Returns true if x is an integer.
`static boolean`
`isInt(float x)`
Returns true if x is an integer.
`static boolean`
`isPower2(int x)`
Returns true if x is a power of 2.
`static boolean`
```isProbablePrime(long n, int k)```
Returns true if n is probably prime, false if it's definitely composite.
`static boolean`
`isZero(double x)`
Tests if a floating number is zero in machine precision.
`static boolean`
```isZero(double x, double epsilon)```
Tests if a floating number is zero in given precision.
`static boolean`
`isZero(float x)`
Tests if a floating number is zero in machine precision.
`static boolean`
```isZero(float x, float epsilon)```
Tests if a floating number is zero in given precision.
`static double`
```JensenShannonDivergence(double[] p, double[] q)```
Jensen-Shannon divergence JS(P||Q) = (KL(P||M) + KL(Q||M)) / 2, where M = (P+Q)/2.
`static double`
```JensenShannonDivergence(double[] p, SparseArray q)```
Jensen-Shannon divergence JS(P||Q) = (KL(P||M) + KL(Q||M)) / 2, where M = (P+Q)/2.
`static double`
```JensenShannonDivergence(SparseArray p, double[] q)```
Jensen-Shannon divergence JS(P||Q) = (KL(P||M) + KL(Q||M)) / 2, where M = (P+Q)/2.
`static double`
```JensenShannonDivergence(SparseArray p, SparseArray q)```
Jensen-Shannon divergence JS(P||Q) = (KL(P||M) + KL(Q||M)) / 2, where M = (P+Q)/2.
`static double`
```kendall(double[] x, double[] y)```
The Kendall Tau Rank Correlation Coefficient is used to measure the degree of correspondence between sets of rankings where the measures are not equidistant.
`static double`
```kendall(float[] x, float[] y)```
The Kendall Tau Rank Correlation Coefficient is used to measure the degree of correspondence between sets of rankings where the measures are not equidistant.
`static double`
```kendall(int[] x, int[] y)```
The Kendall Tau Rank Correlation Coefficient is used to measure the degree of correspondence between sets of rankings where the measures are not equidistant.
`static double`
```KullbackLeiblerDivergence(double[] p, double[] q)```
Kullback-Leibler divergence.
`static double`
```KullbackLeiblerDivergence(double[] p, SparseArray q)```
Kullback-Leibler divergence.
`static double`
```KullbackLeiblerDivergence(SparseArray p, double[] q)```
Kullback-Leibler divergence.
`static double`
```KullbackLeiblerDivergence(SparseArray p, SparseArray q)```
Kullback-Leibler divergence.
`static double`
```lchoose(int n, int k)```
The log of n choose k.
`static double`
`lfactorial(int n)`
The log of factorial of n.
`static double`
`log(double x)`
Returns natural log without underflow.
`static double`
`log1pe(double x)`
Returns natural log(1+exp(x)) without overflow.
`static double`
`log2(double x)`
Log of base 2.
`static double`
`mad(double[] x)`
Returns the median absolute deviation (MAD).
`static double`
`mad(float[] x)`
Returns the median absolute deviation (MAD).
`static double`
`mad(int[] x)`
Returns the median absolute deviation (MAD).
`static double`
`max(double[] x)`
Returns the maximum value of an array.
`static double`
`max(double[][] matrix)`
Returns the maximum of a matrix.
`static double`
```max(double a, double b, double c)```
Returns the maximum of 4 double numbers.
`static double`
```max(double a, double b, double c, double d)```
Returns the maximum of 4 double numbers.
`static float`
`max(float[] x)`
Returns the maximum value of an array.
`static float`
```max(float a, float b, float c)```
Returns the maximum of 4 float numbers.
`static float`
```max(float a, float b, float c, float d)```
Returns the maximum of 4 float numbers.
`static int`
`max(int[] x)`
Returns the maximum value of an array.
`static int`
`max(int[][] matrix)`
Returns the maximum of a matrix.
`static int`
```max(int a, int b, int c)```
Returns the maximum of 3 integer numbers.
`static int`
```max(int a, int b, int c, int d)```
Returns the maximum of 4 integer numbers.
`static double`
`mean(double[] x)`
Returns the mean of an array.
`static double`
`mean(float[] x)`
Returns the mean of an array.
`static double`
`mean(int[] x)`
Returns the mean of an array.
`static double`
`median(double[] x)`
Find the median of an array of type double.
`static float`
`median(float[] x)`
Find the median of an array of type float.
`static int`
`median(int[] x)`
Find the median of an array of type int.
`static <T extends Comparable<? super T>>T`
`median(T[] x)`
Find the median of an array of type double.
`static double`
`min(double[] x)`
Returns the minimum value of an array.
`static double`
`min(double[][] matrix)`
Returns the minimum of a matrix.
`static double`
```min(double a, double b, double c)```
Returns the minimum of 3 double numbers.
`static double`
```min(double a, double b, double c, double d)```
Returns the minimum of 4 double numbers.
`static float`
`min(float[] x)`
Returns the minimum value of an array.
`static float`
```min(float a, float b, float c)```
Returns the minimum of 3 float numbers.
`static float`
```min(float a, float b, float c, float d)```
Returns the minimum of 4 float numbers.
`static int`
`min(int[] x)`
Returns the minimum value of an array.
`static int`
`min(int[][] matrix)`
Returns the minimum of a matrix.
`static int`
```min(int a, int b, int c)```
Returns the minimum of 3 integer numbers.
`static int`
```min(int a, int b, int c, int d)```
Returns the minimum of 4 integer numbers.
`static int`
`mode(int[] a)`
Returns the mode of the array, which is the most frequent element.
`static double`
`norm(double[] x)`
L2 vector norm.
`static float`
`norm(float[] x)`
L2 vector norm.
`static double`
`norm1(double[] x)`
L1 vector norm.
`static float`
`norm1(float[] x)`
L1 vector norm.
`static double`
`norm2(double[] x)`
L2 vector norm.
`static float`
`norm2(float[] x)`
L2 vector norm.
`static void`
`normalize(double[][] x)`
Unitizes each column of a matrix to unit length (L_2 norm).
`static void`
```normalize(double[][] x, boolean centerizing)```
Unitizes each column of a matrix to unit length (L_2 norm).
`static double`
`normInf(double[] x)`
L vector norm.
`static float`
`normInf(float[] x)`
L vector norm that is the maximum absolute value.
`static double[]`
```omit(double[] a, double value)```
Returns a new array without the specified value.
`static float[]`
```omit(float[] a, float value)```
Returns a new array without the specified value.
`static int[]`
```omit(int[] a, int value)```
Returns a new array without the specified value.
`static double[]`
`omitNaN(double[] a)`
Returns a new array without NaN values.
`static float[]`
`omitNaN(float[] a)`
Returns a new array without NaN values.
`static Matrix`
`pdist(double[][] x)`
Returns the pairwise distance matrix of multiple vectors.
`static Matrix`
```pdist(double[][] x, boolean squared)```
Returns the pairwise distance matrix of multiple vectors.
`static Matrix`
`pdist(float[][] x)`
Returns the pairwise distance matrix of multiple vectors.
`static Matrix`
```pdist(float[][] x, boolean squared)```
Returns the pairwise distance matrix of multiple vectors.
`static Matrix`
`pdist(int[][] x)`
Returns the pairwise distance matrix of multiple binary sparse vectors.
`static Matrix`
```pdist(int[][] x, boolean squared)```
Returns the pairwise distance matrix of multiple binary sparse vectors.
`static Matrix`
`pdist(SparseArray[] x)`
Returns the pairwise distance matrix of multiple vectors.
`static Matrix`
```pdist(SparseArray[] x, boolean squared)```
Returns the pairwise distance matrix of multiple vectors.
`static <T> void`
```pdist(T[] x, double[][] d, Distance<T> distance)```
Computes the pairwise distance matrix of multiple vectors.
`static Matrix`
`pdot(double[][] x)`
Returns the pairwise dot product matrix of double vectors.
`static Matrix`
`pdot(float[][] x)`
Returns the pairwise dot product matrix of float vectors.
`static Matrix`
`pdot(int[][] x)`
Returns the pairwise dot product matrix of binary sparse vectors.
`static Matrix`
`pdot(SparseArray[] x)`
Returns the pairwise dot product matrix of multiple vectors.
`static void`
`permutate(double[] x)`
Permutates an array.
`static void`
`permutate(float[] x)`
Permutates an array.
`static int[]`
`permutate(int n)`
Returns a permutation of `(0, 1, 2, ..., n-1)`.
`static void`
`permutate(int[] x)`
Permutates an array.
`static void`
`permutate(Object[] x)`
Permutates an array.
`static double[]`
```pow(double[] x, double n)```
Raise each element of an array to a scalar power.
`static double`
`pow2(double x)`
Returns x * x.
`static long`
```probablePrime(long n, int k)```
Returns a probably prime number greater than n.
`static double`
`q1(double[] x)`
Find the first quantile (p = 1/4) of an array of type double.
`static float`
`q1(float[] x)`
Find the first quantile (p = 1/4) of an array of type float.
`static int`
`q1(int[] x)`
Find the first quantile (p = 1/4) of an array of type int.
`static <T extends Comparable<? super T>>T`
`q1(T[] x)`
Find the first quantile (p = 1/4) of an array of type double.
`static double`
`q3(double[] x)`
Find the third quantile (p = 3/4) of an array of type double.
`static float`
`q3(float[] x)`
Find the third quantile (p = 3/4) of an array of type float.
`static int`
`q3(int[] x)`
Find the third quantile (p = 3/4) of an array of type int.
`static <T extends Comparable<? super T>>T`
`q3(T[] x)`
Find the third quantile (p = 3/4) of an array of type double.
`static double`
`random()`
Generate a random number in [0, 1).
`static int`
`random(double[] prob)`
Given a set of n probabilities, generate a random number in [0, n).
`static int[]`
```random(double[] prob, int n)```
Given a set of m probabilities, draw with replacement a set of n random number in [0, m).
`static double`
```random(double lo, double hi)```
Generate a uniform random number in the range [lo, hi).
`static double[]`
```random(double lo, double hi, int n)```
Generate uniform random numbers in the range [lo, hi).
`static double[]`
`random(int n)`
Generate n random numbers in [0, 1).
`static int`
`randomInt(int n)`
Returns a random integer in [0, n).
`static int`
```randomInt(int lo, int hi)```
Returns a random integer in [lo, hi).
`static long`
`randomLong()`
Returns a random long integer.
`static double[][]`
`rbind(double[]... x)`
Concatenates vectors by rows.
`static float[][]`
`rbind(float[]... x)`
Concatenates vectors by rows.
`static int[][]`
`rbind(int[]... x)`
Concatenates vectors by rows.
`static String[][]`
`rbind(String[]... x)`
Concatenates vectors by rows.
`static void`
`reverse(double[] a)`
Reverses the order of the elements in the specified array.
`static void`
`reverse(float[] a)`
Reverses the order of the elements in the specified array.
`static void`
`reverse(int[] a)`
Reverses the order of the elements in the specified array.
`static <T> void`
`reverse(T[] a)`
Reverses the order of the elements in the specified array.
`static double`
```round(double x, int decimal)```
Round a double vale to given digits such as 10^n, where n is a positive or negative integer.
`static double[]`
`rowMax(double[][] matrix)`
Returns the row maximum of a matrix.
`static int[]`
`rowMax(int[][] matrix)`
Returns the row maximum of a matrix.
`static double[]`
`rowMeans(double[][] matrix)`
Returns the row means of a matrix.
`static double[]`
`rowMin(double[][] matrix)`
Returns the row minimum of a matrix.
`static int[]`
`rowMin(int[][] matrix)`
Returns the row minimum of a matrix.
`static double[]`
`rowSds(double[][] matrix)`
Returns the row standard deviations of a matrix.
`static double[]`
`rowSums(double[][] matrix)`
Returns the row sums of a matrix.
`static long[]`
`rowSums(int[][] matrix)`
Returns the row sums of a matrix.
`static void`
`scale(double[][] x)`
Scales each column of a matrix to range [0, 1].
`static void`
```scale(double a, double[] x)```
Scale each element of an array by a constant x = a * x.
`static void`
```scale(double a, double[] x, double[] y)```
Scale each element of an array by a constant y = a * x.
`static double`
`sd(double[] x)`
Returns the standard deviation of an array.
`static double`
`sd(float[] x)`
Returns the standard deviation of an array.
`static double`
`sd(int[] x)`
Returns the standard deviation of an array.
`static LongStream`
`seeds()`
Returns a stream of random numbers to be used as RNG seeds.
`static void`
`setSeed(long seed)`
Initialize the random number generator with a seed.
`static double`
`sigmoid(double x)`
Logistic sigmoid function `1 / (1 + exp(-x))`.
`static double[]`
```slice(double[] data, int[] index)```
Returns a slice of data for given indices.
`static float[]`
```slice(float[] data, int[] index)```
Returns a slice of data for given indices.
`static int[]`
```slice(int[] data, int[] index)```
Returns a slice of data for given indices.
`static <E> E[]`
```slice(E[] data, int[] index)```
Returns a slice of data for given indices.
`static int`
`softmax(double[] posteriori)`
The softmax function without overflow.
`static int`
```softmax(double[] x, int k)```
The softmax function without overflow.
`static double[]`
```solve(double[] a, double[] b, double[] c, double[] r)```
Solve the tridiagonal linear set which is of diagonal dominance |bi| `>` |ai| + |ci|.
`static int[][]`
`sort(double[][] x)`
Sorts each variable and returns the index of values in ascending order.
`static double`
```spearman(double[] x, double[] y)```
The Spearman Rank Correlation Coefficient is a form of the Pearson coefficient with the data converted to rankings (i.e.
`static double`
```spearman(float[] x, float[] y)```
The Spearman Rank Correlation Coefficient is a form of the Pearson coefficient with the data converted to rankings (i.e.
`static double`
```spearman(int[] x, int[] y)```
The Spearman Rank Correlation Coefficient is a form of the Pearson coefficient with the data converted to rankings (i.e.
`static double`
```squaredDistance(double[] x, double[] y)```
The squared Euclidean distance.
`static double`
```squaredDistance(float[] x, float[] y)```
The squared Euclidean distance.
`static double`
```squaredDistance(int[] x, int[] y)```
The squared Euclidean distance on binary sparse arrays, which are the indices of nonzero elements in ascending order.
`static double`
```squaredDistance(SparseArray x, SparseArray y)```
The Euclidean distance on sparse arrays.
`static double`
```squaredDistanceWithMissingValues(double[] x, double[] y)```
The squared Euclidean distance with handling missing values (represented as NaN).
`static void`
`standardize(double[] x)`
Standardizes an array to mean 0 and variance 1.
`static void`
`standardize(double[][] x)`
Standardizes each column of a matrix to 0 mean and unit variance.
`static void`
```sub(double[] y, double[] x)```
Element-wise subtraction of two arrays y = y - x.
`static int`
`sum(byte[] x)`
Returns the sum of an array.
`static double`
`sum(double[] x)`
Returns the sum of an array.
`static double`
`sum(float[] x)`
Returns the sum of an array.
`static long`
`sum(int[] x)`
Returns the sum of an array.
`static void`
```swap(double[] x, double[] y)```
Swap two arrays.
`static void`
```swap(double[] x, int i, int j)```
Swap two elements of an array.
`static void`
```swap(float[] x, float[] y)```
Swap two arrays.
`static void`
```swap(float[] x, int i, int j)```
Swap two elements of an array.
`static void`
```swap(int[] x, int[] y)```
Swap two arrays.
`static void`
```swap(int[] x, int i, int j)```
Swap two elements of an array.
`static <E> void`
```swap(E[] x, E[] y)```
Swap two arrays.
`static void`
```swap(Object[] x, int i, int j)```
Swap two elements of an array.
`static double[][]`
`transpose(double[][] matrix)`
Returns the matrix transpose.
`static int[]`
`unique(int[] x)`
Find unique elements of vector.
`static String[]`
`unique(String[] x)`
Find unique elements of vector.
`static void`
`unitize(double[] x)`
Unitize an array so that L2 norm of x = 1.
`static void`
`unitize1(double[] x)`
Unitize an array so that L1 norm of x is 1.
`static void`
`unitize2(double[] x)`
Unitize an array so that L2 norm of x = 1.
`static double`
`var(double[] x)`
Returns the variance of an array.
`static double`
`var(float[] x)`
Returns the variance of an array.
`static double`
`var(int[] x)`
Returns the variance of an array.
`static int`
`whichMax(double[] x)`
Returns the index of maximum value of an array.
`static IntPair`
`whichMax(double[][] matrix)`
Returns the index of maximum value of a matrix.
`static int`
`whichMax(float[] x)`
Returns the index of maximum value of an array.
`static int`
`whichMax(int[] x)`
Returns the index of maximum value of an array.
`static int`
`whichMin(double[] x)`
Returns the index of minimum value of an array.
`static IntPair`
`whichMin(double[][] matrix)`
Returns the index of minimum value of a matrix.
`static int`
`whichMin(float[] x)`
Returns the index of minimum value of an array.
`static int`
`whichMin(int[] x)`
Returns the index of minimum value of an array.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ## Field Details

• ### EPSILON

public static final double EPSILON
The machine precision for the double type, which is the difference between 1 and the smallest value greater than 1 that is representable for the double type.
• ### FLOAT_EPSILON

public static final float FLOAT_EPSILON
The machine precision for the float type, which is the difference between 1 and the smallest value greater than 1 that is representable for the float type.
• ### RADIX

public static final int RADIX
The base of the exponent of the double type.
• ### DIGITS

public static final int DIGITS
The number of digits (in radix base) in the mantissa.
• ### FLOAT_DIGITS

public static final int FLOAT_DIGITS
The number of digits (in radix base) in the mantissa.
• ### ROUND_STYLE

public static final int ROUND_STYLE
Rounding style.
• 0 if floating-point addition chops
• 1 if floating-point addition rounds, but not in the ieee style
• 2 if floating-point addition rounds in the ieee style
• 3 if floating-point addition chops, and there is partial underflow
• 4 if floating-point addition rounds, but not in the ieee style, and there is partial underflow
• 5 if floating-point addition rounds in the IEEEE style, and there is partial underflow
• ### MACHEP

public static final int MACHEP
The largest negative integer such that 1.0 + RADIXMACHEP ≠ 1.0, except that machep is bounded below by -(DIGITS+3)
• ### FLOAT_MACHEP

public static final int FLOAT_MACHEP
The largest negative integer such that 1.0 + RADIXMACHEP ≠ 1.0, except that machep is bounded below by -(DIGITS+3)
• ### NEGEP

public static final int NEGEP
The largest negative integer such that 1.0 - RADIXNEGEP ≠ 1.0, except that negeps is bounded below by -(DIGITS+3)
• ### FLOAT_NEGEP

public static final int FLOAT_NEGEP
The largest negative integer such that 1.0 - RADIXNEGEP ≠ 1.0, except that negeps is bounded below by -(DIGITS+3)
• ## Method Details

• ### log2

public static double log2(double x)
Log of base 2.
Parameters:
`x` - a real number.
Returns:
the value `log2(x)`.
• ### log

public static double log(double x)
Returns natural log without underflow.
Parameters:
`x` - a real number.
Returns:
the value `log(x)`.
• ### log1pe

public static double log1pe(double x)
Returns natural log(1+exp(x)) without overflow.
Parameters:
`x` - a real number.
Returns:
the value `log(1+exp(x))`.
• ### isInt

public static boolean isInt(float x)
Returns true if x is an integer.
Parameters:
`x` - a real number.
Returns:
true if x is an integer.
• ### isInt

public static boolean isInt(double x)
Returns true if x is an integer.
Parameters:
`x` - a real number.
Returns:
true if x is an integer.
• ### equals

public static boolean equals(double a, double b)
Returns true if two double values equals to each other in the system precision.
Parameters:
`a` - a double value.
`b` - a double value.
Returns:
true if two double values equals to each other in the system precision
• ### sigmoid

public static double sigmoid(double x)
Logistic sigmoid function `1 / (1 + exp(-x))`.
Parameters:
`x` - a real number.
Returns:
the sigmoid function.
• ### pow2

public static double pow2(double x)
Returns x * x.
Parameters:
`x` - a real number.
Returns:
the square of x.
• ### isPower2

public static boolean isPower2(int x)
Returns true if x is a power of 2.
Parameters:
`x` - a real number.
Returns:
true if x is a power of 2.
• ### isProbablePrime

public static boolean isProbablePrime(long n, int k)
Returns true if n is probably prime, false if it's definitely composite. This implements Miller-Rabin primality test.
Parameters:
`n` - an odd integer to be tested for primality
`k` - the number of rounds of primality test to perform. With larger number of rounds, the test is more accurate but also takes longer time.
Returns:
true if n is probably prime, false if it's definitely composite.
• ### round

public static double round(double x, int decimal)
Round a double vale to given digits such as 10^n, where n is a positive or negative integer.
Parameters:
`x` - a real number.
`decimal` - the number of digits to round to.
Returns:
the rounded value.
• ### factorial

public static double factorial(int n)
The factorial of n.
Parameters:
`n` - a positive integer.
Returns:
the factorial returned as double but is, numerically, an integer. Numerical rounding may make this an approximation after n = 21.
• ### lfactorial

public static double lfactorial(int n)
The log of factorial of n.
Parameters:
`n` - a positive integer.
Returns:
the log of factorial .
• ### choose

public static double choose(int n, int k)
The n choose k. Returns 0 if n is less than k.
Parameters:
`n` - the total number of objects in the set.
`k` - the number of choosing objects from the set.
Returns:
the number of combinations.
• ### lchoose

public static double lchoose(int n, int k)
The log of n choose k.
Parameters:
`n` - the total number of objects in the set.
`k` - the number of choosing objects from the set.
Returns:
the log of the number of combinations.
• ### generateSeed

public static long generateSeed()
Returns a random number to seed other random number generators.
Returns:
a random number to seed other random number generators.
• ### generateSeed

public static byte[] generateSeed(int numBytes)
Returns the given number of random bytes to seed other random number generators.
Parameters:
`numBytes` - the number of seed bytes to generate.
Returns:
the seed bytes.
• ### seeds

public static LongStream seeds()
Returns a stream of random numbers to be used as RNG seeds.
Returns:
a stream of random numbers to be used as RNG seeds.
• ### setSeed

public static void setSeed(long seed)
Initialize the random number generator with a seed.
Parameters:
`seed` - the RNG seed.
• ### probablePrime

public static long probablePrime(long n, int k)
Returns a probably prime number greater than n.
Parameters:
`n` - the returned value should be greater than n.
`k` - the number of rounds of primality test to perform. With larger number of rounds, the test is more accurate but also takes longer time.
Returns:
a probably prime number greater than n.
• ### random

public static int random(double[] prob)
Given a set of n probabilities, generate a random number in [0, n).
Parameters:
`prob` - probabilities of size n. The prob argument can be used to give a vector of weights for obtaining the elements of the vector being sampled. They need not sum to one, but they should be non-negative and not all zero.
Returns:
a random integer in [0, n).
• ### random

public static int[] random(double[] prob, int n)
Given a set of m probabilities, draw with replacement a set of n random number in [0, m).
Parameters:
`prob` - probabilities of size n. The prob argument can be used to give a vector of weights for obtaining the elements of the vector being sampled. They need not sum to one, but they should be non-negative and not all zero.
`n` - the number of random numbers.
Returns:
random numbers in range of [0, m).
• ### random

public static double random()
Generate a random number in [0, 1).
Returns:
a random number.
• ### random

public static double[] random(int n)
Generate n random numbers in [0, 1).
Parameters:
`n` - the number of random numbers.
Returns:
the random numbers.
• ### random

public static double random(double lo, double hi)
Generate a uniform random number in the range [lo, hi).
Parameters:
`lo` - lower limit of range
`hi` - upper limit of range
Returns:
a uniform random number in the range [lo, hi)
• ### random

public static double[] random(double lo, double hi, int n)
Generate uniform random numbers in the range [lo, hi).
Parameters:
`lo` - lower limit of range
`hi` - upper limit of range
`n` - the number of random numbers.
Returns:
uniform random numbers in the range [lo, hi)
• ### randomLong

public static long randomLong()
Returns a random long integer.
Returns:
a random long integer.
• ### randomInt

public static int randomInt(int n)
Returns a random integer in [0, n).
Parameters:
`n` - the upper bound of random number.
Returns:
a random integer.
• ### randomInt

public static int randomInt(int lo, int hi)
Returns a random integer in [lo, hi).
Parameters:
`lo` - lower limit of range
`hi` - upper limit of range
Returns:
a uniform random number in the range [lo, hi)
• ### permutate

public static int[] permutate(int n)
Returns a permutation of `(0, 1, 2, ..., n-1)`.
Parameters:
`n` - the upper bound.
Returns:
the permutation of `(0, 1, 2, ..., n-1)`.
• ### permutate

public static void permutate(int[] x)
Permutates an array.
Parameters:
`x` - the array.
• ### permutate

public static void permutate(float[] x)
Permutates an array.
Parameters:
`x` - the array.
• ### permutate

public static void permutate(double[] x)
Permutates an array.
Parameters:
`x` - the array.
• ### permutate

public static void permutate(Object[] x)
Permutates an array.
Parameters:
`x` - the array.
• ### softmax

public static int softmax(double[] posteriori)
The softmax function without overflow. The function takes as an input vector of K real numbers, and normalizes it into a probability distribution consisting of K probabilities proportional to the exponentials of the input numbers. That is, prior to applying softmax, some vector components could be negative, or greater than one; and might not sum to 1; but after applying softmax, each component will be in the interval (0,1), and the components will add up to 1, so that they can be interpreted as probabilities. Furthermore, the larger input components will correspond to larger probabilities.
Parameters:
`posteriori` - the input/output vector.
Returns:
the index of largest posteriori probability.
• ### softmax

public static int softmax(double[] x, int k)
The softmax function without overflow. The function takes as an input vector of K real numbers, and normalizes it into a probability distribution consisting of K probabilities proportional to the exponentials of the input numbers. That is, prior to applying softmax, some vector components could be negative, or greater than one; and might not sum to 1; but after applying softmax, each component will be in the interval (0,1), and the components will add up to 1, so that they can be interpreted as probabilities. Furthermore, the larger input components will correspond to larger probabilities.
Parameters:
`x` - the input/output vector.
`k` - uses only first k components of input vector.
Returns:
the index of largest posteriori probability.
• ### c

public static int[] c(int... x)
Combines the arguments to form a vector.
Parameters:
`x` - the vector elements.
Returns:
the vector.
• ### c

public static float[] c(float... x)
Combines the arguments to form a vector.
Parameters:
`x` - the vector elements.
Returns:
the vector.
• ### c

public static double[] c(double... x)
Combines the arguments to form a vector.
Parameters:
`x` - the vector elements.
Returns:
the vector.
• ### c

public static String[] c(String... x)
Combines the arguments to form a vector.
Parameters:
`x` - the vector elements.
Returns:
the vector.
• ### c

public static int[] c(int[]... list)
Concatenates multiple vectors into one.
Parameters:
`list` - the vectors.
Returns:
the concatenated vector.
• ### c

public static float[] c(float[]... list)
Concatenates multiple vectors into one.
Parameters:
`list` - the vectors.
Returns:
the concatenated vector.
• ### c

public static double[] c(double[]... list)
Concatenates multiple vectors into one.
Parameters:
`list` - the vectors.
Returns:
the concatenated vector.
• ### c

public static String[] c(String[]... list)
Concatenates multiple vectors into one array of strings.
Parameters:
`list` - the vectors.
Returns:
the concatenated vector.
• ### cbind

public static int[] cbind(int[]... x)
Concatenates vectors by columns.
Parameters:
`x` - the vectors.
Returns:
the concatenated vector.
• ### cbind

public static float[] cbind(float[]... x)
Concatenates vectors by columns.
Parameters:
`x` - the vectors.
Returns:
the concatenated vector.
• ### cbind

public static double[] cbind(double[]... x)
Concatenates vectors by columns.
Parameters:
`x` - the vectors.
Returns:
the concatenated vector.
• ### cbind

public static String[] cbind(String[]... x)
Concatenates vectors by columns.
Parameters:
`x` - the vectors.
Returns:
the concatenated vector.
• ### rbind

public static int[][] rbind(int[]... x)
Concatenates vectors by rows.
Parameters:
`x` - the vectors.
Returns:
the matrix.
• ### rbind

public static float[][] rbind(float[]... x)
Concatenates vectors by rows.
Parameters:
`x` - the vectors.
Returns:
the matrix.
• ### rbind

public static double[][] rbind(double[]... x)
Concatenates vectors by rows.
Parameters:
`x` - the vectors.
Returns:
the matrix.
• ### rbind

public static String[][] rbind(String[]... x)
Concatenates vectors by rows.
Parameters:
`x` - the vectors.
Returns:
the matrix.
• ### slice

public static <E> E[] slice(E[] data, int[] index)
Returns a slice of data for given indices.
Type Parameters:
`E` - the data type of elements.
Parameters:
`data` - the array.
`index` - the indices of selected elements.
Returns:
the selected elements.
• ### slice

public static int[] slice(int[] data, int[] index)
Returns a slice of data for given indices.
Parameters:
`data` - the array.
`index` - the indices of selected elements.
Returns:
the selected elements.
• ### slice

public static float[] slice(float[] data, int[] index)
Returns a slice of data for given indices.
Parameters:
`data` - the array.
`index` - the indices of selected elements.
Returns:
the selected elements.
• ### slice

public static double[] slice(double[] data, int[] index)
Returns a slice of data for given indices.
Parameters:
`data` - the array.
`index` - the indices of selected elements.
Returns:
the selected elements.
• ### contains

public static boolean contains(double[][] polygon, double[] point)
Determines if the polygon contains the point.
Parameters:
`polygon` - the vertices of polygon.
`point` - the point.
Returns:
true if the Polygon contains the point.
• ### contains

public static boolean contains(double[][] polygon, double x, double y)
Determines if the polygon contains the point.
Parameters:
`polygon` - the vertices of polygon.
`x` - the x coordinate of point.
`y` - the y coordinate of point.
Returns:
true if the Polygon contains the point.
• ### omit

public static int[] omit(int[] a, int value)
Returns a new array without the specified value.
Parameters:
`a` - an input array.
`value` - the value to omit.
Returns:
a new array without the specified value.
• ### omit

public static float[] omit(float[] a, float value)
Returns a new array without the specified value.
Parameters:
`a` - an input array.
`value` - the value to omit.
Returns:
a new array without the specified value.
• ### omit

public static double[] omit(double[] a, double value)
Returns a new array without the specified value.
Parameters:
`a` - an input array.
`value` - the value to omit.
Returns:
a new array without the specified value.
• ### omitNaN

public static float[] omitNaN(float[] a)
Returns a new array without NaN values.
Parameters:
`a` - an input array that may contain NaN.
Returns:
a new array without NaN values.
• ### omitNaN

public static double[] omitNaN(double[] a)
Returns a new array without NaN values.
Parameters:
`a` - an input array that may contain NaN.
Returns:
a new array without NaN values.
• ### reverse

public static void reverse(int[] a)
Reverses the order of the elements in the specified array.
Parameters:
`a` - an array to reverse.
• ### reverse

public static void reverse(float[] a)
Reverses the order of the elements in the specified array.
Parameters:
`a` - the array to reverse.
• ### reverse

public static void reverse(double[] a)
Reverses the order of the elements in the specified array.
Parameters:
`a` - the array to reverse.
• ### reverse

public static <T> void reverse(T[] a)
Reverses the order of the elements in the specified array.
Type Parameters:
`T` - the data type of array elements.
Parameters:
`a` - the array to reverse.
• ### mode

public static int mode(int[] a)
Returns the mode of the array, which is the most frequent element. If there are multiple modes, one of them will be returned.
Parameters:
`a` - the array. The order of elements will be changed on output.
Returns:
the mode.
• ### min

public static int min(int a, int b, int c)
Returns the minimum of 3 integer numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
Returns:
the minimum.
• ### min

public static float min(float a, float b, float c)
Returns the minimum of 3 float numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
Returns:
the minimum.
• ### min

public static double min(double a, double b, double c)
Returns the minimum of 3 double numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
Returns:
the minimum.
• ### min

public static int min(int a, int b, int c, int d)
Returns the minimum of 4 integer numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
`d` - a number.
Returns:
the minimum.
• ### min

public static float min(float a, float b, float c, float d)
Returns the minimum of 4 float numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
`d` - a number.
Returns:
the minimum.
• ### min

public static double min(double a, double b, double c, double d)
Returns the minimum of 4 double numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
`d` - a number.
Returns:
the minimum.
• ### max

public static int max(int a, int b, int c)
Returns the maximum of 3 integer numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
Returns:
the maximum.
• ### max

public static float max(float a, float b, float c)
Returns the maximum of 4 float numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
Returns:
the maximum.
• ### max

public static double max(double a, double b, double c)
Returns the maximum of 4 double numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
Returns:
the maximum.
• ### max

public static int max(int a, int b, int c, int d)
Returns the maximum of 4 integer numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
`d` - a number.
Returns:
the maximum.
• ### max

public static float max(float a, float b, float c, float d)
Returns the maximum of 4 float numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
`d` - a number.
Returns:
the maximum.
• ### max

public static double max(double a, double b, double c, double d)
Returns the maximum of 4 double numbers.
Parameters:
`a` - a number.
`b` - a number.
`c` - a number.
`d` - a number.
Returns:
the maximum.
• ### min

public static int min(int[] x)
Returns the minimum value of an array.
Parameters:
`x` - the array.
Returns:
the minimum.
• ### min

public static float min(float[] x)
Returns the minimum value of an array.
Parameters:
`x` - the array.
Returns:
the minimum.
• ### min

public static double min(double[] x)
Returns the minimum value of an array.
Parameters:
`x` - the array.
Returns:
the minimum.
• ### whichMin

public static int whichMin(int[] x)
Returns the index of minimum value of an array.
Parameters:
`x` - the array.
Returns:
the index of minimum.
• ### whichMin

public static int whichMin(float[] x)
Returns the index of minimum value of an array.
Parameters:
`x` - the array.
Returns:
the index of minimum.
• ### whichMin

public static int whichMin(double[] x)
Returns the index of minimum value of an array.
Parameters:
`x` - the array.
Returns:
the index of minimum.
• ### max

public static int max(int[] x)
Returns the maximum value of an array.
Parameters:
`x` - the array.
Returns:
the index of maximum.
• ### max

public static float max(float[] x)
Returns the maximum value of an array.
Parameters:
`x` - the array.
Returns:
the index of maximum.
• ### max

public static double max(double[] x)
Returns the maximum value of an array.
Parameters:
`x` - the array.
Returns:
the index of maximum.
• ### whichMax

public static int whichMax(int[] x)
Returns the index of maximum value of an array.
Parameters:
`x` - the array.
Returns:
the index of maximum.
• ### whichMax

public static int whichMax(float[] x)
Returns the index of maximum value of an array.
Parameters:
`x` - the array.
Returns:
the index of maximum.
• ### whichMax

public static int whichMax(double[] x)
Returns the index of maximum value of an array.
Parameters:
`x` - the array.
Returns:
the index of maximum.
• ### min

public static int min(int[][] matrix)
Returns the minimum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the minimum.
• ### min

public static double min(double[][] matrix)
Returns the minimum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the minimum.
• ### max

public static int max(int[][] matrix)
Returns the maximum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the maximum.
• ### max

public static double max(double[][] matrix)
Returns the maximum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the maximum.
• ### whichMin

public static IntPair whichMin(double[][] matrix)
Returns the index of minimum value of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the index of minimum.
• ### whichMax

public static IntPair whichMax(double[][] matrix)
Returns the index of maximum value of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the index of maximum.
• ### transpose

public static double[][] transpose(double[][] matrix)
Returns the matrix transpose.
Parameters:
`matrix` - the matrix.
Returns:
the transpose.
• ### rowMin

public static int[] rowMin(int[][] matrix)
Returns the row minimum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the row minimums.
• ### rowMax

public static int[] rowMax(int[][] matrix)
Returns the row maximum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the row maximums.
• ### rowSums

public static long[] rowSums(int[][] matrix)
Returns the row sums of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the row sums.
• ### rowMin

public static double[] rowMin(double[][] matrix)
Returns the row minimum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the row minimums.
• ### rowMax

public static double[] rowMax(double[][] matrix)
Returns the row maximum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the row maximums.
• ### rowSums

public static double[] rowSums(double[][] matrix)
Returns the row sums of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the row sums.
• ### rowMeans

public static double[] rowMeans(double[][] matrix)
Returns the row means of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the row means.
• ### rowSds

public static double[] rowSds(double[][] matrix)
Returns the row standard deviations of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the row standard deviations.
• ### colMin

public static int[] colMin(int[][] matrix)
Returns the column minimum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the column minimums.
• ### colMax

public static int[] colMax(int[][] matrix)
Returns the column maximum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the column maximums.
• ### colSums

public static long[] colSums(int[][] matrix)
Returns the column sums of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the column sums.
• ### colMin

public static double[] colMin(double[][] matrix)
Returns the column minimum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the column minimums.
• ### colMax

public static double[] colMax(double[][] matrix)
Returns the column maximum of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the column maximums.
• ### colSums

public static double[] colSums(double[][] matrix)
Returns the column sums of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the column sums.
• ### colMeans

public static double[] colMeans(double[][] matrix)
Returns the column means of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the column means.
• ### colSds

public static double[] colSds(double[][] matrix)
Returns the column standard deviations of a matrix.
Parameters:
`matrix` - the matrix.
Returns:
the column standard deviations.
• ### sum

public static int sum(byte[] x)
Returns the sum of an array.
Parameters:
`x` - the array.
Returns:
the sum.
• ### sum

public static long sum(int[] x)
Returns the sum of an array.
Parameters:
`x` - the array.
Returns:
the sum.
• ### sum

public static double sum(float[] x)
Returns the sum of an array.
Parameters:
`x` - the array.
Returns:
the sum.
• ### sum

public static double sum(double[] x)
Returns the sum of an array.
Parameters:
`x` - the array.
Returns:
the sum.
• ### median

public static int median(int[] x)
Find the median of an array of type int. The input array will be rearranged.
Parameters:
`x` - the array.
Returns:
the median.
• ### median

public static float median(float[] x)
Find the median of an array of type float. The input array will be rearranged.
Parameters:
`x` - the array.
Returns:
the median.
• ### median

public static double median(double[] x)
Find the median of an array of type double. The input array will be rearranged.
Parameters:
`x` - the array.
Returns:
the median.
• ### median

public static <T extends Comparable<? super T>> T median(T[] x)
Find the median of an array of type double. The input array will be rearranged.
Type Parameters:
`T` - the data type of array elements.
Parameters:
`x` - the array.
Returns:
the median.
• ### q1

public static int q1(int[] x)
Find the first quantile (p = 1/4) of an array of type int. The input array will be rearranged.
Parameters:
`x` - the array.
Returns:
the first quantile.
• ### q1

public static float q1(float[] x)
Find the first quantile (p = 1/4) of an array of type float. The input array will be rearranged.
Parameters:
`x` - the array.
Returns:
the first quantile.
• ### q1

public static double q1(double[] x)
Find the first quantile (p = 1/4) of an array of type double. The input array will be rearranged.
Parameters:
`x` - the array.
Returns:
the first quantile.
• ### q1

public static <T extends Comparable<? super T>> T q1(T[] x)
Find the first quantile (p = 1/4) of an array of type double. The input array will be rearranged.
Type Parameters:
`T` - the data type of array elements.
Parameters:
`x` - the array.
Returns:
the first quantile.
• ### q3

public static int q3(int[] x)
Find the third quantile (p = 3/4) of an array of type int. The input array will be rearranged.
Parameters:
`x` - the array.
Returns:
the third quantile.
• ### q3

public static float q3(float[] x)
Find the third quantile (p = 3/4) of an array of type float. The input array will be rearranged.
Parameters:
`x` - the array.
Returns:
the third quantile.
• ### q3

public static double q3(double[] x)
Find the third quantile (p = 3/4) of an array of type double. The input array will be rearranged.
Parameters:
`x` - the array.
Returns:
the third quantile.
• ### q3

public static <T extends Comparable<? super T>> T q3(T[] x)
Find the third quantile (p = 3/4) of an array of type double. The input array will be rearranged.
Type Parameters:
`T` - the data type of array elements.
Parameters:
`x` - the array.
Returns:
the third quantile.
• ### mean

public static double mean(int[] x)
Returns the mean of an array.
Parameters:
`x` - the array.
Returns:
the mean.
• ### mean

public static double mean(float[] x)
Returns the mean of an array.
Parameters:
`x` - the array.
Returns:
the mean.
• ### mean

public static double mean(double[] x)
Returns the mean of an array.
Parameters:
`x` - the array.
Returns:
the mean.
• ### var

public static double var(int[] x)
Returns the variance of an array.
Parameters:
`x` - the array.
Returns:
the variance.
• ### var

public static double var(float[] x)
Returns the variance of an array.
Parameters:
`x` - the array.
Returns:
the variance.
• ### var

public static double var(double[] x)
Returns the variance of an array.
Parameters:
`x` - the array.
Returns:
the variance.
• ### sd

public static double sd(int[] x)
Returns the standard deviation of an array.
Parameters:
`x` - the array.
Returns:
the standard deviation.
• ### sd

public static double sd(float[] x)
Returns the standard deviation of an array.
Parameters:
`x` - the array.
Returns:
the standard deviation.
• ### sd

public static double sd(double[] x)
Returns the standard deviation of an array.
Parameters:
`x` - the array.
Returns:
the standard deviation.
• ### mad

public static double mad(int[] x)
Returns the median absolute deviation (MAD). Note that input array will be altered after the computation. MAD is a robust measure of the variability of a univariate sample of quantitative data. For a univariate data set X1, X2, ..., Xn, the MAD is defined as the median of the absolute deviations from the data's median:

MAD(X) = median(|Xi - median(Xi)|)

that is, starting with the residuals (deviations) from the data's median, the MAD is the median of their absolute values.

MAD is a more robust estimator of scale than the sample variance or standard deviation. For instance, MAD is more resilient to outliers in a data set than the standard deviation. It thus behaves better with distributions without a mean or variance, such as the Cauchy distribution.

In order to use the MAD as a consistent estimator for the estimation of the standard deviation σ, one takes σ = K * MAD, where K is a constant scale factor, which depends on the distribution. For normally distributed data K is taken to be 1.4826. Other distributions behave differently: for example for large samples from a uniform continuous distribution, this factor is about 1.1547.

Parameters:
`x` - the array.
Returns:
the median abolute deviation.
• ### mad

public static double mad(float[] x)
Returns the median absolute deviation (MAD). Note that input array will be altered after the computation. MAD is a robust measure of the variability of a univariate sample of quantitative data. For a univariate data set X1, X2, ..., Xn, the MAD is defined as the median of the absolute deviations from the data's median:

MAD(X) = median(|Xi - median(Xi)|)

that is, starting with the residuals (deviations) from the data's median, the MAD is the median of their absolute values.

MAD is a more robust estimator of scale than the sample variance or standard deviation. For instance, MAD is more resilient to outliers in a data set than the standard deviation. It thus behaves better with distributions without a mean or variance, such as the Cauchy distribution.

In order to use the MAD as a consistent estimator for the estimation of the standard deviation σ, one takes σ = K * MAD, where K is a constant scale factor, which depends on the distribution. For normally distributed data K is taken to be 1.4826. Other distributions behave differently: for example for large samples from a uniform continuous distribution, this factor is about 1.1547.

Parameters:
`x` - the array.
Returns:
the median abolute deviation.
• ### mad

public static double mad(double[] x)
Returns the median absolute deviation (MAD). Note that input array will be altered after the computation. MAD is a robust measure of the variability of a univariate sample of quantitative data. For a univariate data set X1, X2, ..., Xn, the MAD is defined as the median of the absolute deviations from the data's median:

MAD(X) = median(|Xi - median(Xi)|)

that is, starting with the residuals (deviations) from the data's median, the MAD is the median of their absolute values.

MAD is a more robust estimator of scale than the sample variance or standard deviation. For instance, MAD is more resilient to outliers in a data set than the standard deviation. It thus behaves better with distributions without a mean or variance, such as the Cauchy distribution.

In order to use the MAD as a consistent estimator for the estimation of the standard deviation σ, one takes σ = K * MAD, where K is a constant scale factor, which depends on the distribution. For normally distributed data K is taken to be 1.4826. Other distributions behave differently: for example for large samples from a uniform continuous distribution, this factor is about 1.1547.

Parameters:
`x` - the array.
Returns:
the median abolute deviation.
• ### distance

public static double distance(int[] x, int[] y)
The Euclidean distance on binary sparse arrays, which are the indices of nonzero elements in ascending order.
Parameters:
`x` - a binary sparse vector.
`y` - a binary sparse vector.
Returns:
the Euclidean distance.
• ### distance

public static double distance(float[] x, float[] y)
The Euclidean distance.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the Euclidean distance.
• ### distance

public static double distance(double[] x, double[] y)
The Euclidean distance.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the Euclidean distance.
• ### distance

public static double distance
The Euclidean distance.
Parameters:
`x` - a sparse vector.
`y` - a sparse vector.
Returns:
the Euclidean distance.
• ### squaredDistance

public static double squaredDistance(int[] x, int[] y)
The squared Euclidean distance on binary sparse arrays, which are the indices of nonzero elements in ascending order.
Parameters:
`x` - a binary sparse vector.
`y` - a binary sparse vector.
Returns:
the square of Euclidean distance.
• ### squaredDistance

public static double squaredDistance(float[] x, float[] y)
The squared Euclidean distance.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the square of Euclidean distance.
• ### squaredDistance

public static double squaredDistance(double[] x, double[] y)
The squared Euclidean distance.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the square of Euclidean distance.
• ### squaredDistance

public static double squaredDistance
The Euclidean distance on sparse arrays.
Parameters:
`x` - a sparse vector.
`y` - a sparse vector.
Returns:
the square of Euclidean distance.
• ### squaredDistanceWithMissingValues

public static double squaredDistanceWithMissingValues(double[] x, double[] y)
The squared Euclidean distance with handling missing values (represented as NaN). NaN will be treated as missing values and will be excluded from the calculation. Let m be the number nonmissing values, and n be the number of all values. The returned distance is (n * d / m), where d is the square of distance between nonmissing values.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the square of Euclidean distance.
• ### pdist

public static Matrix pdist(int[][] x)
Returns the pairwise distance matrix of multiple binary sparse vectors.
Parameters:
`x` - binary sparse vectors, which are the indices of nonzero elements in ascending order.
Returns:
the full pairwise distance matrix.
• ### pdist

public static Matrix pdist(int[][] x, boolean squared)
Returns the pairwise distance matrix of multiple binary sparse vectors.
Parameters:
`x` - binary sparse vectors, which are the indices of nonzero elements in ascending order.
`squared` - If true, compute the squared Euclidean distance.
Returns:
the pairwise distance matrix.
• ### pdist

public static Matrix pdist(float[][] x)
Returns the pairwise distance matrix of multiple vectors.
Parameters:
`x` - the vectors.
Returns:
the full pairwise distance matrix.
• ### pdist

public static Matrix pdist(float[][] x, boolean squared)
Returns the pairwise distance matrix of multiple vectors.
Parameters:
`x` - the vectors.
`squared` - If true, compute the squared Euclidean distance.
Returns:
the pairwise distance matrix.
• ### pdist

public static Matrix pdist(double[][] x)
Returns the pairwise distance matrix of multiple vectors.
Parameters:
`x` - the vectors.
Returns:
the full pairwise distance matrix.
• ### pdist

public static Matrix pdist(double[][] x, boolean squared)
Returns the pairwise distance matrix of multiple vectors.
Parameters:
`x` - the vectors.
`squared` - If true, compute the squared Euclidean distance.
Returns:
the pairwise distance matrix.
• ### pdist

public static Matrix pdist(SparseArray[] x)
Returns the pairwise distance matrix of multiple vectors.
Parameters:
`x` - the vectors.
Returns:
the full pairwise distance matrix.
• ### pdist

public static Matrix pdist(SparseArray[] x, boolean squared)
Returns the pairwise distance matrix of multiple vectors.
Parameters:
`x` - the vectors.
`squared` - If true, compute the squared Euclidean distance.
Returns:
the pairwise distance matrix.
• ### pdist

public static <T> void pdist(T[] x, double[][] d, Distance<T> distance)
Computes the pairwise distance matrix of multiple vectors.
Type Parameters:
`T` - the data type of vectors.
Parameters:
`x` - the vectors.
`d` - The output distance matrix. It may be only the lower half.
`distance` - the distance lambda.
• ### entropy

public static double entropy(double[] p)
Shannon's entropy.
Parameters:
`p` - the probabilities.
Returns:
Shannon's entropy.
• ### KullbackLeiblerDivergence

public static double KullbackLeiblerDivergence(double[] p, double[] q)
Kullback-Leibler divergence. The Kullback-Leibler divergence (also information divergence, information gain, relative entropy, or KLIC) is a non-symmetric measure of the difference between two probability distributions P and Q. KL measures the expected number of extra bits required to code samples from P when using a code based on Q, rather than using a code based on P. Typically P represents the "true" distribution of data, observations, or a precise calculated theoretical distribution. The measure Q typically represents a theory, model, description, or approximation of P.

Although it is often intuited as a distance metric, the KL divergence is not a true metric - for example, the KL from P to Q is not necessarily the same as the KL from Q to P.

Parameters:
`p` - a probability distribution.
`q` - a probability distribution.
Returns:
Kullback-Leibler divergence
• ### KullbackLeiblerDivergence

public static double KullbackLeiblerDivergence
Kullback-Leibler divergence. The Kullback-Leibler divergence (also information divergence, information gain, relative entropy, or KLIC) is a non-symmetric measure of the difference between two probability distributions P and Q. KL measures the expected number of extra bits required to code samples from P when using a code based on Q, rather than using a code based on P. Typically P represents the "true" distribution of data, observations, or a precise calculated theoretical distribution. The measure Q typically represents a theory, model, description, or approximation of P.

Although it is often intuited as a distance metric, the KL divergence is not a true metric - for example, the KL from P to Q is not necessarily the same as the KL from Q to P.

Parameters:
`p` - a probability distribution.
`q` - a probability distribution.
Returns:
Kullback-Leibler divergence
• ### KullbackLeiblerDivergence

public static double KullbackLeiblerDivergence(double[] p, SparseArray q)
Kullback-Leibler divergence. The Kullback-Leibler divergence (also information divergence, information gain, relative entropy, or KLIC) is a non-symmetric measure of the difference between two probability distributions P and Q. KL measures the expected number of extra bits required to code samples from P when using a code based on Q, rather than using a code based on P. Typically P represents the "true" distribution of data, observations, or a precise calculated theoretical distribution. The measure Q typically represents a theory, model, description, or approximation of P.

Although it is often intuited as a distance metric, the KL divergence is not a true metric - for example, the KL from P to Q is not necessarily the same as the KL from Q to P.

Parameters:
`p` - a probability distribution.
`q` - a probability distribution.
Returns:
Kullback-Leibler divergence
• ### KullbackLeiblerDivergence

public static double KullbackLeiblerDivergence(SparseArray p, double[] q)
Kullback-Leibler divergence. The Kullback-Leibler divergence (also information divergence, information gain, relative entropy, or KLIC) is a non-symmetric measure of the difference between two probability distributions P and Q. KL measures the expected number of extra bits required to code samples from P when using a code based on Q, rather than using a code based on P. Typically P represents the "true" distribution of data, observations, or a precise calculated theoretical distribution. The measure Q typically represents a theory, model, description, or approximation of P.

Although it is often intuited as a distance metric, the KL divergence is not a true metric - for example, the KL from P to Q is not necessarily the same as the KL from Q to P.

Parameters:
`p` - a probability distribution.
`q` - a probability distribution.
Returns:
Kullback-Leibler divergence
• ### JensenShannonDivergence

public static double JensenShannonDivergence(double[] p, double[] q)
Jensen-Shannon divergence JS(P||Q) = (KL(P||M) + KL(Q||M)) / 2, where M = (P+Q)/2. The Jensen-Shannon divergence is a popular method of measuring the similarity between two probability distributions. It is also known as information radius or total divergence to the average. It is based on the Kullback-Leibler divergence, with the difference that it is always a finite value. The square root of the Jensen-Shannon divergence is a metric.
Parameters:
`p` - a probability distribution.
`q` - a probability distribution.
Returns:
Jensen-Shannon divergence
• ### JensenShannonDivergence

public static double JensenShannonDivergence
Jensen-Shannon divergence JS(P||Q) = (KL(P||M) + KL(Q||M)) / 2, where M = (P+Q)/2. The Jensen-Shannon divergence is a popular method of measuring the similarity between two probability distributions. It is also known as information radius or total divergence to the average. It is based on the Kullback-Leibler divergence, with the difference that it is always a finite value. The square root of the Jensen-Shannon divergence is a metric.
Parameters:
`p` - a probability distribution.
`q` - a probability distribution.
Returns:
Jensen-Shannon divergence
• ### JensenShannonDivergence

public static double JensenShannonDivergence(double[] p, SparseArray q)
Jensen-Shannon divergence JS(P||Q) = (KL(P||M) + KL(Q||M)) / 2, where M = (P+Q)/2. The Jensen-Shannon divergence is a popular method of measuring the similarity between two probability distributions. It is also known as information radius or total divergence to the average. It is based on the Kullback-Leibler divergence, with the difference that it is always a finite value. The square root of the Jensen-Shannon divergence is a metric.
Parameters:
`p` - a probability distribution.
`q` - a probability distribution.
Returns:
Jensen-Shannon divergence
• ### JensenShannonDivergence

public static double JensenShannonDivergence(SparseArray p, double[] q)
Jensen-Shannon divergence JS(P||Q) = (KL(P||M) + KL(Q||M)) / 2, where M = (P+Q)/2. The Jensen-Shannon divergence is a popular method of measuring the similarity between two probability distributions. It is also known as information radius or total divergence to the average. It is based on the Kullback-Leibler divergence, with the difference that it is always a finite value. The square root of the Jensen-Shannon divergence is a metric.
Parameters:
`p` - a probability distribution.
`q` - a probability distribution.
Returns:
Jensen-Shannon divergence
• ### dot

public static int dot(int[] x, int[] y)
Returns the dot product between two binary sparse arrays, which are the indices of nonzero elements in ascending order.
Parameters:
`x` - a binary sparse vector.
`y` - a binary sparse vector.
Returns:
the dot product.
• ### dot

public static float dot(float[] x, float[] y)
Returns the dot product between two vectors.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the dot product.
• ### dot

public static double dot(double[] x, double[] y)
Returns the dot product between two vectors.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the dot product.
• ### dot

public static double dot
Returns the dot product between two sparse arrays.
Parameters:
`x` - a sparse vector.
`y` - a sparse vector.
Returns:
the dot product.
• ### pdot

public static Matrix pdot(int[][] x)
Returns the pairwise dot product matrix of binary sparse vectors.
Parameters:
`x` - the binary sparse vectors, which are the indices of nonzero elements in ascending order.
Returns:
the dot product matrix.
• ### pdot

public static Matrix pdot(float[][] x)
Returns the pairwise dot product matrix of float vectors.
Parameters:
`x` - the vectors.
Returns:
the dot product matrix.
• ### pdot

public static Matrix pdot(double[][] x)
Returns the pairwise dot product matrix of double vectors.
Parameters:
`x` - the vectors.
Returns:
the dot product matrix.
• ### pdot

public static Matrix pdot(SparseArray[] x)
Returns the pairwise dot product matrix of multiple vectors.
Parameters:
`x` - the sparse vectors.
Returns:
the dot product matrix.
• ### cov

public static double cov(int[] x, int[] y)
Returns the covariance between two vectors.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the covariance.
• ### cov

public static double cov(float[] x, float[] y)
Returns the covariance between two vectors.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the covariance.
• ### cov

public static double cov(double[] x, double[] y)
Returns the covariance between two vectors.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the covariance.
• ### cov

public static double[][] cov(double[][] data)
Returns the sample covariance matrix.
Parameters:
`data` - the samples
Returns:
the covariance matrix.
• ### cov

public static double[][] cov(double[][] data, double[] mu)
Returns the sample covariance matrix.
Parameters:
`data` - the samples
`mu` - the known mean of data.
Returns:
the covariance matrix.
• ### cor

public static double cor(int[] x, int[] y)
Returns the correlation coefficient between two vectors.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the correlation coefficient.
• ### cor

public static double cor(float[] x, float[] y)
Returns the correlation coefficient between two vectors.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the correlation coefficient.
• ### cor

public static double cor(double[] x, double[] y)
Returns the correlation coefficient between two vectors.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the correlation coefficient.
• ### cor

public static double[][] cor(double[][] data)
Returns the sample correlation matrix.
Parameters:
`data` - the samples
Returns:
the correlation matrix.
• ### cor

public static double[][] cor(double[][] data, double[] mu)
Returns the sample correlation matrix.
Parameters:
`data` - the samples
`mu` - the known mean of data.
Returns:
the correlation matrix.
• ### spearman

public static double spearman(int[] x, int[] y)
The Spearman Rank Correlation Coefficient is a form of the Pearson coefficient with the data converted to rankings (i.e. when variables are ordinal). It can be used when there is non-parametric data and hence Pearson cannot be used.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the Spearman rank correlation coefficient.
• ### spearman

public static double spearman(float[] x, float[] y)
The Spearman Rank Correlation Coefficient is a form of the Pearson coefficient with the data converted to rankings (i.e. when variables are ordinal). It can be used when there is non-parametric data and hence Pearson cannot be used.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the Spearman rank correlation coefficient.
• ### spearman

public static double spearman(double[] x, double[] y)
The Spearman Rank Correlation Coefficient is a form of the Pearson coefficient with the data converted to rankings (i.e. when variables are ordinal). It can be used when there is non-parametric data and hence Pearson cannot be used.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the Spearman rank correlation coefficient.
• ### kendall

public static double kendall(int[] x, int[] y)
The Kendall Tau Rank Correlation Coefficient is used to measure the degree of correspondence between sets of rankings where the measures are not equidistant. It is used with non-parametric data.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the Kendall rank correlation coefficient.
• ### kendall

public static double kendall(float[] x, float[] y)
The Kendall Tau Rank Correlation Coefficient is used to measure the degree of correspondence between sets of rankings where the measures are not equidistant. It is used with non-parametric data.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the Kendall rank correlation coefficient.
• ### kendall

public static double kendall(double[] x, double[] y)
The Kendall Tau Rank Correlation Coefficient is used to measure the degree of correspondence between sets of rankings where the measures are not equidistant. It is used with non-parametric data.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the Kendall rank correlation coefficient.
• ### norm1

public static float norm1(float[] x)
L1 vector norm.
Parameters:
`x` - a vector.
Returns:
L1 norm.
• ### norm1

public static double norm1(double[] x)
L1 vector norm.
Parameters:
`x` - a vector.
Returns:
L1 norm.
• ### norm2

public static float norm2(float[] x)
L2 vector norm.
Parameters:
`x` - a vector.
Returns:
L2 norm.
• ### norm2

public static double norm2(double[] x)
L2 vector norm.
Parameters:
`x` - a vector.
Returns:
L2 norm.
• ### normInf

public static float normInf(float[] x)
L vector norm that is the maximum absolute value.
Parameters:
`x` - a vector.
Returns:
L norm.
• ### normInf

public static double normInf(double[] x)
L vector norm. Maximum absolute value.
Parameters:
`x` - a vector.
Returns:
L norm.
• ### norm

public static float norm(float[] x)
L2 vector norm.
Parameters:
`x` - a vector.
Returns:
L2 norm.
• ### norm

public static double norm(double[] x)
L2 vector norm.
Parameters:
`x` - a vector.
Returns:
L2 norm.
• ### cos

public static float cos(float[] x, float[] y)
Returns the cosine similarity.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the cosine similarity.
• ### cos

public static double cos(double[] x, double[] y)
Returns the cosine similarity.
Parameters:
`x` - a vector.
`y` - a vector.
Returns:
the cosine similarity.
• ### standardize

public static void standardize(double[] x)
Standardizes an array to mean 0 and variance 1.
Parameters:
`x` - the matrix.
• ### scale

public static void scale(double[][] x)
Scales each column of a matrix to range [0, 1].
Parameters:
`x` - the matrix.
• ### standardize

public static void standardize(double[][] x)
Standardizes each column of a matrix to 0 mean and unit variance.
Parameters:
`x` - the matrix.
• ### normalize

public static void normalize(double[][] x)
Unitizes each column of a matrix to unit length (L_2 norm).
Parameters:
`x` - the matrix.
• ### normalize

public static void normalize(double[][] x, boolean centerizing)
Unitizes each column of a matrix to unit length (L_2 norm).
Parameters:
`x` - the matrix.
`centerizing` - If true, centerize each column to 0 mean.
• ### unitize

public static void unitize(double[] x)
Unitize an array so that L2 norm of x = 1.
Parameters:
`x` - the vector.
• ### unitize1

public static void unitize1(double[] x)
Unitize an array so that L1 norm of x is 1.
Parameters:
`x` - the vector.
• ### unitize2

public static void unitize2(double[] x)
Unitize an array so that L2 norm of x = 1.
Parameters:
`x` - the vector.
• ### equals

public static boolean equals(float[] x, float[] y)
Check if x element-wisely equals y with default epsilon 1E-7.
Parameters:
`x` - an array.
`y` - an array.
Returns:
true if x element-wisely equals y.
• ### equals

public static boolean equals(float[] x, float[] y, float epsilon)
Check if x element-wisely equals y in given precision.
Parameters:
`x` - an array.
`y` - an array.
`epsilon` - a number close to zero.
Returns:
true if x element-wisely equals y.
• ### equals

public static boolean equals(double[] x, double[] y)
Check if x element-wisely equals y with default epsilon 1E-10.
Parameters:
`x` - an array.
`y` - an array.
Returns:
true if x element-wisely equals y.
• ### equals

public static boolean equals(double[] x, double[] y, double epsilon)
Check if x element-wisely equals y in given precision.
Parameters:
`x` - an array.
`y` - an array.
`epsilon` - a number close to zero.
Returns:
true if x element-wisely equals y.
• ### equals

public static boolean equals(float[][] x, float[][] y)
Check if x element-wisely equals y with default epsilon 1E-7.
Parameters:
`x` - a two-dimensional array.
`y` - a two-dimensional array.
Returns:
true if x element-wisely equals y.
• ### equals

public static boolean equals(float[][] x, float[][] y, float epsilon)
Check if x element-wisely equals y in given precision.
Parameters:
`x` - a two-dimensional array.
`y` - a two-dimensional array.
`epsilon` - a number close to zero.
Returns:
true if x element-wisely equals y.
• ### equals

public static boolean equals(double[][] x, double[][] y)
Check if x element-wisely equals y with default epsilon 1E-10.
Parameters:
`x` - a two-dimensional array.
`y` - a two-dimensional array.
Returns:
true if x element-wisely equals y.
• ### equals

public static boolean equals(double[][] x, double[][] y, double epsilon)
Check if x element-wisely equals y in given precision.
Parameters:
`x` - a two-dimensional array.
`y` - a two-dimensional array.
`epsilon` - a number close to zero.
Returns:
true if x element-wisely equals y.
• ### isZero

public static boolean isZero(float x)
Tests if a floating number is zero in machine precision.
Parameters:
`x` - a real number.
Returns:
true if x is zero in machine precision.
• ### isZero

public static boolean isZero(float x, float epsilon)
Tests if a floating number is zero in given precision.
Parameters:
`x` - a real number.
`epsilon` - a number close to zero.
Returns:
true if x is zero in `epsilon` precision.
• ### isZero

public static boolean isZero(double x)
Tests if a floating number is zero in machine precision.
Parameters:
`x` - a real number.
Returns:
true if x is zero in machine precision.
• ### isZero

public static boolean isZero(double x, double epsilon)
Tests if a floating number is zero in given precision.
Parameters:
`x` - a real number.
`epsilon` - a number close to zero.
Returns:
true if x is zero in `epsilon` precision.
• ### clone

public static int[][] clone(int[][] x)
Deep clone a two-dimensional array.
Parameters:
`x` - a two-dimensional array.
Returns:
the deep clone.
• ### clone

public static float[][] clone(float[][] x)
Deep clone a two-dimensional array.
Parameters:
`x` - a two-dimensional array.
Returns:
the deep clone.
• ### clone

public static double[][] clone(double[][] x)
Deep clone a two-dimensional array.
Parameters:
`x` - a two-dimensional array.
Returns:
the deep clone.
• ### swap

public static void swap(int[] x, int i, int j)
Swap two elements of an array.
Parameters:
`x` - an array.
`i` - the index of first element.
`j` - the index of second element.
• ### swap

public static void swap(float[] x, int i, int j)
Swap two elements of an array.
Parameters:
`x` - an array.
`i` - the index of first element.
`j` - the index of second element.
• ### swap

public static void swap(double[] x, int i, int j)
Swap two elements of an array.
Parameters:
`x` - an array.
`i` - the index of first element.
`j` - the index of second element.
• ### swap

public static void swap(Object[] x, int i, int j)
Swap two elements of an array.
Parameters:
`x` - an array.
`i` - the index of first element.
`j` - the index of second element.
• ### swap

public static void swap(int[] x, int[] y)
Swap two arrays.
Parameters:
`x` - an array.
`y` - the other array.
• ### swap

public static void swap(float[] x, float[] y)
Swap two arrays.
Parameters:
`x` - an array.
`y` - the other array.
• ### swap

public static void swap(double[] x, double[] y)
Swap two arrays.
Parameters:
`x` - an array.
`y` - the other array.
• ### swap

public static <E> void swap(E[] x, E[] y)
Swap two arrays.
Type Parameters:
`E` - the data type of array elements.
Parameters:
`x` - an array.
`y` - the other array.
• ### copy

public static void copy(int[][] x, int[][] y)
Copy x into y.
Parameters:
`x` - the input matrix.
`y` - the output matrix.
• ### copy

public static void copy(float[][] x, float[][] y)
Deep copy x into y.
Parameters:
`x` - the input matrix.
`y` - the output matrix.
• ### copy

public static void copy(double[][] x, double[][] y)
Deep copy x into y.
Parameters:
`x` - the input matrix.
`y` - the output matrix.
• ### add

public static void add(double[] y, double[] x)
Element-wise sum of two arrays y = x + y.
Parameters:
`y` - avector.
`x` - a vector.
• ### sub

public static void sub(double[] y, double[] x)
Element-wise subtraction of two arrays y = y - x.
Parameters:
`y` - the minuend array.
`x` - the subtrahend array.
• ### scale

public static void scale(double a, double[] x)
Scale each element of an array by a constant x = a * x.
Parameters:
`a` - the scale factor.
`x` - the input and output vector.
• ### scale

public static void scale(double a, double[] x, double[] y)
Scale each element of an array by a constant y = a * x.
Parameters:
`a` - the scale factor.
`x` - a vector.
`y` - the output vector.
• ### axpy

public static double[] axpy(double a, double[] x, double[] y)
Update an array by adding a multiple of another array y = a * x + y.
Parameters:
`a` - the scale factor.
`x` - a vector.
`y` - the input and output vector.
Returns:
the vector y.
• ### pow

public static double[] pow(double[] x, double n)
Raise each element of an array to a scalar power.
Parameters:
`x` - the base array.
`n` - the scalar exponent.
Returns:
xn
• ### unique

public static int[] unique(int[] x)
Find unique elements of vector.
Parameters:
`x` - an integer array.
Returns:
the same values as in x but with no repetitions.
• ### unique

public static String[] unique(String[] x)
Find unique elements of vector.
Parameters:
`x` - an array of strings.
Returns:
the same values as in x but with no repetitions.
• ### sort

public static int[][] sort(double[][] x)
Sorts each variable and returns the index of values in ascending order. Note that the order of original array is NOT altered.
Parameters:
`x` - a set of variables to be sorted. Each row is an instance. Each column is a variable.
Returns:
the index of values in ascending order
• ### solve

public static double[] solve(double[] a, double[] b, double[] c, double[] r)
Solve the tridiagonal linear set which is of diagonal dominance |bi| `>` |ai| + |ci|.
```     | b0 c0  0  0  0 ...                        |
| a1 b1 c1  0  0 ...                        |
|  0 a2 b2 c2  0 ...                        |
|                ...                        |
|                ... a(n-2)  b(n-2)  c(n-2) |
|                ... 0       a(n-1)  b(n-1) |
```
Parameters:
`a` - the lower part of tridiagonal matrix. a[0] is undefined and not referenced by the method.
`b` - the diagonal of tridiagonal matrix.
`c` - the upper of tridiagonal matrix. c[n-1] is undefined and not referenced by the method.
`r` - the right-hand side of linear equations.
Returns:
the solution.