SloppyMath (deeplearning4j-core 0.0.3 API)

java.lang.Object
- org.deeplearning4j.berkeley.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.

Version:

2003/01/02

Author:

Christopher Manning

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`LOGTOLERANCE` If a difference is bigger than this in log terms, then the sum or difference of them will just be the larger (to 12 or so decimal places for double, and 7 or 8 for float).

Constructor Summary

Constructors
Constructor and Description

SloppyMath()

Constructors
Constructor and Description
`SloppyMath()`

Method Summary

Methods
Modifier and Type	Method and Description
`static double`	`abs(double x)`
`static float`	`addExp_Old(float[] logV)` Similar to logAdd, but without the final log.
`static float`	`addExp(float[] logV, int lastIndex)`
`static double`	`approxExp(double val)`
`static double`	`approxLog(double val)`
`static double`	`approxPow(double a, double b)`
`static double`	`chiSquare2by2(int k, int n, int r, int m)` Find a 2x2 chi-square value.
`static double`	`exactBinomial(int k, int n, double p)` Find a one tailed exact binomial test probability.
`static double`	`exp(double logX)`
`static double`	`hypergeometric(int k, int n, int r, int m)` Find a hypergeometric distribution.
`static double`	`intPow(double b, int e)` exponentiation like we learned in grade school: multiply b by itself e times.
`static float`	`intPow(float b, int e)` exponentiation like we learned in grade school: multiply b by itself e times.
`static int`	`intPow(int b, int e)` exponentiation like we learned in grade school: multiply b by itself e times.
`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`	`isDangerous(float d)`
`static boolean`	`isDiscreteProb(double d, double tol)`
`static boolean`	`isGreater(double x, double y)`
`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`	`lambert(double v, double u)`
`static float`	`logAdd_Old(float[] logV)`
`static <T> double`	`logAdd(Counter<T> counts)`
`static double`	`logAdd(double[] logV)`
`static double`	`logAdd(double[] logV, int lastIndex)`
`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`	`logAdd(float[] logV)`
`static float`	`logAdd(float[] logV, int lastIndex)`
`static float`	`logAdd(float lx, float ly)` Returns the log of the sum of two numbers, which are themselves input in log form.
`static double`	`logAdd(List<Double> logV)`
`static void`	`logNormalize(double[] logV)`
`static double`	`logSubtract(double a, double b)`
`static void`	`main(String[] args)` Tests the hypergeometric distribution code, or other functions provided in this module.
`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 int`	`max(int a, int b, int c)` Returns the minimum of three int 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.
`static int`	`min(int a, int b, int c)` Returns the minimum of three int values.
`static int`	`nChooseK(int n, int k)` Computes n choose k in an efficient way.
`static double`	`noNaNDivide(double num, double denom)`
`static double`	`oneTailedFishersExact(int k, int n, int r, int m)` Find a one-tailed Fisher's exact probability.
`static double`	`relativeDifferance(double a, double b)`
`static double`	`unsafeAdd(double a, double b)`
`static double`	`unsafeSubtract(double a, double b)`

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

- Field Detail
  - LOGTOLERANCE
```
public static final double LOGTOLERANCE
```
    If a difference is bigger than this in log terms, then the sum or difference of them will just be the larger (to 12 or so decimal places for double, and 7 or 8 for float).
    
    See Also:
    Constant Field Values
- Constructor Detail
  - SloppyMath
```
public SloppyMath()
```
- Method Detail
  - abs
```
public static double abs(double x)
```
  - lambert
```
public static double lambert(double v,
             double u)
```
  - max
```
public static int max(int a,
      int b,
      int c)
```
    Returns the minimum of three int values.
  - min
```
public static int min(int a,
      int b,
      int c)
```
    Returns the minimum of three int values.
  - 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.
  - isDangerous
```
public static boolean isDangerous(float d)
```
  - isGreater
```
public static boolean isGreater(double x,
                double y)
```
  - 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.
  - relativeDifferance
```
public static double relativeDifferance(double a,
                        double b)
```
  - isDiscreteProb
```
public static boolean isDiscreteProb(double d,
                     double tol)
```
  - logAdd
```
public static float logAdd(float lx,
           float 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. Also, handle correctly the case of arguments being -Inf (e.g., probability 0).
    
    Parameters:
    lx - First number, in log form
    ly - Second number, in log form
    
    Returns:
    log(exp(lx) + exp(ly))
  - 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. Also, handle correctly the case of arguments being -Inf (e.g., probability 0).
    
    Parameters:
    lx - First number, in log form
    ly - Second number, in log form
    
    Returns:
    log(exp(lx) + exp(ly))
  - logAdd
```
public static double logAdd(float[] logV)
```
  - logNormalize
```
public static void logNormalize(double[] logV)
```
  - logAdd
```
public static double logAdd(double[] logV)
```
  - logAdd
```
public static double logAdd(List<Double> logV)
```
  - logAdd_Old
```
public static float logAdd_Old(float[] logV)
```
  - logAdd
```
public static float logAdd(float[] logV,
           int lastIndex)
