MathUtil (ELKI: Environment for DeveLoping KDD-Applications Supported by Index-Structures)

java.lang.Object
- de.lmu.ifi.dbs.elki.math.MathUtil

```
public final class MathUtil
extends Object
```
A collection of math related utility functions.

Author:

Arthur Zimek, Erich Schubert

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`DEG2RAD` Constant for degrees to radians.
`static int[]`	`EMPTY_INTS` Empty integer array.
`static double`	`HALFPI` Half the value of Pi.
`static double`	`LOG10` Natural logarithm of 10.
`static double`	`LOG2` Logarithm of 2 to the basis e, for logarithm conversion.
`static double`	`LOG3` Logarithm of 3 to the basis e, for logarithm conversion.
`static double`	`LOGLOG2` Log(log(2))
`static double`	`LOGPI` Math.log(Math.PI).
`static double`	`LOGPIHALF` Math.log(Math.PI) / 2.
`static double`	`LOGSQRTTWOPI` Math.log(Math.sqrt(2*Math.PI)).
`static double`	`LOGTWOPI` Math.log(2*Math.PI).
`static double`	`ONE_BY_LOG2` 1. / log(2)
`static double`	`ONE_BY_SQRTPI` Precomputed value of 1 / sqrt(pi).
`static double`	`ONE_BY_SQRTTWOPI` Precomputed value of 1 / sqrt(2 * pi).
`static double`	`ONEHALFPI` 1.5 times Pi.
`static double`	`PISQUARE` Pi squared
`static double`	`QUARTERPI` One quarter of Pi.
`static double`	`RAD2DEG` Constant for radians to degrees.
`static double`	`SQRT2` Square root of 2.
`static double`	`SQRT5` Square root of 5.
`static double`	`SQRTHALF` Square root of 0.5 == 1 / sqrt(2).
`static double`	`SQRTHALFPI` Constant for sqrt(pi/2)
`static double`	`SQRTPI` Square root of Pi.
`static double`	`SQRTTWOPI` Square root of two times Pi.
`static double`	`TWOPI` Two times Pi.

Constructor Summary

Constructors
Modifier Constructor and Description

private MathUtil()
Fake constructor for static class.

Constructors
Modifier	Constructor and Description
`private`	`MathUtil()` Fake constructor for static class.

Method Summary

