SpecialMath (Java Statistical Analysis Tool 0.0.8 API)

java.lang.Object
- jsat.math.SpecialMath

```
public class SpecialMath
extends Object
```
This class provides static methods for computing accurate approximations to many special functions.

All methods should return absolute differences of less than 10^-9 for all reasonable values. Unreasonable values would be those in areas of high change (such as those approaching positive / negative infinity).

Author:

Edward Raff

Constructor Summary

Constructors
Constructor and Description

SpecialMath()

Constructors
Constructor and Description
`SpecialMath()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`bernoulli(int n)` Computes an approximation to the n'th Bernoulli number B_n.
`static double`	`beta(double z, double w)` Computes the Beta function B(z,w)
`static double`	`betaIncReg(double x, double a, double b)` Computes the regularized incomplete beta function, I_x(a, b).
`static double`	`digamma(double x)` Computes the value of the digamma function, Ψ(x), which is the derivative of `lnGamma(double)`.
`static double`	`erf(double x)`
`static double`	`erfc(double x)`
`static double`	`gamma(double z)` The gamma function is a generalization of the factorial function.
`static double`	`gammaIncLow(double a, double z)` Computes the lower incomplete gamma function, γ(a,z).
`static double`	`gammaIncUp(double a, double z)` Computes the incomplete gamma function, Γ(a,z).
`static double`	`gammaP(double a, double z)` Returns the regularized gamma function P(a,z) = γ(a,z)/Γ(a).
`static double`	`gammaPSeries(double a, double z)`
`static double`	`gammaQ(double a, double z)` Computes the regularized gamma function Q(a,z) = Γ(a,z)/Γ(a).
`static double`	`invBetaIncReg(double p, double a, double b)` Computes the inverse of the incomplete beta function, I_p^-1(a,b), such that `I_x(a, b)` = `p`.
`static double`	`invErf(double x)`
`static double`	`invErfc(double x)`
`static double`	`invGammaP(double p, double a)` Finds the value `x` such that `P(a,x)` = `p`.
`static double`	`invXlnX(double y)`
`static double`	`lnBeta(double z, double w)`
`static double`	`lnGamma(double z)` Computes the natural logarithm of `gamma(double)`.
`static double`	`reLnBn(int n)` Computes the real part of the natural logarithm of the Bernoulli numbers.
`static double`	`zeta(double x)` Computes the Riemann zeta function ζ(x) for some value of x This method may return: `Double.NaN` for x = 1 (would be complex infinity) NOTE: This method is not yet complete in terms of accuracy.

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

- Constructor Detail
  - SpecialMath
```
public SpecialMath()
```
- Method Detail
  - invXlnX
```
public static double invXlnX(double y)
```
  - gamma
```
public static double gamma(double z)
```
    The gamma function is a generalization of the factorial function. This method provides the gamma function for values from -Infinity to Infinity.
    Special Values:
    - Double.NaN returned if z = 0 or z = Double.NEGATIVE_INFINITY
    Parameters:
    
    z - any real value
    
    Returns:
    
    Γ(z)
  - lnGamma
```
public static double lnGamma(double z)
```
    Computes the natural logarithm of gamma(double). This method is more numerically stable than taking the log of the result of Γ(z).
    Special Values:
    - Double.POSITIVE_INFINITY returned if z ≤ 0
    - Double.NaN returned if z = Double.NEGATIVE_INFINITY
    Parameters:
    
    z - any real number value
    
    Returns:
    
    Log(Γ(z))
  - digamma
```
public static double digamma(double x)
```
    Computes the value of the digamma function, Ψ(x), which is the derivative of lnGamma(double).
    
    This method may return:
    - Double.NaN for zero and negative integer values (would be complex infinity)
    This method should be accurate to an absolute difference of 10^-14 for all values that are not near an asymptote.
    Parameters:
    
    x - the value to compute the digamma function at
    
    Returns:
    
    the value of Ψ(x)
  - zeta
```
public static double zeta(double x)
```
    Computes the Riemann zeta function ζ(x) for some value of x
    
    This method may return:
    - Double.NaN for x = 1 (would be complex infinity)
    NOTE: This method is not yet complete in terms of accuracy.
    - For x < -0.5, the values returned will be of the correct magnitude - but are not very accurate
    - For x in [-0.5, 2.5], the values returned will be of reasonable accurate (absolute difference around 10^-7), unless it is very close to 1
    - For x > 2.5, the result will be very accurate (absolute difference less than 10^-14
    Parameters:
    
    x - a real valued input
    
    Returns:
    
    ζ(x)
  - reLnBn
```
public static double reLnBn(int n)
```
    Computes the real part of the natural logarithm of the Bernoulli numbers.
    The Bernoulli zeros for odd n will return Double.NEGATIVE_INFINITY and for any value less than 0 will return Double.NaN.
    
    Currently only accurate to an absolute difference of 10^-11
    
    Parameters:
    
    n - the integer Bernoulli value to obtain an approximation of
    
    Returns:
    
    Re(Log(B_n))
  - bernoulli
```
public static double bernoulli(int n)
```
    Computes an approximation to the n'th Bernoulli number B_n. The Bernoulli numbers grow in value rapidly, and so the accuracy of this method decays quickly. n > 20 should have the correct order of magnitude, but may not have many significant figures. reLnBn(int) should be used instead when possible.
    
    Parameters:
    
    n - the bernoulli number to compute
    
    Returns:
    
    B_n
  - erf
```
public static double erf(double x)
```
  - invErf
```
public static double invErf(double x)
```
  - erfc
```
public static double erfc(double x)
```
  - invErfc
```
public static double invErfc(double x)
```
  - beta
```
public static double beta(double z,
                          double w)