```
  - logAdd
```
public static double logAdd(double[] logV,
            int lastIndex)
```
  - addExp_Old
```
public static float addExp_Old(float[] logV)
```
    Similar to logAdd, but without the final log. I.e. Sum_i exp(logV_i)
    
    Parameters:
    logV -
    
    Returns:
  - addExp
```
public static float addExp(float[] logV,
           int lastIndex)
```
  - nChooseK
```
public static int nChooseK(int n,
           int k)
```
    Computes n choose k in an efficient way. Works with k == 0 or k == n but undefined if k < 0 or k > n
    
    Parameters:
    n -
    k -
    
    Returns:
    fact(n) / fact(k) * fact(n-k)
  - intPow
```
public static int intPow(int b,
         int e)
```
    exponentiation like we learned in grade school: multiply b by itself e times. Uses power of two trick. e must be nonnegative!!! no checking!!!
    
    Parameters:
    b - base
    e - exponent
    
    Returns:
    b^e
  - intPow
```
public static float intPow(float b,
           int e)
```
    exponentiation like we learned in grade school: multiply b by itself e times. Uses power of two trick. e must be nonnegative!!! no checking!!!
    
    Parameters:
    b - base
    e - exponent
    
    Returns:
    b^e
  - intPow
```
public static double intPow(double b,
            int e)
```
    exponentiation like we learned in grade school: multiply b by itself e times. Uses power of two trick. e must be nonnegative!!! no checking!!!
    
    Parameters:
    b - base
    e - exponent
    
    Returns:
    b^e
  - hypergeometric
```
public static double hypergeometric(int k,
                    int n,
                    int r,
                    int m)
```
    Find a hypergeometric distribution. This uses exact math, trying fairly hard to avoid numeric overflow by interleaving multiplications and divisions. (To do: make it even better at avoiding overflow, by using loops that will do either a multiple or divide based on the size of the intermediate result.)
    
    Parameters:
    k - The number of black balls drawn
    n - The total number of balls
    r - The number of black balls
    m - The number of balls drawn
    
    Returns:
    The hypergeometric value
  - exactBinomial
```
public static double exactBinomial(int k,
                   int n,
                   double p)
```
    Find a one tailed exact binomial test probability. Finds the chance of this or a higher result
    
    Parameters:
    k - number of successes
    n - Number of trials
    p - Probability of a success
  - oneTailedFishersExact
```
public static double oneTailedFishersExact(int k,
                           int n,
                           int r,
                           int m)
```
    Find a one-tailed Fisher's exact probability. Chance of having seen this or a more extreme departure from what you would have expected given independence. I.e., k >= the value passed in. Warning: this was done just for collocations, where you are concerned with the case of k being larger than predicted. It doesn't correctly handle other cases, such as k being smaller than expected.
    
    Parameters:
    k - The number of black balls drawn
    n - The total number of balls
    r - The number of black balls
    m - The number of balls drawn
    
    Returns:
    The Fisher's exact p-value
  - chiSquare2by2
```
public static double chiSquare2by2(int k,
                   int n,
                   int r,
                   int m)
```
    Find a 2x2 chi-square value. Note: could do this more neatly using simplified formula for 2x2 case.
    
    Parameters:
    k - The number of black balls drawn
    n - The total number of balls
    r - The number of black balls
    m - The number of balls drawn
    
    Returns:
    The Fisher's exact p-value
  - exp
```
public static double exp(double logX)
```
  - main
```
public static void main(String[] args)
```
    Tests the hypergeometric distribution code, or other functions provided in this module.
    
    Parameters:
    args - Either none, and the log add rountines are tested, or the following 4 arguments: k (cell), n (total), r (row), m (col)
  - noNaNDivide
```
public static double noNaNDivide(double num,
                 double denom)
```
  - approxLog
```
public static double approxLog(double val)
```
  - approxExp
```
public static double approxExp(double val)
```
  - approxPow
```
public static double approxPow(double a,
               double b)
```
  - logSubtract
```
public static double logSubtract(double a,
                 double b)
```
  - unsafeSubtract
```
public static double unsafeSubtract(double a,
                    double b)
```
  - unsafeAdd
```
public static double unsafeAdd(double a,
               double b)
```
  - logAdd
```
public static <T> double logAdd(Counter<T> counts)
```

Class SloppyMath

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOGTOLERANCE

Constructor Detail

SloppyMath

Method Detail

abs

lambert

max

min

max

max

min

min

isDangerous

isDangerous

isGreater

isVeryDangerous

relativeDifferance

isDiscreteProb

logAdd

logAdd

logAdd

logNormalize

logAdd

logAdd

logAdd_Old

logAdd

logAdd

addExp_Old

addExp

nChooseK

intPow

intPow

intPow

hypergeometric

exactBinomial

oneTailedFishersExact

chiSquare2by2

exp

main

noNaNDivide

approxLog

approxExp

approxPow

logSubtract

unsafeSubtract

unsafeAdd

logAdd