Parallel Colt 0.7.2

## cern.jet.math.tfloat Class FloatArithmetic

```java.lang.Object cern.jet.math.tfloat.FloatConstants cern.jet.math.tfloat.FloatArithmetic
```

`public class FloatArithmeticextends FloatConstants`

Arithmetic functions.

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

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

### floor

`public static long floor(float 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 float log(float base,
float value)```
Returns logbasevalue.

### log10

`public static float log10(float value)`
Returns log10value.

### log2

`public static float log2(float value)`
Returns log2value.

### logFactorial

`public static float 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 float 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)

Parallel Colt 0.7.2