MathUtilities (illinois-cogcomp-nlp 3.1.29 API)

java.lang.Object
- edu.illinois.cs.cogcomp.core.math.MathUtilities

```
public class MathUtilities
extends Object
```
Some math utilities that are not present in the standard math library.

Author:

Vivek Srikumar

Field Summary

Fields
Modifier and Type Field and Description

static double EPSILON
An attempt to fix the value of epsilon used across different applications.

Fields
Modifier and Type	Field and Description
`static double`	`EPSILON` An attempt to fix the value of epsilon used across different applications.

Constructor Summary

Constructors
Constructor and Description

MathUtilities()

Constructors
Constructor and Description
`MathUtilities()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`beta(double x, double w)` Get the Beta(x,w)
`static int`	`binomialCoeffs(int n, int k)`
`static boolean`	`epsilonEquals(double d1, double d2)` Check equality of two doubles upto `EPSILON`
`static double`	`erf(double x)`
`static double`	`erfc(double x)`
`static double`	`incompleteGammaP(double a, double x)` Get the incomplete gamma function P(a,x).
`static double`	`incompleteGammaQ(double a, double x)`
`static double`	`lnFactorial(int x)` Get the log of the factorial of a number.
`static double`	`lnGamma(double xx)` Computes log(gamma(xx)).
`static double`	`logAdd(Collection<Double> doubles)` Add a collection of numbers in log space
`static double`	`logAdd(double[] doubles)` Add an array of numbers in log space
`static double`	`logAdd(double x1, double x2)` Add two numbers in log space.
`static <T extends Comparable<T>> Pair<Integer,T>`	`max(Collection<T> list)` Find the argmax and max in a list of elements that can are ordered.
`static Pair<Integer,Double>`	`max(double[] array)` Find the argmax and max in a double array.
`static Pair<Integer,Integer>`	`max(int[] array)` Find the argmax and max in an int array.
`static <T,S extends Comparable<S>> Pair<T,S>`	`max(Map<T,S> map)` Find the argmax and max in a map from items to values.
`static <T extends Comparable<T>> Pair<Integer,T>`	`max(T[] array)` Find the argmax and max in a array of elements that can are ordered.
`static <T extends Comparable<T>> Pair<Integer,T>`	`min(Collection<T> list)` Find the argmin and min in a list of elements that can are ordered.
`static Pair<Integer,Double>`	`min(double[] array)` Find the argmin and min in a double array.
`static Pair<Integer,Integer>`	`min(int[] array)` Find the argmin and min in a int array.
`static <T,S extends Comparable<S>> Pair<T,S>`	`min(Map<T,S> map)` Find the argmin and min in a map from items to values.
`static <T extends Comparable<T>> Pair<Integer,T>`	`min(T[] array)` Find the argmin and min in a array of elements that can are ordered.
`static double[]`	`multiply(double[] d, double m)` Multiply all elements of a double array with a scalar.
`static double[]`	`multiply(double[] d1, double[] d2)` Elementwise multiplication of two double arrays.
`static List<Double>`	`multiply(List<Double> l, double m)` Multiply a list of doubles with a scalar
`static List<Double>`	`multiply(List<Double> d1, List<Double> d2)` Elementwise multiplication of two lists of doubles.
`static double[]`	`softmax(double[] input)` Efficient computation of softmax.
`static double[]`	`softmax(double[] input, double[] multiplier)`
`static List<Double>`	`softmax(List<Double> input)` Efficient computation of softmax.
`static List<Double>`	`softmax(List<Double> input, List<Double> multiplier)`

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
```
    An attempt to fix the value of epsilon used across different applications.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - MathUtilities
```
public MathUtilities()
```
- Method Detail
  - max
```
public static Pair<Integer,Double> max(double[] array)
```
    Find the argmax and max in a double array. If the array is empty, the function returns (-1, Double.NEGATIVE_INFINITY)
  - max
```
public static Pair<Integer,Integer> max(int[] array)
```
    Find the argmax and max in an int array. If the array is empty, the function returns (-1, Integer.MIN_VALUE)
  - max
```
public static <T extends Comparable<T>> Pair<Integer,T> max(Collection<T> list)
```
    Find the argmax and max in a list of elements that can are ordered. If the list is empty, the function returns (-1, null).
  - max
```
public static <T extends Comparable<T>> Pair<Integer,T> max(T[] array)
```
    Find the argmax and max in a array of elements that can are ordered. If the list is empty, the function returns (-1, null).
  - max
```
public static <T,S extends Comparable<S>> Pair<T,S> max(Map<T,S> map)
```
    Find the argmax and max in a map from items to values. If the list is empty, the function returns (null, null).
    
    Type Parameters:
    
    T - represents items
    
    S - represents values, should be Comparable
    
    Returns:
    
    Pair of (argmax, max)
  - min
