MathEx

java.lang.Object
- smile.math.MathEx

```
public class MathEx
extends java.lang.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, L₁ norm, L₂ 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 and Description
`static int`	`DIGITS` The number of digits (in radix base) in the mantissa.
`static 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 int`	`FLOAT_DIGITS` The number of digits (in radix base) in the mantissa.
`static 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 int`	`FLOAT_MACHEP` The largest negative integer such that 1.0 + RADIX^MACHEP ≠ 1.0, except that machep is bounded below by -(DIGITS+3)
`static int`	`FLOAT_NEGEP` The largest negative integer such that 1.0 - RADIX^NEGEP ≠ 1.0, except that negeps is bounded below by -(DIGITS+3)
`static int`	`MACHEP` The largest negative integer such that 1.0 + RADIX^MACHEP ≠ 1.0, except that machep is bounded below by -(DIGITS+3)
`static int`	`NEGEP` The largest negative integer such that 1.0 - RADIX^NEGEP ≠ 1.0, except that negeps is bounded below by -(DIGITS+3)
`static int`	`RADIX` The base of the exponent of the double type.
`static int`	`ROUND_STYLE` Rounding style.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`add(double[] y, double[] x)` Element-wise sum of two arrays y = x + y.
`static boolean`	`all(boolean[] x)` Given a set of boolean values, are all of the values true?
`static boolean`	`any(boolean[] x)` Given a set of boolean values, is at least one of the values true?
`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)` Merges multiple vectors into one.
`static float[]`	`c(float... x)` Combines the arguments to form a vector.
`static float[]`	`c(float[]... list)` Merges multiple vectors into one.
`static int[]`	`c(int... x)` Combines the arguments to form a vector.
`static int[]`	`c(int[]... list)` Merges multiple vectors into one.
`static java.lang.String[]`	`c(java.lang.String... x)` Combines the arguments to form a vector.
`static java.lang.String[]`	`c(java.lang.String[]... list)` Concatenates multiple vectors into one array of strings.
`static double[]`	`cbind(double[]... x)` Take a sequence of vector arguments and combine by columns.
`static float[]`	`cbind(float[]... x)` Take a sequence of vector arguments and combine by columns.
`static int[]`	`cbind(int[]... x)` Take a sequence of vector arguments and combine by columns.
`static java.lang.String[]`	`cbind(java.lang.String[]... x)` Take a sequence of vector arguments and combine 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[][] data)` Returns the column maximum for a matrix.
`static int[]`	`colMax(int[][] data)` Returns the column maximum for a matrix.
`static double[]`	`colMeans(double[][] data)` Returns the column means for a matrix.
`static double[]`	`colMin(double[][] data)` Returns the column minimum for a matrix.
`static int[]`	`colMin(int[][] data)` Returns the column minimum for a matrix.
`static double[]`	`colSds(double[][] data)` Returns the column deviations for a matrix.
`static double[]`	`colSums(double[][] data)` Returns the column sums for a matrix.
`static long[]`	`colSums(int[][] data)` Returns the column sums for a matrix.
`static boolean`	`contains(double[][] polygon, double[] point)` Determines if the polygon contains the specified coordinates.
`static boolean`	`contains(double[][] polygon, double x, double y)` Determines if the polygon contains the specified coordinates.
`static void`	`copy(double[][] x, double[][] y)` Copy x into y.
`static void`	`copy(double[] x, double[] y)` Copy x into y.
`static void`	`copy(float[][] x, float[][] y)` Copy x into y.
`static void`	`copy(float[] x, float[] y)` Copy x into y.
`static void`	`copy(int[][] x, int[][] y)` 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 eps)` Check if x element-wisely equals y.
`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 eps)` Check if x element-wisely equals y.
`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.
`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.
`static double`	`factorial(int n)` The factorial of n.
`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.
`static boolean`	`isZero(double x, double epsilon)` Tests if a floating number is zero with given epsilon.
`static boolean`	`isZero(float x)` Tests if a floating number is zero.
`static boolean`	`isZero(float x, float epsilon)` Tests if a floating number is zero with given epsilon.
`static double`	`JensenShannonDivergence(double[] x, double[] y)` Jensen-Shannon divergence JS(P\|\|Q) = (KL(P\|\|M) + KL(Q\|\|M)) / 2, where M = (P+Q)/2.
`static double`	`JensenShannonDivergence(double[] x, SparseArray y)` Jensen-Shannon divergence JS(P\|\|Q) = (KL(P\|\|M) + KL(Q\|\|M)) / 2, where M = (P+Q)/2.
`static double`	`JensenShannonDivergence(SparseArray x, double[] y)` Jensen-Shannon divergence JS(P\|\|Q) = (KL(P\|\|M) + KL(Q\|\|M)) / 2, where M = (P+Q)/2.
`static double`	`JensenShannonDivergence(SparseArray x, SparseArray y)` 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[] x, double[] y)` Kullback-Leibler divergence.
`static double`	`KullbackLeiblerDivergence(double[] x, SparseArray y)` Kullback-Leibler divergence.
`static double`	`KullbackLeiblerDivergence(SparseArray x, double[] y)` Kullback-Leibler divergence.
`static double`	`KullbackLeiblerDivergence(SparseArray x, SparseArray y)` 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`	`logistic(double x)` Logistic sigmoid function.
`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)` maximum of 3 doubles
`static double`	`max(double a, double b, double c, double d)` maximum of 4 doubles
`static float`	`max(float[] x)` Returns the maximum value of an array.
`static float`	`max(float a, float b, float c)` maximum of 3 floats
`static float`	`max(float a, float b, float c, float d)` maximum of 4 floats
`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)` maximum of 3 integers
`static int`	`max(int a, int b, int c, int d)` maximum of 4 integers
`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[] a)` Find the median of an array of type double.
`static float`	`median(float[] a)` Find the median of an array of type float.
`static int`	`median(int[] a)` Find the median of an array of type int.
`static <T extends java.lang.Comparable<? super T>> T`	`median(T[] a)` 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)` minimum of 3 doubles
`static double`	`min(double a, double b, double c, double d)` minimum of 4 doubles
`static float`	`min(float[] x)` Returns the minimum value of an array.
`static double`	`min(float a, float b, float c)` minimum of 3 floats
`static double`	`min(float a, float b, float c, float d)` minimum of 4 floats
`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)` minimum of 3 integers
`static int`	`min(int a, int b, int c, int d)` minimum of 4 integers
`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-infinity vector norm.
`static float`	`normInf(float[] x)` L-infinity vector norm.
`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)` Generates a permutation of given array.
`static void`	`permutate(float[] x)` Generates a permutation of given array.
`static int[]`	`permutate(int n)` Generates a permutation of 0, 1, 2, ..., n-1, which is useful for sampling without replacement.
`static void`	`permutate(int[] x)` Generates a permutation of given array.
`static void`	`permutate(java.lang.Object[] x)` Generates a permutation of given array.
`static double[]`	`pow(double[] x, double n)` Raise each element of an array to a scalar power.
`static long`	`probablePrime(long n, int k)` Returns a probably prime number greater than n.
`static double`	`q1(double[] a)` Find the first quantile (p = 1/4) of an array of type double.
`static float`	`q1(float[] a)` Find the first quantile (p = 1/4) of an array of type float.
`static int`	`q1(int[] a)` Find the first quantile (p = 1/4) of an array of type int.
`static <T extends java.lang.Comparable<? super T>> T`	`q1(T[] a)` Find the first quantile (p = 1/4) of an array of type double.
`static double`	`q3(double[] a)` Find the third quantile (p = 3/4) of an array of type double.
`static float`	`q3(float[] a)` Find the third quantile (p = 3/4) of an array of type float.
`static int`	`q3(int[] a)` Find the third quantile (p = 3/4) of an array of type int.
`static <T extends java.lang.Comparable<? super T>> T`	`q3(T[] a)` 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 n 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)` Take a sequence of vector arguments and combine by rows.
`static float[][]`	`rbind(float[]... x)` Take a sequence of vector arguments and combine by rows.
`static int[][]`	`rbind(int[]... x)` Take a sequence of vector arguments and combine by rows.
`static java.lang.String[][]`	`rbind(java.lang.String[]... x)` Take a sequence of vector arguments and combine 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[][] data)` Returns the row maximum for a matrix.
`static int[]`	`rowMax(int[][] data)` Returns the row maximum for a matrix.
`static double[]`	`rowMeans(double[][] data)` Returns the row means for a matrix.
`static double[]`	`rowMin(double[][] data)` Returns the row minimum for a matrix.
`static int[]`	`rowMin(int[][] data)` Returns the row minimum for a matrix.
`static double[]`	`rowSds(double[][] data)` Returns the row standard deviations for a matrix.
`static double[]`	`rowSums(double[][] data)` Returns the row sums for a matrix.
`static long[]`	`rowSums(int[][] data)` Returns the row sums for 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 java.util.stream.LongStream`	`seeds(long n, int k)` Returns a stream of prime numbers to be used as RNG seeds.
`static void`	`setSeed()` Initialize the random generator with a random seed from a cryptographically strong random number generator.
`static void`	`setSeed(long seed)` Initialize the random generator with a seed.
`static double[]`	`slice(double[] 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 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 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
`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 (ie.
`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 (ie.
`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 (ie.
`static double`	`sqr(double x)` Returns x * x.
`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 <E> void`	`swap(E[] x, E[] y)` Swap two arrays.
`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 void`	`swap(java.lang.Object[] x, int i, int j)` Swap two elements of an array.
`static double`	`tanh(double x)` Hyperbolic tangent function.
`static double[][]`	`transpose(double[][] A)` Returns the matrix transpose.
`static int[]`	`unique(int[] x)` Find unique elements of vector.
`static java.lang.String[]`	`unique(java.lang.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[][] x)` Returns the index of maximum value of an array.
`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[][] x)` Returns the index of minimum value of an array.
`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 Detail
  - 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 + RADIX^MACHEP ≠ 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 + RADIX^MACHEP ≠ 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 - RADIX^NEGEP ≠ 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 - RADIX^NEGEP ≠ 1.0, except that negeps is bounded below by -(DIGITS+3)
- Method Detail
  - log2
```
public static double log2(double x)
```
    Log of base 2.
  - log
```
public static double log(double x)
```
    Returns natural log without underflow.
  - log1pe
```
public static double log1pe(double x)
```
    Returns natural log(1+exp(x)) without overflow.
  - isInt
```
public static boolean isInt(float x)
```
    Returns true if x is an integer.
  - isInt
```
public static boolean isInt(double x)
```
    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
  - logistic
```
public static double logistic(double x)
```
    Logistic sigmoid function.
  - tanh
```
public static double tanh(double x)
```
    Hyperbolic tangent function. The tanh function is a rescaling of the logistic sigmoid, such that its outputs range from -1 to 1.
  - sqr
```
public static double sqr(double x)
```
    Returns x * x.
  - isPower2
```
public static boolean isPower2(int x)
```
    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 - a parameter that determines the accuracy of the test
  - 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.
  - factorial
```
public static double factorial(int n)
```
    The factorial of n.
    
    Returns:
    
    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.
  - choose
```
public static double choose(int n,
                            int k)
```
    The n choose k. Returns 0 if n is less than k.
  - lchoose
```
public static double lchoose(int n,
                             int k)
```
    The log of n choose k.
  - setSeed
```
public static void setSeed(long seed)
```
    Initialize the random generator with a seed.
  - setSeed
```
public static void setSeed()
```
    Initialize the random generator with a random seed from a cryptographically strong random number generator.
  - 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 - a parameter that determines the accuracy of the primality test
  - seeds
```
public static java.util.stream.LongStream seeds(long n,
                                                int k)
```
    Returns a stream of prime numbers to be used as RNG seeds.
    
    Parameters:
    
    n - the returned value should be greater than n.
    
    k - a parameter that determines the accuracy of the primality test
  - 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.
    
    Returns:
    
    an random array of length n in range of [0, m).
  - random
```
public static double random()
```
    Generate a random number in [0, 1).
  - random
```
public static double[] random(int n)
```
    Generate n random numbers in [0, 1).
  - 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 real in the range [lo, hi)
  - random
```
public static double[] random(double lo,
                              double hi,
                              int n)
```
    Generate n uniform random numbers in the range [lo, hi).
    
    Parameters:
    
    n - size of the array
    
    lo - lower limit of range
    
    hi - upper limit of range
    
    Returns:
    
    a uniform random real in the range [lo, hi)
  - randomLong
```
public static long randomLong()
```
    Returns a random long integer.
  - randomInt
```
public static int randomInt(int n)
```
    Returns a random integer in [0, n).
  - randomInt
```
public static int randomInt(int lo,
                            int hi)
```
    Returns a random integer in [lo, hi).
  - permutate
```
public static int[] permutate(int n)
```
    Generates a permutation of 0, 1, 2, ..., n-1, which is useful for sampling without replacement.
  - permutate
```
public static void permutate(int[] x)
```
    Generates a permutation of given array.
  - permutate
```
public static void permutate(float[] x)
```
    Generates a permutation of given array.
  - permutate
```
public static void permutate(double[] x)
```
    Generates a permutation of given array.
  - permutate
```
public static void permutate(java.lang.Object[] x)
```
    Generates a permutation of given 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.
  - c
```
public static float[] c(float... x)
```
    Combines the arguments to form a vector.
  - c
```
public static double[] c(double... x)
```
    Combines the arguments to form a vector.
  - c
```
public static java.lang.String[] c(java.lang.String... x)
```
    Combines the arguments to form a vector.
  - c
```
public static int[] c(int[]... list)
```
    Merges multiple vectors into one.
  - c
```
public static float[] c(float[]... list)
```
    Merges multiple vectors into one.
  - c
```
public static double[] c(double[]... list)
```
    Merges multiple vectors into one.
  - c
```
public static java.lang.String[] c(java.lang.String[]... list)
```
    Concatenates multiple vectors into one array of strings.
  - cbind
```
public static int[] cbind(int[]... x)
```
    Take a sequence of vector arguments and combine by columns.
  - cbind
```
public static float[] cbind(float[]... x)
```
    Take a sequence of vector arguments and combine by columns.
  - cbind
```
public static double[] cbind(double[]... x)
```
    Take a sequence of vector arguments and combine by columns.
  - cbind
```
public static java.lang.String[] cbind(java.lang.String[]... x)
```
    Take a sequence of vector arguments and combine by columns.
  - rbind
```
public static int[][] rbind(int[]... x)
```
    Take a sequence of vector arguments and combine by rows.
  - rbind
```
public static float[][] rbind(float[]... x)
```
    Take a sequence of vector arguments and combine by rows.
  - rbind
```
public static double[][] rbind(double[]... x)
```
    Take a sequence of vector arguments and combine by rows.
  - rbind
```
public static java.lang.String[][] rbind(java.lang.String[]... x)
```
    Take a sequence of vector arguments and combine by rows.
  - slice
```
public static <E> E[] slice(E[] data,
                            int[] index)
```
    Returns a slice of data for given indices.
  - slice
```
public static int[] slice(int[] data,
                          int[] index)
```
    Returns a slice of data for given indices.
  - slice
```
public static float[] slice(float[] data,
                            int[] index)
```
    Returns a slice of data for given indices.
  - slice
```
public static double[] slice(double[] data,
                             int[] index)
```
    Returns a slice of data for given indices.
  - contains
```
public static boolean contains(double[][] polygon,
                               double[] point)
```
    Determines if the polygon contains the specified coordinates.
    
    Parameters:
    
    point - the coordinates of specified point to be tested.
    
    Returns:
    
    true if the Polygon contains the specified coordinates; false otherwise.
  - contains
```
public static boolean contains(double[][] polygon,
                               double x,
                               double y)
```
    Determines if the polygon contains the specified coordinates.
    
    Parameters:
    
    x - the specified x coordinate.
    
    y - the specified y coordinate.
    
    Returns:
    
    true if the Polygon contains the specified coordinates; false otherwise.
  - 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 - an array to reverse.
  - reverse
```
public static void reverse(double[] a)
```
    Reverses the order of the elements in the specified array.
    
    Parameters:
    
    a - an array to reverse.
  - reverse
```
public static <T> void reverse(T[] a)
```
    Reverses the order of the elements in the specified array.
    
    Parameters:
    
    a - an array to reverse.
  - min
```
public static int min(int a,
                      int b,
                      int c)
```
    minimum of 3 integers
  - min
```
public static double min(float a,
                         float b,
                         float c)
```
    minimum of 3 floats
  - min
```
public static double min(double a,
                         double b,
                         double c)
```
    minimum of 3 doubles
  - min
```
public static int min(int a,
                      int b,
                      int c,
                      int d)
```
    minimum of 4 integers
  - min
```
public static double min(float a,
                         float b,
                         float c,
                         float d)
```
    minimum of 4 floats
  - min
```
public static double min(double a,
                         double b,
                         double c,
                         double d)
```
    minimum of 4 doubles
  - max
```
public static int max(int a,
                      int b,
                      int c)
```
    maximum of 3 integers
  - max
```
public static float max(float a,
                        float b,
                        float c)
```
    maximum of 3 floats
  - max
```
public static double max(double a,
                         double b,
                         double c)
```
    maximum of 3 doubles
  - max
```
public static int max(int a,
                      int b,
                      int c,
                      int d)
```
    maximum of 4 integers
  - max
```
public static float max(float a,
                        float b,
                        float c,
                        float d)
```
    maximum of 4 floats
  - max
```
public static double max(double a,
                         double b,
                         double c,
                         double d)
```
    maximum of 4 doubles
  - min
```
public static int min(int[] x)
```
    Returns the minimum value of an array.
  - min
```
public static float min(float[] x)
```
    Returns the minimum value of an array.
  - min
```
public static double min(double[] x)
```
    Returns the minimum value of an array.
  - whichMin
```
public static int whichMin(int[] x)
```
    Returns the index of minimum value of an array.
  - whichMin
```
public static int whichMin(float[] x)
```
    Returns the index of minimum value of an array.
  - whichMin
```
public static int whichMin(double[] x)
```
    Returns the index of minimum value of an array.
  - whichMin
```
public static IntPair whichMin(double[][] x)
```
    Returns the index of minimum value of an array.
  - max
```
public static int max(int[] x)
```
    Returns the maximum value of an array.
  - max
```
public static float max(float[] x)
```
    Returns the maximum value of an array.
  - max
```
public static double max(double[] x)
```
    Returns the maximum value of an array.
  - whichMax
```
public static int whichMax(int[] x)
```
    Returns the index of maximum value of an array.
  - whichMax
```
public static int whichMax(float[] x)
```
    Returns the index of maximum value of an array.
  - whichMax
```
public static int whichMax(double[] x)
```
    Returns the index of maximum value of an array.
  - whichMax
```
public static IntPair whichMax(double[][] x)
```
    Returns the index of maximum value of an array.
  - min
```
public static int min(int[][] matrix)
```
    Returns the minimum of a matrix.
  - min
```
public static double min(double[][] matrix)
```
    Returns the minimum of a matrix.
  - max
```
public static int max(int[][] matrix)
```
    Returns the maximum of a matrix.
  - max
```
public static double max(double[][] matrix)
```
    Returns the maximum of a matrix.
  - transpose
```
public static double[][] transpose(double[][] A)
```
    Returns the matrix transpose.
  - rowMin
```
public static int[] rowMin(int[][] data)
```
    Returns the row minimum for a matrix.
  - rowMax
```
public static int[] rowMax(int[][] data)
```
    Returns the row maximum for a matrix.
  - rowSums
```
public static long[] rowSums(int[][] data)
```
    Returns the row sums for a matrix.
  - rowMin
```
public static double[] rowMin(double[][] data)
```
    Returns the row minimum for a matrix.
  - rowMax
```
public static double[] rowMax(double[][] data)
```
    Returns the row maximum for a matrix.
  - rowSums
```
public static double[] rowSums(double[][] data)
```
    Returns the row sums for a matrix.
  - rowMeans
```
public static double[] rowMeans(double[][] data)
```
    Returns the row means for a matrix.
  - rowSds
```
public static double[] rowSds(double[][] data)
```
    Returns the row standard deviations for a matrix.
  - colMin
```
public static int[] colMin(int[][] data)
```
    Returns the column minimum for a matrix.
  - colMax
```
public static int[] colMax(int[][] data)
```
    Returns the column maximum for a matrix.
  - colSums
```
public static long[] colSums(int[][] data)
```
    Returns the column sums for a matrix.
  - colMin
```
public static double[] colMin(double[][] data)
```
    Returns the column minimum for a matrix.
  - colMax
```
public static double[] colMax(double[][] data)
```
    Returns the column maximum for a matrix.
  - colSums
```
public static double[] colSums(double[][] data)
```
    Returns the column sums for a matrix.
  - colMeans
```
public static double[] colMeans(double[][] data)
```
    Returns the column means for a matrix.
  - colSds
```
public static double[] colSds(double[][] data)
```
    Returns the column deviations for a matrix.
  - sum
```
public static int sum(byte[] x)
```
    Returns the sum of an array.
  - sum
```
public static long sum(int[] x)
```
    Returns the sum of an array.
  - sum
```
public static double sum(float[] x)
```
    Returns the sum of an array.
  - sum
```
public static double sum(double[] x)
```
    Returns the sum of an array.
  - median
```
public static int median(int[] a)
```
    Find the median of an array of type int. The input array will be rearranged.
  - median
```
public static float median(float[] a)
```
    Find the median of an array of type float. The input array will be rearranged.
  - median
```
public static double median(double[] a)
```
    Find the median of an array of type double. The input array will be rearranged.
  - median
```
public static <T extends java.lang.Comparable<? super T>> T median(T[] a)
```
    Find the median of an array of type double. The input array will be rearranged.
  - q1
```
public static int q1(int[] a)
```
    Find the first quantile (p = 1/4) of an array of type int. The input array will be rearranged.
  - q1
```
public static float q1(float[] a)
```
    Find the first quantile (p = 1/4) of an array of type float. The input array will be rearranged.
  - q1
```
public static double q1(double[] a)
```
    Find the first quantile (p = 1/4) of an array of type double. The input array will be rearranged.
  - q1
```
public static <T extends java.lang.Comparable<? super T>> T q1(T[] a)
```
    Find the first quantile (p = 1/4) of an array of type double. The input array will be rearranged.
  - q3
```
public static int q3(int[] a)
```
    Find the third quantile (p = 3/4) of an array of type int. The input array will be rearranged.
  - q3
```
public static float q3(float[] a)
```
    Find the third quantile (p = 3/4) of an array of type float. The input array will be rearranged.
  - q3
```
public static double q3(double[] a)
```
    Find the third quantile (p = 3/4) of an array of type double. The input array will be rearranged.
  - q3
```
public static <T extends java.lang.Comparable<? super T>> T q3(T[] a)
```
    Find the third quantile (p = 3/4) of an array of type double. The input array will be rearranged.
  - mean
```
public static double mean(int[] x)
```
    Returns the mean of an array.
  - mean
```
public static double mean(float[] x)
```
    Returns the mean of an array.
  - mean
```
public static double mean(double[] x)
```
    Returns the mean of an array.
  - var
```
public static double var(int[] x)
```
    Returns the variance of an array.
  - var
```
public static double var(float[] x)
```
    Returns the variance of an array.
  - var
```
public static double var(double[] x)
```
    Returns the variance of an array.
  - sd
```
public static double sd(int[] x)
```
    Returns the standard deviation of an array.
  - sd
```
public static double sd(float[] x)
```
    Returns the standard deviation of an array.
  - sd
```
public static double sd(double[] x)
```
    Returns the standard deviation of an array.
  - 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 X₁, X₂, ..., X_n, the MAD is defined as the median of the absolute deviations from the data's median:
    MAD(X) = median(|X_i - median(X_i)|)
    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.
  - 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 X₁, X₂, ..., X_n, the MAD is defined as the median of the absolute deviations from the data's median:
    MAD(X) = median(|X_i - median(X_i)|)
    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.
  - 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 X₁, X₂, ..., X_n, the MAD is defined as the median of the absolute deviations from the data's median:
    MAD(X) = median(|X_i - median(X_i)|)
    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.
  - all
```
public static boolean all(boolean[] x)
```
    Given a set of boolean values, are all of the values true?
  - any
```
public static boolean any(boolean[] x)
```
    Given a set of boolean values, is at least one of the values true?
  - 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.
  - distance
```
public static double distance(float[] x,
                              float[] y)
```
    The Euclidean distance.
  - distance
```
public static double distance(double[] x,
                              double[] y)
```
    The Euclidean distance.
  - distance
```
public static double distance(SparseArray x,
                              SparseArray y)
```
    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.
  - squaredDistance
```
public static double squaredDistance(float[] x,
                                     float[] y)
```
    The squared Euclidean distance.
  - squaredDistance
```
public static double squaredDistance(double[] x,
                                     double[] y)
```
    The squared Euclidean distance.
  - squaredDistance
```
public static double squaredDistance(SparseArray x,
                                     SparseArray y)
```
    The Euclidean distance on sparse arrays.
  - squaredDistanceWithMissingValues
```
public static double squaredDistanceWithMissingValues(double[] x,
                                                      double[] y)
```
    The squared Euclidean distance with handling missing values (represented as NaN).
  - pdist
```
public static Matrix pdist(int[][] x)
```
    Returns the pairwise distance matrix of multiple binary sparse vectors.
    
    Parameters:
    
    x - Each row is a binary sparse array, which are the indices of nonzero elements in ascending order.
    
    Returns:
    
    a 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 - Each row is a binary sparse array, 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 - Rows of x correspond to observations, and columns correspond to variables.
    
    Returns:
    
    a full pairwise distance matrix.
  - pdist
```
public static Matrix pdist(float[][] x,
                           boolean squared)
```
    Returns the pairwise distance matrix of multiple vectors.
    
    Parameters:
    
    x - Rows of x correspond to observations, and columns correspond to variables.
    
    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 - Rows of x correspond to observations, and columns correspond to variables.
    
    Returns:
    
    a full pairwise distance matrix.
  - pdist
```
public static Matrix pdist(double[][] x,
                           boolean squared)
```
    Returns the pairwise distance matrix of multiple vectors.
    
    Parameters:
    
    x - Rows of x correspond to observations, and columns correspond to variables.
    
    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 - Each row is the sparse array of observations
    
    Returns:
    
    a full pairwise distance matrix.
  - pdist
```
public static Matrix pdist(SparseArray[] x,
                           boolean squared)
```
    Returns the pairwise distance matrix of multiple vectors.
    
    Parameters:
    
    x - Each row is the sparse array of observations
    
    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.
    
    Parameters:
    
    x - Rows of x correspond to observations, and columns correspond to variables.
    
    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.
  - KullbackLeiblerDivergence
```
public static double KullbackLeiblerDivergence(double[] x,
                                               double[] y)
```
    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.
  - KullbackLeiblerDivergence
```
public static double KullbackLeiblerDivergence(SparseArray x,
                                               SparseArray y)
```
    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.
  - KullbackLeiblerDivergence
```
public static double KullbackLeiblerDivergence(double[] x,
                                               SparseArray y)
```
    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.
  - KullbackLeiblerDivergence
```
public static double KullbackLeiblerDivergence(SparseArray x,
                                               double[] y)
```
    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.
  - JensenShannonDivergence
```
public static double JensenShannonDivergence(double[] x,
                                             double[] y)
```
    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.
  - JensenShannonDivergence
```
public static double JensenShannonDivergence(SparseArray x,
                                             SparseArray y)
```
    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.
  - JensenShannonDivergence
```
public static double JensenShannonDivergence(double[] x,
                                             SparseArray y)
```
    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.
  - JensenShannonDivergence
```
public static double JensenShannonDivergence(SparseArray x,
                                             double[] y)
```
    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.
  - 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.
  - dot
```
public static float dot(float[] x,
                        float[] y)
```
    Returns the dot product between two vectors.
  - dot
```
public static double dot(double[] x,
                         double[] y)
```
    Returns the dot product between two vectors.
  - dot
```
public static double dot(SparseArray x,
                         SparseArray y)
```
    Returns the dot product between two sparse arrays.
  - pdot
```
public static Matrix pdot(int[][] x)
```
    Returns the pairwise dot product matrix of binary sparse vectors.
    
    Parameters:
    
    x - Rows of x correspond to observations, and columns correspond to variables.
    
    Returns:
    
    The dot product matrix.
  - pdot
```
public static Matrix pdot(float[][] x)
```
    Returns the pairwise dot product matrix of float vectors.
    
    Parameters:
    
    x - Rows of x correspond to observations, and columns correspond to variables.
    
    Returns:
    
    The dot product matrix.
  - pdot
```
public static Matrix pdot(double[][] x)
```
    Returns the pairwise dot product matrix of double vectors.
    
    Parameters:
    
    x - Rows of x correspond to observations, and columns correspond to variables.
    
    Returns:
    
    The dot product matrix.
  - pdot
```
public static Matrix pdot(SparseArray[] x)
```
    Returns the pairwise dot product matrix of multiple vectors.
    
    Parameters:
    
    x - Rows of x correspond to observations, and columns correspond to variables.
    
    Returns:
    
    The dot product matrix.
  - cov
```
public static double cov(int[] x,
                         int[] y)
```
    Returns the covariance between two vectors.
  - cov
```
public static double cov(float[] x,
                         float[] y)
```
    Returns the covariance between two vectors.
  - cov
```
public static double cov(double[] x,
                         double[] y)
```
    Returns the covariance between two vectors.
  - cov
```
public static double[][] cov(double[][] data)
```
    Returns the sample covariance matrix.
  - cov
```
public static double[][] cov(double[][] data,
                             double[] mu)
```
    Returns the sample covariance matrix.
    
    Parameters:
    
    mu - the known mean of data.
  - cor
```
public static double cor(int[] x,
                         int[] y)
```
    Returns the correlation coefficient between two vectors.
  - cor
```
public static double cor(float[] x,
                         float[] y)
```
    Returns the correlation coefficient between two vectors.
  - cor
```
public static double cor(double[] x,
                         double[] y)
```
    Returns the correlation coefficient between two vectors.
  - cor
```
public static double[][] cor(double[][] data)
```
    Returns the sample correlation matrix.
  - cor
```
public static double[][] cor(double[][] data,
                             double[] mu)
```
    Returns the sample correlation matrix.
    
    Parameters:
    
    mu - the known mean of data.
  - 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 (ie. when variables are ordinal). It can be used when there is non-parametric data and hence Pearson cannot be used.
  - 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 (ie. when variables are ordinal). It can be used when there is non-parametric data and hence Pearson cannot be used.
  - 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 (ie. when variables are ordinal). It can be used when there is non-parametric data and hence Pearson cannot be used.
  - 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.
  - 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.
  - 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.
  - norm1
```
public static float norm1(float[] x)
```
    L1 vector norm.
  - norm1
```
public static double norm1(double[] x)
```
    L1 vector norm.
  - norm2
```
public static float norm2(float[] x)
```
    L2 vector norm.
  - norm2
```
public static double norm2(double[] x)
```
    L2 vector norm.
  - normInf
```
public static float normInf(float[] x)
```
    L-infinity vector norm. Maximum absolute value.
  - normInf
```
public static double normInf(double[] x)
```
    L-infinity vector norm. Maximum absolute value.
  - norm
```
public static float norm(float[] x)
```
    L2 vector norm.
  - norm
```
public static double norm(double[] x)
```
    L2 vector norm.
  - cos
```
public static float cos(float[] x,
                        float[] y)
```
    Returns the cosine similarity.
  - cos
```
public static double cos(double[] x,
                         double[] y)
```
    Returns the cosine similarity.
  - standardize
```
public static void standardize(double[] x)
```
    Standardizes an array to mean 0 and variance 1.
  - scale
```
public static void scale(double[][] x)
```
    Scales each column of a matrix to range [0, 1].
  - standardize
```
public static void standardize(double[][] x)
```
    Standardizes each column of a matrix to 0 mean and unit variance.
  - normalize
```
public static void normalize(double[][] x)
```
    Unitizes each column of a matrix to unit length (L_2 norm).
  - normalize
```
public static void normalize(double[][] x,
                             boolean centerizing)
```
    Unitizes each column of a matrix to unit length (L_2 norm).
    
    Parameters:
    
    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 array of double
  - unitize1
```
public static void unitize1(double[] x)
```
    Unitize an array so that L1 norm of x is 1.
    
    Parameters:
    
    x - an array of non-negative double
  - unitize2
```
public static void unitize2(double[] x)
```
    Unitize an array so that L2 norm of x = 1.
    
    Parameters:
    
    x - the array of double
  - equals
```
public static boolean equals(float[] x,
                             float[] y)
```
    Check if x element-wisely equals y with default epsilon 1E-7.
  - equals
```
public static boolean equals(float[] x,
                             float[] y,
                             float epsilon)
```
    Check 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.
  - equals
```
public static boolean equals(double[] x,
                             double[] y,
                             double eps)
```
    Check 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.
  - equals
```
public static boolean equals(float[][] x,
                             float[][] y,
                             float epsilon)
```
    Check 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.
  - equals
```
public static boolean equals(double[][] x,
                             double[][] y,
                             double eps)
```
    Check if x element-wisely equals y.
  - isZero
```
public static boolean isZero(float x)
```
    Tests if a floating number is zero.
  - isZero
```
public static boolean isZero(float x,
                             float epsilon)
```
    Tests if a floating number is zero with given epsilon.
  - isZero
```
public static boolean isZero(double x)
```
    Tests if a floating number is zero.
  - isZero
```
public static boolean isZero(double x,
                             double epsilon)
```
    Tests if a floating number is zero with given epsilon.
  - clone
```
public static int[][] clone(int[][] x)
```
    Deep clone a two-dimensional array.
  - clone
```
public static float[][] clone(float[][] x)
```
    Deep clone a two-dimensional array.
  - clone
```
public static double[][] clone(double[][] x)
```
    Deep clone a two-dimensional array.
  - swap
```
public static void swap(int[] x,
                        int i,
                        int j)
```
    Swap two elements of an array.
  - swap
```
public static void swap(float[] x,
                        int i,
                        int j)
```
    Swap two elements of an array.
  - swap
```
public static void swap(double[] x,
                        int i,
                        int j)
```
    Swap two elements of an array.
  - swap
```
public static void swap(java.lang.Object[] x,
                        int i,
                        int j)
```
    Swap two elements of an array.
  - swap
```
public static void swap(int[] x,
                        int[] y)
```
    Swap two arrays.
  - swap
```
public static void swap(float[] x,
                        float[] y)
```
    Swap two arrays.
  - swap
```
public static void swap(double[] x,
                        double[] y)
```
    Swap two arrays.
  - swap
```
public static <E> void swap(E[] x,
                            E[] y)
```
    Swap two arrays.
  - copy
```
public static void copy(int[] x,
                        int[] y)
```
    Copy x into y.
  - copy
```
public static void copy(float[] x,
                        float[] y)
```
    Copy x into y.
  - copy
```
public static void copy(double[] x,
                        double[] y)
```
    Copy x into y.
  - copy
```
public static void copy(int[][] x,
                        int[][] y)
```
    Copy x into y.
  - copy
```
public static void copy(float[][] x,
                        float[][] y)
```
    Copy x into y.
  - copy
```
public static void copy(double[][] x,
                        double[][] y)
```
    Copy x into y.
  - add
```
public static void add(double[] y,
                       double[] x)
```
    Element-wise sum of two arrays y = x + y.
  - sub
```
public static void sub(double[] y,
                       double[] x)
```
    Element-wise subtraction of two arrays y = y - x.
    
    Parameters:
    
    y - minuend matrix
    
    x - subtrahend matrix
  - scale
```
public static void scale(double a,
                         double[] x)
```
    Scale each element of an array by a constant x = a * x.
  - scale
```
public static void scale(double a,
                         double[] x,
                         double[] y)
```
    Scale each element of an array by a constant y = a * x.
  - 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.
  - pow
```
public static double[] pow(double[] x,
                           double n)
```
    Raise each element of an array to a scalar power.
    
    Parameters:
    
    x - array
    
    n - scalar exponent
    
    Returns:
    
    xⁿ
  - 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 java.lang.String[] unique(java.lang.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
```
     |b_i| > |a_i| + |c_i|.
 
```
```
     | 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.

Class MathEx

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EPSILON

FLOAT_EPSILON

RADIX

DIGITS

FLOAT_DIGITS

ROUND_STYLE

MACHEP

FLOAT_MACHEP

NEGEP

FLOAT_NEGEP

Method Detail

log2

log

log1pe

isInt

isInt

equals

logistic

tanh

sqr

isPower2

isProbablePrime

round

factorial

lfactorial

choose

lchoose

setSeed

setSeed

probablePrime

seeds

random

random

random

random

random

random

randomLong

randomInt

randomInt

permutate

permutate

permutate

permutate

permutate

softmax

softmax

c

c

c

c

c

c

c

c

cbind

cbind

cbind

cbind

rbind

rbind

rbind

rbind

slice

slice

slice

slice

contains

contains

reverse

reverse

reverse

reverse

min

min