Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## cc.mallet.util
Class Maths

    java.lang.Object
      cc.mallet.util.Maths

    public final class Maths

extends java.lang.Object

Field Summary
`static double` | `EPSILON` Numbers that are closer than this are considered equal by almostEquals.
`static double` | `log2`

Constructor Summary
`Maths()`

Method Summary
`static boolean` | `almostEquals(double[] d1, double[] d2, double eps)`
`static boolean` | `almostEquals(double d1, double d2)`
`static boolean` | `almostEquals(double d1, double d2, double epsilon)`
`static double` | `beta(double a, double b)`
`static boolean` | `checkWithinRange(double value, double min, double max)` Checks if `min <= value <= max`.
`static double` | `cosh(double a)`
`static double` | `factorial(int n)`
`static double` | `gamma(double x)`
`static double` | `getEntropy(double[] dist)`
`static double` | `jensenShannonDivergence(double[] p1, double[] p2)` Returns the Jensen-Shannon divergence.
`static double` | `klDivergence(double[] p1, double[] p2)` Returns the KL divergence, K(p1 || p2).
`static double` | `logBeta(double a, double b)`
`static double` | `logBinom(int x, int n, double p)` Computes p(x;n,p) where x~B(n,p)
`static double` | `logFactorial(int n)`
`static double` | `logGamma(double x)`
`static double` | `logit(double p)`
`static double` | `numCombinations(int n, int r)`
`static double` | `numPermutations(int n, int r)`
`static double` | `oldLogGamma(double x)`
`static double` | `pbinom(int x, int n, double p)` Vastly inefficient O(x) method to compute cdf of B(n,p)
`static double` | `sigmod_rev(double sig)`
`static double` | `sigmod(double beta)`
`static double` | `subtractLogProb(double a, double b)` Returns the difference of two doubles expressed in log space, that is,
`static double` | `sumLogProb(double[] vals)` Sums an array of numbers log(x1)...log(xn).
`static double` | `sumLogProb(double a, double b)` Returns the sum of two doubles expressed in log space, that is,
`static double` | `tanh(double a)`

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

Field Detail

### EPSILON

    public static double EPSILON

  Numbers that are closer than this are considered equal by almostEquals.

### log2

    public static final double log2

Constructor Detail

### Maths

    public Maths()

Method Detail

### logGamma

    public static final double logGamma(double x)

### oldLogGamma

    public static double oldLogGamma(double x)

### logBeta

    public static double logBeta(double a,
                                 double b)

### beta

    public static double beta(double a,
                              double b)

### gamma

    public static double gamma(double x)

### factorial

    public static double factorial(int n)

### logFactorial

    public static double logFactorial(int n)

### logBinom

    public static double logBinom(int x,
                                  int n,
                                  double p)

  Computes p(x;n,p) where x~B(n,p)

### pbinom

    public static double pbinom(int x,
                                int n,
                                double p)

  Vastly inefficient O(x) method to compute cdf of B(n,p)

### sigmod

    public static double sigmod(double beta)

### sigmod_rev

    public static double sigmod_rev(double sig)

### logit

    public static double logit(double p)

### numCombinations

    public static double numCombinations(int n,
                                         int r)

### numPermutations

    public static double numPermutations(int n,
                                         int r)

### cosh

    public static double cosh(double a)

### tanh

    public static double tanh(double a)

### almostEquals

    public static boolean almostEquals(double d1,
                                       double d2)

### almostEquals

    public static boolean almostEquals(double d1,
                                       double d2,
                                       double epsilon)

### almostEquals

    public static boolean almostEquals(double[] d1,
                                       double[] d2,
                                       double eps)

### checkWithinRange

    public static boolean checkWithinRange(double value,
                                           double min,
                                           double max)

  Checks if `min <= value <= max`.

### klDivergence

    public static double klDivergence(double[] p1,
                                      double[] p2)

  Returns the KL divergence, K(p1 || p2). The log is w.r.t. base 2.

  *Note*: If any value in `p2` is `0.0` then the KL-divergence is `infinite`.

### jensenShannonDivergence

    public static double jensenShannonDivergence(double[] p1,
                                                 double[] p2)

  Returns the Jensen-Shannon divergence.

### sumLogProb

    public static double sumLogProb(double a,
                                    double b)

  Returns the sum of two doubles expressed in log space, that is,

          sumLogProb = log (e^a + e^b)
                     = log e^a(1 + e^(b-a))
                     = a + log (1 + e^(b-a))

  By exponentiating `b-a`, we obtain better numerical precision than we would if we calculated `e^a` or `e^b` directly.

  Note: This function is just like `sumNegLogProb` in `Transducer`, except that the logs aren't negated.

### sumLogProb

    public static double sumLogProb(double[] vals)

  Sums an array of numbers log(x1)...log(xn). This saves some of the unnecessary calls to Math.log in the two-argument version.

  Note that this implementation IGNORES elements of the input array that are more than LOGTOLERANCE (currently 30.0) less than the maximum element.

  Cursory testing makes me wonder if this is actually much faster than repeated use of the 2-argument version, however -cas.

  Parameters:
    `vals` - An array log(x1), log(x2), ..., log(xn)
  Returns:
    log(x1+x2+...+xn)

### subtractLogProb

    public static double subtractLogProb(double a,
                                         double b)

  Returns the difference of two doubles expressed in log space, that is,

          sumLogProb = log (e^a - e^b)
                     = log e^a(1 - e^(b-a))
                     = a + log (1 - e^(b-a))

  By exponentiating `b-a`, we obtain better numerical precision than we would if we calculated `e^a` or `e^b` directly.

  Returns `NaN` if b > a (so that log(e^a - e^b) is undefined).

### getEntropy

    public static double getEntropy(double[] dist)

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD