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

## sim.util.distribution
Class Arithmetic

    java.lang.Object
      sim.util.distribution.Constants
          sim.util.distribution.Arithmetic

All Implemented Interfaces:
  java.io.Serializable

    public class Arithmetic

extends Constants
implements java.io.Serializable

Arithmetic functions.

See Also:
  Serialized Form

Field Summary
`protected static double` | `big`
`protected static double` | `biginv`
`protected static double[]` | `doubleFactorials`
`protected static double[]` | `logFactorials`
`protected static double` | `LOGPI`
`protected static long[]` | `longFactorials`
`protected static double` | `MACHEP`
`protected static double` | `MAXGAM`
`protected static double` | `MAXLOG`
`protected static double` | `MINLOG`
`protected static double` | `SQRTH`
`protected static double` | `SQTPI`

Constructor Summary
`protected` | `Arithmetic()` Makes this class non instantiable, but still let's others inherit from it.

Method Summary
`static double` | `binomial(double n, long k)` Efficiently returns the binomial coefficient, often also referred to as "n over k" or "n choose k".
`static double` | `binomial(long n, long k)` Efficiently returns the binomial coefficient, often also referred to as "n over k" or "n choose k".
`static long` | `ceil(double value)` Returns the smallest `long >= value`.
`static double` | `chbevl(double x, double[] coef, int N)` Evaluates the series of Chebyshev polynomials Ti at argument x/2.
`static double` | `factorial(int k)` Instantly returns the factorial `k!`.
`static long` | `floor(double value)` Returns the largest `long <= value`.
`static double` | `log(double base, double value)` Returns `logbasevalue`.
`static double` | `log10(double value)` Returns `log10value`.
`static double` | `log2(double value)` Returns `log2value`.
`static double` | `logFactorial(int k)` Returns `log(k!)`.
`static long` | `longFactorial(int k)` Instantly returns the factorial `k!`.
`static double` | `stirlingCorrection(int k)` Returns the StirlingCorrection.

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

Field Detail

### MACHEP

    protected static final double MACHEP

See Also:
  Constant Field Values

### MAXLOG

    protected static final double MAXLOG

See Also:
  Constant Field Values

### MINLOG

    protected static final double MINLOG

See Also:
  Constant Field Values

### MAXGAM

    protected static final double MAXGAM

See Also:
  Constant Field Values

### SQTPI

    protected static final double SQTPI

See Also:
  Constant Field Values

### SQRTH

    protected static final double SQRTH

See Also:
  Constant Field Values

### LOGPI

    protected static final double LOGPI

See Also:
  Constant Field Values

### big

    protected static final double big

See Also:
  Constant Field Values

### biginv

    protected static final double biginv

See Also:
  Constant Field Values

### logFactorials

    protected static final double[] logFactorials

### longFactorials

    protected static final long[] longFactorials

### doubleFactorials

    protected static final double[] doubleFactorials

Constructor Detail

### Arithmetic

    protected Arithmetic()

  Makes this class non instantiable, but still let's others inherit from it.

Method Detail

### binomial

    public static double binomial(double n,
                                  long k)

  Efficiently returns the binomial coefficient, often also referred to as "n over k" or "n choose k". The binomial coefficient is defined as `(n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )`.
  - k<0`: `0`.`
  - k==0`: `1`.`
  - k==1`: `n`.`
  - else: `(n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )`.

  Returns:
    the binomial coefficient.

### binomial

    public static double binomial(long n,
                                  long k)

  Efficiently returns the binomial coefficient, often also referred to as "n over k" or "n choose k". The binomial coefficient is defined as
  - k<0`: `0`.`
  - k==0 || k==n`: `1`.`
  - k==1 || k==n-1`: `n`.`
  - else: `(n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )`.

  Returns:
    the binomial coefficient.

### ceil

    public static long ceil(double value)

  Returns the smallest `long >= value`.
Examples: `1.0 -> 1, 1.2 -> 2, 1.9 -> 2`. This method is safer than using (long) Math.ceil(value), because of possible rounding error.

### chbevl

    public static double chbevl(double x,
                                double[] coef,
                                int N)
                         throws java.lang.ArithmeticException

  Evaluates the series of Chebyshev polynomials Ti at argument x/2. The series is given by

              N-1
               - '
        y  =   >   coef[i] T (x/2)
               -            i
              i=0

  Coefficients are stored in reverse order, i.e. the zero order term is last in the array. Note N is the number of coefficients, not the order.

  If coefficients are for the interval a to b, x must have been transformed to x -> 2(2x - b - a)/(b-a) before entering the routine. This maps x from (a, b) to (-1, 1), over which the Chebyshev polynomials are defined.

  If the coefficients are for the inverted interval, in which (a, b) is mapped to (1/b, 1/a), the transformation required is x -> 2(2ab/x - b - a)/(b-a). If b is infinity, this becomes x -> 4a/x - 1.

  SPEED:

  Taking advantage of the recurrence properties of the Chebyshev polynomials, the routine requires one more addition per loop than evaluating a nested polynomial of the same degree.

  Parameters:
    `x` - argument to the polynomial.
    `coef` - the coefficients of the polynomial.
    `N` - the number of coefficients.
  Throws:
    `java.lang.ArithmeticException`

### factorial

    public static double factorial(int k)

  Instantly returns the factorial `k!`.

  Parameters:
    `k` - must hold `k >= 0`.

### floor

    public static long floor(double value)

  Returns the largest `long <= value`.
Examples: `1.0 -> 1, 1.2 -> 1, 1.9 -> 1`
2.0 -> 2, 2.2 -> 2, 2.9 -> 2
This method is safer than using (long) Math.floor(value), because of possible rounding error.

### log

    public static double log(double base,
                             double value)

  Returns `logbasevalue`.

### log10

    public static double log10(double value)

  Returns `log10value`.

### log2

    public static double log2(double value)

  Returns `log2value`.

### logFactorial

    public static double logFactorial(int k)

  Returns `log(k!)`. Tries to avoid overflows. For `k<30` simply looks up a table in O(1). For `k>=30` uses stirlings approximation.

  Parameters:
    `k` - must hold `k >= 0`.

### longFactorial

    public static long longFactorial(int k)
                              throws java.lang.IllegalArgumentException

  Instantly returns the factorial `k!`.

  Parameters:
    `k` - must hold `k >= 0 && k < 21`.
  Throws:
    `java.lang.IllegalArgumentException`

### stirlingCorrection

    public static double stirlingCorrection(int k)

  Returns the StirlingCorrection.

  Correction term of the Stirling approximation for `log(k!)` (series in 1/k, or table values for small k) with int parameter k.

  `log k! = (k + 1/2)log(k + 1) - (k + 1) + (1/2)log(2Pi) + stirlingCorrection(k + 1)`

  log k! = (k + 1/2)log(k) - k + (1/2)log(2Pi) + stirlingCorrection(k)

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