edu.umass.cs.mallet.base.util

Class Maths

java.lang.Object

edu.umass.cs.mallet.base.util.Maths

public final class Maths
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
static double	EPSILON Numbers that are closer than this are considered equal by almostEquals.

Constructor Summary

Constructors

Constructor and Description
Maths()

Method Summary

Modifier and Type	Method and Description
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 double	cosh(double a)
static double	factorial(int n)
static double	gamma(double x)
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	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.

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)

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)

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.

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).