```
    Computes the Beta function B(z,w)
    
    Parameters:
    
    z -
    
    w -
    
    Returns:
    
    B(z,w)
  - lnBeta
```
public static double lnBeta(double z,
                            double w)
```
  - betaIncReg
```
public static double betaIncReg(double x,
                                double a,
                                double b)
```
    Computes the regularized incomplete beta function, I_x(a, b). The result of which is always in the range [0, 1]
    
    Parameters:
    
    x - any value in the range [0, 1]
    
    a - any value ≥ 0
    
    b - any value ≥ 0
    
    Returns:
    
    the result in a range of [0,1]
  - invBetaIncReg
```
public static double invBetaIncReg(double p,
                                   double a,
                                   double b)
```
    Computes the inverse of the incomplete beta function, I_p^-1(a,b), such that I_x(a, b) = p. The returned value, x, will always be in the range [0,1]. The input p, must also be in the range [0,1].
    
    Parameters:
    
    p - any value in the range [0,1]
    
    a - any value ≥ 0
    
    b - any value ≥ 0
    
    Returns:
    
    the value x, such that I_x(a, b) will return p.
  - gammaQ
```
public static double gammaQ(double a,
                            double z)
```
    Computes the regularized gamma function Q(a,z) = Γ(a,z)/Γ(a).
    This method is more numerically stable and accurate than computing it via the direct method, and is always in the range [0,1].
    
    Note: The this method returns Double.NaN for a<0, though real values of Q(a,z) do exist
    
    Parameters:
    
    a - any value ≥ 0
    
    z - any value > 0
    
    Returns:
    
    Q(a,z)
  - gammaPSeries
```
public static double gammaPSeries(double a,
                                  double z)
```
  - gammaP
```
public static double gammaP(double a,
                            double z)
```
    Returns the regularized gamma function P(a,z) = γ(a,z)/Γ(a).
    This method is more numerically stable and accurate than computing it via the direct method, and is always in the range [0,1].
    
    Note: The this method returns Double.NaN for a<0, though real values of P(a,z) do exist
    
    Parameters:
    
    a - any value ≥ 0
    
    z - any value > 0
    
    Returns:
    
    P(a,z)
  - invGammaP
```
public static double invGammaP(double p,
                               double a)
```
    Finds the value x such that P(a,x) = p.
    
    Parameters:
    
    a - any real value
    
    p - and value in the range [0, 1]
    
    Returns:
    
    the inverse
  - gammaIncUp
```
public static double gammaIncUp(double a,
                                double z)
```
    Computes the incomplete gamma function, Γ(a,z).
    Returns Double.NaN for z ≤ 0
    
    Parameters:
    
    a - any value (-∞, ∞)
    
    z - any value > 0
    
    Returns:
    
    Γ(a,z)
  - gammaIncLow
```
public static double gammaIncLow(double a,
                                 double z)
```
    Computes the lower incomplete gamma function, γ(a,z).
    Returns Double.NaN for z ≤ 0
    
    Parameters:
    
    a - any value (-∞, ∞)
    
    z - any value > 0
    
    Returns:
    
    γ(a,z)

Class SpecialMath

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SpecialMath

Method Detail

invXlnX

gamma

lnGamma

digamma

zeta

reLnBn

bernoulli

erf

invErf

erfc

invErfc

beta

lnBeta

betaIncReg

invBetaIncReg

gammaQ

gammaPSeries

gammaP

invGammaP

gammaIncUp

gammaIncLow