Methods
Modifier and Type	Method and Description
`static double`	`angle(double[] v1, double[] v2)` Compute the angle between two vectors.
`static double`	`angle(double[] v1, double[] v2, double[] o)` Compute the angle between two vectors.
`static double`	`angle(Vector v1, Vector v2)` Compute the angle between two vectors.
`static double`	`angle(Vector v1, Vector v2, Vector o)` Compute the angle between two vectors.
`static double`	`approximateBinomialCoefficient(int n, int k)` Binomial coefficent, also known as "n choose k").
`static double`	`approximateFactorial(int n)` Compute the Factorial of n, often written as `c!`
`static long`	`binomialCoefficient(long n, long k)` Binomial coefficient, also known as "n choose k".
`static double`	`cosToSin(double angle, double cos)` Fast way of computing sin(x) from x and cos(x).
`static double`	`deg2rad(double deg)` Convert Degree to Radians.
`static BigInteger`	`factorial(BigInteger n)` Compute the Factorial of n, often written as `c!`
`static long`	`factorial(int n)` Compute the Factorial of n, often written as `c!`
`static double`	`fastHypot(double a, double b)` Computes the square root of the sum of the squared arguments without under or overflow.
`static double`	`fastHypot3(double a, double b, double c)` Computes the square root of the sum of the squared arguments without under or overflow.
`static double`	`floatToDoubleLower(float f)` Return the largest double that rounds up to this float.
`static double`	`floatToDoubleUpper(float f)` Return the largest double that rounds down to this float.
`static int`	`ipowi(int x, int p)` Fast loop for computing `Math.pow(x, p)` for p >= 0 integer and x integer.
`static double`	`log1mexp(double x)` More stable than `Math.log(1 - Math.exp(x))`
`static double`	`log2(double x)` Compute the base 2 logarithm.
`static double`	`mahalanobisDistance(double[][] weightMatrix, double[] o1_minus_o2)` Compute the Mahalanobis distance using the given weight matrix.
`static double`	`mahalanobisDistance(double[][] weightMatrix, double[] o1, double[] o2)` Compute the Mahalanobis distance using the given weight matrix.
`static double`	`mahalanobisDistance(Matrix weightMatrix, Vector o1_minus_o2)` Compute the Mahalanobis distance using the given weight matrix.
`static double`	`mahalanobisDistance(Matrix weightMatrix, Vector o1, Vector o2)` Compute the Mahalanobis distance using the given weight matrix.
`static double`	`max(double a, double b)` Binary max, without handling of special values.
`static double`	`max(double a, double b, double c)` Ternary max, without handling of special values.
`static double`	`max(double a, double b, double c, double d)` Quadrary max, without handling of special values.
`static int`	`max(int a, int b)` Binary max.
`static int`	`max(int a, int b, int c)` Ternary max.
`static int`	`max(int a, int b, int c, int d)` Quadrary max, without handling of special values.
`static double`	`min(double a, double b)` Binary min, without handling of special values.
`static double`	`min(double a, double b, double c)` Ternary min, without handling of special values.
`static double`	`min(double a, double b, double c, double d)` Quadrary min, without handling of special values.
`static int`	`min(int a, int b)` Binary min, without handling of special values.
`static int`	`min(int a, int b, int c)` Ternary min, without handling of special values.
`static int`	`min(int a, int b, int c, int d)` Quadrary min, without handling of special values.
`static int`	`nextAllOnesInt(int x)` Find the next larger number with all ones.
`static long`	`nextAllOnesLong(long x)` Find the next larger number with all ones.
`static int`	`nextPow2Int(int x)` Find the next power of 2.
`static long`	`nextPow2Long(long x)` Find the next power of 2.
`static double`	`normAngle(double x)` Normalize an angle to [0:2pi[
`static double`	`pearsonCorrelationCoefficient(double[] x, double[] y)` Compute the Pearson product-moment correlation coefficient for two FeatureVectors.
`static double`	`pearsonCorrelationCoefficient(NumberVector x, NumberVector y)` Compute the Pearson product-moment correlation coefficient for two NumberVectors.
`static double`	`powi(double x, int p)` Fast loop for computing `Math.pow(x, p)` for p >= 0 integer.
`static double`	`rad2deg(double rad)` Radians to Degree.
`static double[]`	`randomDoubleArray(int len)` Produce an array of random numbers in [0:1].
`static double[]`	`randomDoubleArray(int len, Random r)` Produce an array of random numbers in [0:1].
`static int[]`	`sequence(int start, int end)` Generate an array of integers.
`static double`	`sinToCos(double angle, double sin)` Fast way of computing cos(x) from x and sin(x).
`static long`	`sumFirstIntegers(long i)` Compute the sum of the i first integers.
`static double`	`weightedPearsonCorrelationCoefficient(double[] x, double[] y, double[] weights)` Compute the Pearson product-moment correlation coefficient for two FeatureVectors.
`static double`	`weightedPearsonCorrelationCoefficient(NumberVector x, NumberVector y, double[] weights)` Compute the Pearson product-moment correlation coefficient for two NumberVectors.
`static double`	`weightedPearsonCorrelationCoefficient(NumberVector x, NumberVector y, NumberVector weights)` Compute the Pearson product-moment correlation coefficient for two FeatureVectors.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
 - TWOPI
```
public static final double TWOPI
```
 Two times Pi.
 
 See Also:
 Constant Field Values
 - HALFPI
```
public static final double HALFPI
```
 Half the value of Pi.
 
 See Also:
 Constant Field Values
 - QUARTERPI
```
public static final double QUARTERPI
```
 One quarter of Pi.
 
 See Also:
 Constant Field Values
 - ONEHALFPI
```
public static final double ONEHALFPI
```
 1.5 times Pi.
 
 See Also:
 Constant Field Values
 - PISQUARE
```
public static final double PISQUARE
```
 Pi squared
 
 See Also:
 Constant Field Values
 - SQRTPI
```
public static final double SQRTPI
```
 Square root of Pi.
 - SQRTTWOPI
```
public static final double SQRTTWOPI
```
 Square root of two times Pi.
 - SQRTHALFPI
```
public static final double SQRTHALFPI
```
 Constant for sqrt(pi/2)
 - SQRT2
```
public static final double SQRT2
```
 Square root of 2.
 - SQRT5
```
public static final double SQRT5
```
 Square root of 5.
 - SQRTHALF
```
public static final double SQRTHALF
```
 Square root of 0.5 == 1 / sqrt(2).
 - ONE_BY_SQRTPI
```
public static final double ONE_BY_SQRTPI
```
 Precomputed value of 1 / sqrt(pi).
 - ONE_BY_SQRTTWOPI
```
public static final double ONE_BY_SQRTTWOPI
```
 Precomputed value of 1 / sqrt(2 * pi).
 - ONE_BY_LOG2
```
public static final double ONE_BY_LOG2
```
 1. / log(2)
 - LOG2
```
public static final double LOG2
```
 Logarithm of 2 to the basis e, for logarithm conversion.
 - LOG3
```
public static final double LOG3
```
 Logarithm of 3 to the basis e, for logarithm conversion.
 - LOG10
```
public static final double LOG10
```
 Natural logarithm of 10.
 - LOGPI
```
public static final double LOGPI
```
 Math.log(Math.PI).
 - LOGPIHALF
```
public static final double LOGPIHALF
```
 Math.log(Math.PI) / 2.
 - LOGTWOPI
```
public static final double LOGTWOPI
```
 Math.log(2*Math.PI).
 - LOGSQRTTWOPI
```
public static final double LOGSQRTTWOPI
```
 Math.log(Math.sqrt(2*Math.PI)).
 - LOGLOG2
```
public static final double LOGLOG2
```
 Log(log(2))
 - DEG2RAD
```
public static final double DEG2RAD
```
 Constant for degrees to radians.
 
 See Also:
 Constant Field Values
 - RAD2DEG
```
public static final double RAD2DEG
```
 Constant for radians to degrees.
 
 See Also:
 Constant Field Values
 - EMPTY_INTS
```
public static final int[] EMPTY_INTS
```
 Empty integer array.
- Constructor Detail
 - MathUtil
```
private MathUtil()
```
 Fake constructor for static class.
- Method Detail
 - log2
```
public static double log2(double x)
```
 Compute the base 2 logarithm.
 
 Parameters:
 x - X
 
 Returns:
 Logarithm base 2.
 - fastHypot
```
public static double fastHypot(double a,
 double b)
```
 Computes the square root of the sum of the squared arguments without under or overflow. Note: this code is not redundant to Math.hypot(double, double), since the latter is significantly slower (but maybe has a higher precision).
 
 Parameters:
 a - first cathetus
 b - second cathetus
 
 Returns:
 sqrt(a2 + b2)
 - fastHypot3
```
public static double fastHypot3(double a,
 double b,
 double c)
```
 Computes the square root of the sum of the squared arguments without under or overflow. Note: this code is not redundant to Math.hypot(double, double), since the latter is significantly slower (but has a higher precision).
 
 Parameters:
 a - first cathetus
 b - second cathetus
 c - second cathetus
 
 Returns:
 sqrt(a2 + b2 + c2)
 - mahalanobisDistance
```
public static double mahalanobisDistance(Matrix weightMatrix,
 Vector o1_minus_o2)
```
 Compute the Mahalanobis distance using the given weight matrix.
 
 Parameters:
 weightMatrix - Weight Matrix
 o1_minus_o2 - Delta vector
 
 Returns:
 Mahalanobis distance
 - mahalanobisDistance
```
public static double mahalanobisDistance(double[][] weightMatrix,
 double[] o1_minus_o2)
```
 Compute the Mahalanobis distance using the given weight matrix.
 
 Parameters:
 weightMatrix - Weight Matrix
 o1_minus_o2 - Delta vector
 
 Returns:
 Mahalanobis distance
 - mahalanobisDistance
```
public static double mahalanobisDistance(Matrix weightMatrix,
 Vector o1,
 Vector o2)
```
 Compute the Mahalanobis distance using the given weight matrix.
 
 Parameters:
 weightMatrix - Weight Matrix
 o1 - First vector
 o2 - Center vector
 
 Returns:
 Mahalanobis distance
 - mahalanobisDistance
```
public static double mahalanobisDistance(double[][] weightMatrix,
 double[] o1,
 double[] o2)
```
 Compute the Mahalanobis distance using the given weight matrix.
 
 Parameters:
 weightMatrix - Weight Matrix
 o1 - First vector
 o2 - Center vector
 
 Returns:
 Mahalanobis distance
 - pearsonCorrelationCoefficient
```
public static double pearsonCorrelationCoefficient(NumberVector x,
 NumberVector y)
```
 Compute the Pearson product-moment correlation coefficient for two NumberVectors.
 
 Parameters:
 x - first NumberVector
 y - second NumberVector
 
 Returns:
 the Pearson product-moment correlation coefficient for x and y
 - weightedPearsonCorrelationCoefficient
```
public static double weightedPearsonCorrelationCoefficient(NumberVector x,
 NumberVector y,
 double[] weights)
```
 Compute the Pearson product-moment correlation coefficient for two NumberVectors.
 
 Parameters:
 x - first NumberVector
 y - second NumberVector
 weights - Weights
 
 Returns:
 the Pearson product-moment correlation coefficient for x and y
 - weightedPearsonCorrelationCoefficient
```
public static double weightedPearsonCorrelationCoefficient(NumberVector x,
 NumberVector y,
 NumberVector weights)
```
 Compute the Pearson product-moment correlation coefficient for two FeatureVectors.
 
 Parameters:
 x - first FeatureVector
 y - second FeatureVector
 weights - Weights
 
 Returns:
 the Pearson product-moment correlation coefficient for x and y
 - pearsonCorrelationCoefficient
```
public static double pearsonCorrelationCoefficient(double[] x,
 double[] y)
```
 Compute the Pearson product-moment correlation coefficient for two FeatureVectors.
 
 Parameters:
 x - first FeatureVector
 y - second FeatureVector
 
 Returns:
 the Pearson product-moment correlation coefficient for x and y
 - weightedPearsonCorrelationCoefficient
```
public static double weightedPearsonCorrelationCoefficient(double[] x,
 double[] y,
 double[] weights)
```
 Compute the Pearson product-moment correlation coefficient for two FeatureVectors.
 
 Parameters:
 x - first FeatureVector
 y - second FeatureVector
 weights - Weights
 
 Returns:
 the Pearson product-moment correlation coefficient for x and y
 - factorial
```
public static BigInteger factorial(BigInteger n)
```
 Compute the Factorial of n, often written as c! in mathematics.
 Use this method if for large values of n.
 
 Parameters:
 n - Note: n >= 0. This BigInteger n will be 0 after this method finishes.
 
 Returns:
 n * (n-1) * (n-2) * ... * 1
 - factorial
```
public static long factorial(int n)
```
 Compute the Factorial of n, often written as c! in mathematics.
 
 Parameters:
 n - Note: n >= 0
 
 Returns:
 n * (n-1) * (n-2) * ... * 1
 - binomialCoefficient
```
public static long binomialCoefficient(long n,
 long k)
```
 Binomial coefficient, also known as "n choose k".
 
 Parameters:
 n - Total number of samples. n > 0
 k - Number of elements to choose. n >= k, k >= 0
 
 Returns:
 n! / (k! * (n-k)!)
 - approximateFactorial
```
public static double approximateFactorial(int n)
```
 Compute the Factorial of n, often written as c! in mathematics.
 
 Parameters:
 n - Note: n >= 0
 
 Returns:
 n * (n-1) * (n-2) * ... * 1
 - approximateBinomialCoefficient
```
public static double approximateBinomialCoefficient(int n,
 int k)
```
 Binomial coefficent, also known as "n choose k").
 
 Parameters:
 n - Total number of samples. n > 0
 k - Number of elements to choose. n >= k, k >= 0
 
 Returns:
 n! / (k! * (n-k)!)
 - sumFirstIntegers
```
public static long sumFirstIntegers(long i)
```
 Compute the sum of the i first integers.
 
 Parameters:
 i - maximum summand
 
 Returns:
 Sum
 - randomDoubleArray
```
public static double[] randomDoubleArray(int len)
```
 Produce an array of random numbers in [0:1].
 
 Parameters:
 len - Length
 
 Returns:
 Array
 - randomDoubleArray
```
public static double[] randomDoubleArray(int len,
 Random r)
```
 Produce an array of random numbers in [0:1].
 
 Parameters:
 len - Length
 r - Random generator
 
 Returns:
 Array
 - deg2rad
```
public static double deg2rad(double deg)
```
 Convert Degree to Radians. This is essentially the same as Math.toRadians(double), but we keep it for now, it might be marginally faster, but certainly not slower.
 
 Parameters:
 deg - Degree value
 
 Returns:
 Radian value
 - rad2deg
```
public static double rad2deg(double rad)
```
 Radians to Degree. This is essentially the same as Math.toRadians(double), but we keep it for now, it might be marginally faster, but certainly not slower.
 
 Parameters:
 rad - Radians value
 
 Returns:
 Degree value
 - angle
```
public static double angle(Vector v1,
 Vector v2)
```
 Compute the angle between two vectors.
 
 Parameters:
 v1 - first vector
 v2 - second vector
 
 Returns:
 Angle
 - angle
```
public static double angle(double[] v1,
 double[] v2)
```
 Compute the angle between two vectors.
 
 Parameters:
 v1 - first vector
 v2 - second vector
 
 Returns:
 Angle
 - angle
```
public static double angle(Vector v1,
 Vector v2,
 Vector o)
```
 Compute the angle between two vectors.
 
 Parameters:
 v1 - first vector
 v2 - second vector
 o - Origin
 
 Returns:
 Angle
 - angle
```
public static double angle(double[] v1,
 double[] v2,
 double[] o)
```
 Compute the angle between two vectors.
 
 Parameters:
 v1 - first vector
 v2 - second vector
 o - Origin
 
 Returns:
 Angle
 - normAngle
```
public static double normAngle(double x)
```
 Normalize an angle to [0:2pi[
 
 Parameters:
 x - Input angle
 
 Returns:
 Normalized angle
 - sinToCos
```
public static double sinToCos(double angle,
 double sin)
```
 Fast way of computing cos(x) from x and sin(x).
 
 Parameters:
 angle - Input angle x
 sin - Sine of x.
 
 Returns:
 Cosine of x
 - cosToSin
```
public static double cosToSin(double angle,
 double cos)
```
 Fast way of computing sin(x) from x and cos(x).
 
 Parameters:
 angle - Input angle x
 cos - Cosine of x.
 
 Returns:
 Sine of x
 - nextPow2Int
```
public static int nextPow2Int(int x)
```
 Find the next power of 2. Classic bit operation, for signed 32-bit. Valid for positive integers only (0 otherwise).
 
 Parameters:
 x - original integer
 
 Returns:
 Next power of 2
 - nextPow2Long
```
public static long nextPow2Long(long x)
```
 Find the next power of 2. Classic bit operation, for signed 64-bit. Valid for positive integers only (0 otherwise).
 
 Parameters:
 x - original long integer
 
 Returns:
 Next power of 2
 - nextAllOnesInt
```
public static int nextAllOnesInt(int x)
```
 Find the next larger number with all ones. Classic bit operation, for signed 32-bit. Valid for positive integers only (-1 otherwise).
 
 Parameters:
 x - original integer
 
 Returns:
 Next number with all bits set
 - nextAllOnesLong
```
public static long nextAllOnesLong(long x)
```
 Find the next larger number with all ones. Classic bit operation, for signed 64-bit. Valid for positive integers only (-1 otherwise).
 
 Parameters:
 x - original long integer
 
 Returns:
 Next number with all bits set
 - floatToDoubleUpper
```
public static double floatToDoubleUpper(float f)
```
 Return the largest double that rounds down to this float. Note: Probably not always correct - subnormal values are quite tricky. So some of the bounds might not be tight.
 
 Parameters:
 f - Float value
 
 Returns:
 Double value
 - floatToDoubleLower
```
public static double floatToDoubleLower(float f)
```
 Return the largest double that rounds up to this float. Note: Probably not always correct - subnormal values are quite tricky. So some of the bounds might not be tight.
 
 Parameters:
 f - Float value
 
 Returns:
 Double value
 - log1mexp
```
public static double log1mexp(double x)
```
 More stable than Math.log(1 - Math.exp(x))
 
 Parameters:
 x - Value
 
 Returns:
 log(1-exp(x))
 - powi
```
public static double powi(double x,
 int p)
```
 Fast loop for computing Math.pow(x, p) for p >= 0 integer.
 
 Parameters:
 x - Base
 p - Exponent
 
 Returns:
 Math.pow(x, p)
 - ipowi
```
public static int ipowi(int x,
 int p)
```
 Fast loop for computing Math.pow(x, p) for p >= 0 integer and x integer.
 
 Parameters:
 x - Base
 p - Exponent
 
 Returns:
 Math.pow(x, p)
 - sequence
```
public static int[] sequence(int start,
 int end)
```
 Generate an array of integers.
 
 Parameters:
 start - First integer
 end - Last integer (exclusive!)
 
 Returns:
 Array of integers of length end-start
 - max
```
public static double max(double a,
 double b)
```
 Binary max, without handling of special values. Because of the lack of special case handling, this is faster than Math.max(int, int). But usually, it should be written inline as (a >= b) ? a : b The result is asymmetric in case of Double.NaN:
 MathUtil.max(Double.NaN, 1.) is 1, but
 MathUtil.max(1., Double.NaN) is Double.NaN.
 
 Parameters:
 a - First value
 b - Second value
 
 Returns:
 Maximum
 - max
```
public static double max(double a,
 double b,
 double c)
```
 Ternary max, without handling of special values. Because of the lack of special case handling, this is faster than Math.max(int, int). But usually, it should be written inline.
 
 Parameters:
 a - First value
 b - Second value
 c - Third value
 
 Returns:
 Maximum
 - max
```
public static double max(double a,
 double b,
 double c,
 double d)
```
 Quadrary max, without handling of special values. Because of the lack of special case handling, this is faster than Math.max(int, int). But usually, it should be written inline.
 
 Parameters:
 a - First value
 b - Second value
 c - Third value
 d - Fourth value
 
 Returns:
 Maximum
 - max
```
public static int max(int a,
 int b)
```
 Binary max. If possible, inline.
 
 Parameters:
 a - First value
 b - Second value
 
 Returns:
 Maximum
 - max
```
public static int max(int a,
 int b,
 int c)
```
 Ternary max. If possible, inline.
 
 Parameters:
 a - First value
 b - Second value
 c - Third value
 
 Returns:
 Maximum
 - max
```
public static int max(int a,
 int b,
 int c,
 int d)
```
 Quadrary max, without handling of special values. Because of the lack of special case handling, this is faster than Math.max(int, int). But usually, it should be written inline.
 
 Parameters:
 a - First value
 b - Second value
 c - Third value
 d - Fourth value
 
 Returns:
 Maximum
 - min
```
public static double min(double a,
 double b)
```
 Binary min, without handling of special values. Because of the lack of special case handling, this is faster than Math.min(int, int). But usually, it should be written inline as (a <= b) ? a : b The result is asymmetric in case of Double.NaN:
 MathUtil.min(Double.NaN, 1.) is 1, but
 MathUtil.min(1., Double.NaN) is Double.NaN.
 
 Parameters:
 a - First value
 b - Second value
 
 Returns:
 minimum
 - min
```
public static double min(double a,
 double b,
 double c)
```
 Ternary min, without handling of special values. Because of the lack of special case handling, this is faster than Math.min(int, int). But usually, it should be written inline.
 
 Parameters:
 a - First value
 b - Second value
 c - Third value
 
 Returns:
 minimum
 - min
```
public static double min(double a,
 double b,
 double c,
 double d)
```
 Quadrary min, without handling of special values. Because of the lack of special case handling, this is faster than Math.min(int, int). But usually, it should be written inline.
 
 Parameters:
 a - First value
 b - Second value
 c - Third value
 d - Fourth value
 
 Returns:
 minimum
 - min
```
public static int min(int a,
 int b)
```
 Binary min, without handling of special values. Because of the lack of special case handling, this is faster than Math.min(int, int). But usually, it should be written inline.
 
 Parameters:
 a - First value
 b - Second value
 
 Returns:
 minimum
 - min
```
public static int min(int a,
 int b,
 int c)
```
 Ternary min, without handling of special values. Because of the lack of special case handling, this is faster than Math.min(int, int). But usually, it should be written inline.
 
 Parameters:
 a - First value
 b - Second value
 c - Third value
 
 Returns:
 minimum
 - min
```
public static int min(int a,
 int b,
 int c,
 int d)
```
 Quadrary min, without handling of special values. Because of the lack of special case handling, this is faster than Math.min(int, int). But usually, it should be written inline.
 
 Parameters:
 a - First value
 b - Second value
 c - Third value
 d - Fourth value
 
 Returns:
 minimum

Class MathUtil

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TWOPI

HALFPI

QUARTERPI

ONEHALFPI

PISQUARE

SQRTPI

SQRTTWOPI

SQRTHALFPI

SQRT2

SQRT5

SQRTHALF

ONE_BY_SQRTPI

ONE_BY_SQRTTWOPI

ONE_BY_LOG2

LOG2

LOG3

LOG10

LOGPI

LOGPIHALF

LOGTWOPI

LOGSQRTTWOPI

LOGLOG2

DEG2RAD

RAD2DEG

EMPTY_INTS

Constructor Detail

MathUtil

Method Detail

log2

fastHypot

fastHypot3

mahalanobisDistance

mahalanobisDistance

mahalanobisDistance

mahalanobisDistance

pearsonCorrelationCoefficient

weightedPearsonCorrelationCoefficient

weightedPearsonCorrelationCoefficient

pearsonCorrelationCoefficient

weightedPearsonCorrelationCoefficient

factorial

factorial

binomialCoefficient

approximateFactorial

approximateBinomialCoefficient

sumFirstIntegers

randomDoubleArray

randomDoubleArray

deg2rad

rad2deg

angle

angle

angle

angle

normAngle

sinToCos

cosToSin

nextPow2Int

nextPow2Long

nextAllOnesInt

nextAllOnesLong

floatToDoubleUpper

floatToDoubleLower

log1mexp

powi

ipowi

sequence

max

max

max

max

max

max

min