/// <summary>
/// Returns the integral from <tt>x</tt> to infinity of the gamma
/// probability density function:
/// <pre>
/// inf.
/// b -
/// a | | b-1 -at
/// y = ----- | t e dt
/// - | |
/// | (b) -
/// x
/// </pre>
/// The incomplete gamma integral is used, according to the
/// relation
/// <para>
/// y = Gamma.incompleteGammaComplement( b, a*x ).
///
/// </para>
/// </summary>
/// <param name="a"> the paramater a (alpha) of the gamma distribution. </param>
/// <param name="b"> the paramater b (beta, lambda) of the gamma distribution. </param>
/// <param name="x"> integration end point. </param>
/// <returns> result </returns>
public static double gammaComplemented(double a, double b, double x)
{
if (x < 0.0)
{
return(0.0);
}
return(GammaFunctions.incompleteGammaComplement(b, a * x));
}
/// <summary>
/// Returns the area under the right hand tail (from <tt>x</tt> to
/// infinity) of the Chi square probability density function
/// with <tt>v</tt> degrees of freedom.
/// <pre>
/// inf.
/// -
/// 1 | | v/2-1 -t/2
/// P( x | v ) = ----------- | t e dt
/// v/2 - | |
/// 2 | (v/2) -
/// x
/// </pre>
/// where <tt>x</tt> is the Chi-square variable.
///
/// The incomplete gamma integral is used, according to the
/// formula
///
/// <tt>y = chiSquareComplemented( v, x ) = incompleteGammaComplement( v/2.0, x/2.0 )</tt>.
///
///
/// The arguments must both be positive.
/// </summary>
/// <param name="v"> degrees of freedom. </param>
/// <param name="x"> x </param>
/// <returns> result </returns>
/// <exception cref="ArithmeticException"> error </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static double chiSquareComplemented(double v, double x) throws ArithmeticException
public static double chiSquareComplemented(double v, double x)
{
if (x < 0.0 || v < 1.0)
{
return(0.0);
}
return(GammaFunctions.incompleteGammaComplement(v / 2.0, x / 2.0));
}
/// <summary>
/// Returns the sum of the terms <tt>k+1</tt> to <tt>Infinity</tt> of the Poisson distribution.
/// <pre>
/// inf. j
/// -- -m m
/// > e --
/// -- j!
/// j=k+1
/// </pre>
/// The terms are not summed directly; instead the incomplete
/// gamma integral is employed, according to the formula
/// <para>
/// <tt>y = poissonComplemented( k, m ) = Gamma.incompleteGamma( k+1, m )</tt>.
///
/// The arguments must both be positive.
///
/// </para>
/// </summary>
/// <param name="k"> start term. </param>
/// <param name="mean"> the mean of the poisson distribution. </param>
/// <returns> result </returns>
/// <exception cref="ArithmeticException"> error </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static double poissonComplemented(int k, double mean) throws ArithmeticException
public static double poissonComplemented(int k, double mean)
{
if (mean < 0)
{
throw new System.ArgumentException();
}
if (k < -1)
{
return(0.0);
}
return(GammaFunctions.incompleteGamma((double)(k + 1), mean));
}
/// <summary>
/// Returns the sum of the terms <tt>k+1</tt> to infinity of the Negative
/// Binomial distribution.
/// <pre>
/// inf
/// -- ( n+j-1 ) n j
/// > ( ) p (1-p)
/// -- ( j )
/// j=k+1
/// </pre>
/// The terms are not computed individually; instead the incomplete
/// beta integral is employed, according to the formula
/// <para>
/// y = negativeBinomialComplemented( k, n, p ) = Gamma.incompleteBeta( k+1, n, 1-p ).
///
/// All arguments must be positive,
/// </para>
/// </summary>
/// <param name="k"> end term. </param>
/// <param name="n"> the number of trials. </param>
/// <param name="p"> the probability of success (must be in <tt>(0.0,1.0)</tt>). </param>
/// <returns> result </returns>
public static double negativeBinomialComplemented(int k, int n, double p)
{
if ((p < 0.0) || (p > 1.0))
{
throw new System.ArgumentException();
}
if (k < 0)
{
return(0.0);
}
return(GammaFunctions.incompleteBeta(k + 1, n, 1.0 - p));
}
/// <summary>
/// Power series for incomplete beta integral; formerly named <tt>pseries</tt>.
/// Use when b*x is small and x not too close to 1.
/// </summary>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: static double powerSeries(double a, double b, double x) throws ArithmeticException
internal static double powerSeries(double a, double b, double x)
{
double s, t, u, v, n, t1, z, ai;
ai = 1.0 / a;
u = (1.0 - b) * x;
v = u / (a + 1.0);
t1 = v;
t = u;
n = 2.0;
s = 0.0;
z = MACHEP * ai;
while (Math.Abs(v) > z)
{
u = (n - b) * x / n;
t *= u;
v = t / (a + n);
s += v;
n += 1.0;
}
s += t1;
s += ai;
u = a * Math.Log(x);
if ((a + b) < MAXGAM && Math.Abs(u) < MAXLOG)
{
t = GammaFunctions.gamma(a + b) / (GammaFunctions.gamma(a) * GammaFunctions.gamma(b));
s = s * t * Math.Pow(x, a);
}
else
{
t = GammaFunctions.logGamma(a + b) - GammaFunctions.logGamma(a) - GammaFunctions.logGamma(b) + u + Math.Log(s);
if (t < MINLOG)
{
s = 0.0;
}
else
{
s = Math.Exp(t);
}
}
return(s);
}
/// <summary>
/// Returns the integral from minus infinity to <tt>t</tt> of the Student-t
/// distribution with <tt>k > 0</tt> degrees of freedom.
/// <pre>
/// t
/// -
/// | |
/// - | 2 -(k+1)/2
/// | ( (k+1)/2 ) | ( x )
/// ---------------------- | ( 1 + --- ) dx
/// - | ( k )
/// sqrt( k pi ) | ( k/2 ) |
/// | |
/// -
/// -inf.
/// </pre>
/// Relation to incomplete beta integral:
/// <para>
/// <tt>1 - studentT(k,t) = 0.5 * Gamma.incompleteBeta( k/2, 1/2, z )</tt>
/// where <tt>z = k/(k + t**2)</tt>.
/// </para>
/// <para>
/// Since the function is symmetric about <tt>t=0</tt>, the area under the
/// right tail of the density is found by calling the function
/// with <tt>-t</tt> instead of <tt>t</tt>.
///
/// </para>
/// </summary>
/// <param name="k"> degrees of freedom. </param>
/// <param name="t"> integration end point. </param>
/// <returns> result </returns>
/// <exception cref="ArithmeticException"> error </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static double studentT(double k, double t) throws ArithmeticException
public static double studentT(double k, double t)
{
if (k <= 0)
{
throw new System.ArgumentException();
}
if (t == 0)
{
return(0.5);
}
double cdf = 0.5 * GammaFunctions.incompleteBeta(0.5 * k, 0.5, k / (k + t * t));
if (t >= 0)
{
cdf = 1.0 - cdf; // fixes bug reported by [email protected]
}
return(cdf);
}
/// <summary>
/// Returns the sum of the terms <tt>k+1</tt> through <tt>n</tt> of the Binomial
/// probability density.
/// <pre>
/// n
/// -- ( n ) j n-j
/// > ( ) p (1-p)
/// -- ( j )
/// j=k+1
/// </pre>
/// The terms are not summed directly; instead the incomplete
/// beta integral is employed, according to the formula
/// <para>
/// <tt>y = binomialComplemented( k, n, p ) = Gamma.incompleteBeta( k+1, n-k, p )</tt>.
/// </para>
/// <para>
/// All arguments must be positive,
/// </para>
/// </summary>
/// <param name="k"> end term. </param>
/// <param name="n"> the number of trials. </param>
/// <param name="p"> the probability of success (must be in <tt>(0.0,1.0)</tt>). </param>
/// <returns> result </returns>
/// <exception cref="ArithmeticException"> error </exception>
public static double binomialComplemented(int k, int n, double p)
{
if ((p < 0.0) || (p > 1.0))
{
throw new System.ArgumentException();
}
if ((k < 0) || (n < k))
{
throw new System.ArgumentException();
}
if (k == n)
{
return(0.0);
}
if (k == 0)
{
return(1.0 - Math.Pow(1.0 - p, n - k));
}
return(GammaFunctions.incompleteBeta(k + 1, n - k, p));
}
/// <summary>
/// Returns the area from zero to <tt>x</tt> under the beta density
/// function.
/// <pre>
/// x
/// - -
/// | (a+b) | | a-1 b-1
/// P(x) = ---------- | t (1-t) dt
/// - - | |
/// | (a) | (b) -
/// 0
/// </pre>
/// This function is identical to the incomplete beta
/// integral function <tt>Gamma.incompleteBeta(a, b, x)</tt>.
///
/// The complemented function is
///
/// <tt>1 - P(1-x) = Gamma.incompleteBeta( b, a, x )</tt>;
/// </summary>
/// <param name="a"> a </param>
/// <param name="b"> b </param>
/// <param name="x"> x </param>
/// <returns> result </returns>
/// <exception cref="ArithmeticException"> error </exception>
public static double beta(double a, double b, double x)
{
return(GammaFunctions.incompleteBeta(a, b, x));
}
/// <summary>
/// Returns the area under the right hand tail (from <tt>x</tt> to
/// infinity) of the beta density function.
///
/// This function is identical to the incomplete beta
/// integral function <tt>Gamma.incompleteBeta(b, a, x)</tt>.
/// </summary>
/// <param name="a"> a </param>
/// <param name="b"> b </param>
/// <param name="x"> x </param>
/// <returns> result </returns>
/// <exception cref="ArithmeticException"> error </exception>
public static double betaComplemented(double a, double b, double x)
{
return(GammaFunctions.incompleteBeta(b, a, x));
}