```
public static Pair<Integer,Double> min(double[] array)
```
    Find the argmin and min in a double array. If the array is empty, the function returns (-1, Double.POSITIVE_INFINITY)
  - min
```
public static Pair<Integer,Integer> min(int[] array)
```
    Find the argmin and min in a int array. If the array is empty, the function returns (-1, Integer.MAX_VALUE)
    
    Returns:
    
    A pair of integers containing (argMin, min).
  - min
```
public static <T extends Comparable<T>> Pair<Integer,T> min(Collection<T> list)
```
    Find the argmin and min in a list of elements that can are ordered. If the list is empty, the function returns (-1, null).
  - min
```
public static <T,S extends Comparable<S>> Pair<T,S> min(Map<T,S> map)
```
    Find the argmin and min in a map from items to values. If the list is empty, the function returns (null, null).
    
    Type Parameters:
    
    T - represents items
    
    S - represents values, should be Comparable
    
    Returns:
    
    Pair of (argmin, min)
  - min
```
public static <T extends Comparable<T>> Pair<Integer,T> min(T[] array)
```
    Find the argmin and min in a array of elements that can are ordered. If the list is empty, the function returns (-1, null).
  - multiply
```
public static List<Double> multiply(List<Double> l,
                                    double m)
```
    Multiply a list of doubles with a scalar
  - multiply
```
public static List<Double> multiply(List<Double> d1,
                                    List<Double> d2)
```
    Elementwise multiplication of two lists of doubles. Both lists should be equally long. The output is also a list that has the same length, where each element is the product of the corresponding elements of the input lists.
  - multiply
```
public static double[] multiply(double[] d1,
                                double[] d2)
```
    Elementwise multiplication of two double arrays. Both arrays should be equally long. The output is an array of the same length.
  - multiply
```
public static double[] multiply(double[] d,
                                double m)
```
    Multiply all elements of a double array with a scalar.
  - softmax
```
public static double[] softmax(double[] input)
```
    Efficient computation of softmax. This does not create overflow errors because of exponentiation
  - softmax
```
public static double[] softmax(double[] input,
                               double[] multiplier)
```
  - softmax
```
public static List<Double> softmax(List<Double> input)
```
    Efficient computation of softmax. This does not create overflow errors because of exponentiation
  - softmax
```
public static List<Double> softmax(List<Double> input,
                                   List<Double> multiplier)
```
  - epsilonEquals
```
public static boolean epsilonEquals(double d1,
                                    double d2)
```
    Check equality of two doubles upto EPSILON
  - logAdd
```
public static double logAdd(double x1,
                            double x2)
```
    Add two numbers in log space.
    Suppose y1 and y2 are two positive reals and let x1 = log(y1) and x2 = log(y2). This function (and the other versions of logAdd) computes log(exp(x1) + exp(x2)) = log(y1 + y2) without underflow or overflow errors. This can be used, for example, to maintain log probabilities without worrying about the probabilities getting too small.
  - logAdd
```
public static double logAdd(double[] doubles)
```
    Add an array of numbers in log space
  - logAdd
```
public static double logAdd(Collection<Double> doubles)
```
    Add a collection of numbers in log space
  - lnGamma
```
public static double lnGamma(double xx)
```
    Computes log(gamma(xx)). From numerical recipies. This just works.
  - lnFactorial
```
public static double lnFactorial(int x)
```
    Get the log of the factorial of a number. Upto 32, the factorial is exact. After that, the gamma function is used because the numbers can't be represented anyway.
  - binomialCoeffs
```
public static int binomialCoeffs(int n,
                                 int k)
```
  - beta
```
public static double beta(double x,
                          double w)
```
    Get the Beta(x,w)
  - incompleteGammaP
```
public static double incompleteGammaP(double a,
                                      double x)
```
    Get the incomplete gamma function P(a,x). This implementation is directly taken from numerical recipies 2nd Ed.
    Wikipedia calls this function the lower incomplete gamma function where the integral is from 0 to x.
  - incompleteGammaQ
```
public static double incompleteGammaQ(double a,
                                      double x)
```
  - erf
```
public static double erf(double x)
```
  - erfc
```
public static double erfc(double x)
```

Class MathUtilities

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EPSILON

Constructor Detail

MathUtilities

Method Detail

max

max

max

max

max

min

min

min

min

min

multiply

multiply

multiply

multiply

softmax

softmax

softmax

softmax

epsilonEquals

logAdd

logAdd

logAdd

lnGamma

lnFactorial

binomialCoeffs

beta

incompleteGammaP

incompleteGammaQ

erf

erfc