sim.util.distribution

## Class Arithmetic

• All Implemented Interfaces:
java.io.Serializable

```public class Arithmetic
extends Constants
implements java.io.Serializable```
Arithmetic functions.
Serialized Form
• ### Field Summary

Fields
Modifier and Type Field and Description
`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

Constructors
Modifier Constructor and Description
`protected ` `Arithmetic()`
Makes this class non instantiable, but still let's others inherit from it.
• ### Method Summary

Methods
Modifier and Type Method and Description
`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`
Constant Field Values
• #### MAXLOG

`protected static final double MAXLOG`
Constant Field Values
• #### MINLOG

`protected static final double MINLOG`
Constant Field Values
• #### MAXGAM

`protected static final double MAXGAM`
Constant Field Values
• #### SQTPI

`protected static final double SQTPI`
Constant Field Values
• #### SQRTH

`protected static final double SQRTH`
Constant Field Values
• #### LOGPI

`protected static final double LOGPI`
Constant Field Values
• #### big

`protected static final double big`
Constant Field Values
• #### biginv

`protected static final double biginv`
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)