edu.stanford.nlp.math
Class SloppyMath

java.lang.Object
  |
  +--edu.stanford.nlp.math.SloppyMath

public final class SloppyMath

extends Object

The class SloppyMath contains methods for performing basic numeric operations. In some cases, such as max and min, they cut a few corners in the implementation for the sake of efficiency. In particular, they may not handle special notions like NaN and -0.0 correctly. This was the origin of the class name, but some other operations are just useful math additions, such as logSum.

Constructor Summary

SloppyMath()

Method Summary

static boolean	isDangerous(double d) Returns true if the argument is a "dangerous" double to have around, namely one that is infinite, NaN or zero.
static boolean	isVeryDangerous(double d) Returns true if the argument is a "very dangerous" double to have around, namely one that is infinite or NaN.
static double	logAdd(double lx, double ly) Returns the log of the sum of two numbers, which are themselves input in log form.
static double	logSum(double[] logInputs) Returns the log of the sum of an array of numbers, which are themselves input in log form.
static double	max(double a, double b) Returns the greater of two double values.
static float	max(float a, float b) Returns the greater of two float values.
static double	min(double a, double b) Returns the smaller of two double values.
static float	min(float a, float b) Returns the smaller of two float values.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SloppyMath

public SloppyMath()

Method Detail

max

public static float max(float a,
                        float b)

Returns the greater of two float values. That is, the result is the argument closer to positive infinity. If the arguments have the same value, the result is that same value. Does none of the special checks for NaN or -0.0f that Math.max does.

Parameters:

a - an argument.

b - another argument.

Returns:

the larger of a and b.

max

public static double max(double a,
                         double b)

Returns the greater of two double values. That is, the result is the argument closer to positive infinity. If the arguments have the same value, the result is that same value. Does none of the special checks for NaN or -0.0f that Math.max does.

Parameters:

a - an argument.

b - another argument.

Returns:

the larger of a and b.

min

public static float min(float a,
                        float b)

Returns the smaller of two float values. That is, the result is the value closer to negative infinity. If the arguments have the same value, the result is that same value. Does none of the special checks for NaN or -0.0f that Math.max does.

Parameters:

a - an argument.

b - another argument.

Returns:

the smaller of a and b.

min

public static double min(double a,
                         double b)

Returns the smaller of two double values. That is, the result is the value closer to negative infinity. If the arguments have the same value, the result is that same value. Does none of the special checks for NaN or -0.0f that Math.max does.

Parameters:

a - an argument.

b - another argument.

Returns:

the smaller of a and b.

isDangerous

public static boolean isDangerous(double d)

Returns true if the argument is a "dangerous" double to have around, namely one that is infinite, NaN or zero.

isVeryDangerous

public static boolean isVeryDangerous(double d)

Returns true if the argument is a "very dangerous" double to have around, namely one that is infinite or NaN.

logSum

public static double logSum(double[] logInputs)

Returns the log of the sum of an array of numbers, which are themselves input in log form. This is all natural logarithms. Reasonable care is taken to do this as efficiently as possible (under the assumption that the numbers might differ greatly in magnitude), with high accuracy, and without numerical overflow.

Returns:

log(x1 + ... + xn)

logAdd

public static double logAdd(double lx,
                            double ly)

Returns the log of the sum of two numbers, which are themselves input in log form. This uses natural logarithms. Reasonable care is taken to do this as efficiently as possible (under the assumption that the numbers might differ greatly in magnitude), with high accuracy, and without numerical overflow.

Parameters:

lx - First number, in log form

ly - Second number, in log form

Returns:

log(exp(lx) + exp(ly))