Colt 1.2.0

## cern.jet.math Class Arithmetic

```java.lang.Object cern.jet.math.Constants cern.jet.math.Arithmetic
```

public class Arithmetic
extends Constants

Arithmetic functions.

 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 `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

 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 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:
`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 IllegalArgumentException```
Instantly returns the factorial k!.

Parameters:
`k` - must hold k >= 0 && k < 21.
Throws:
`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)

Colt 1.2.0