forked from tsai/mathnet-numerics
Browse Source
Added incomplete Beta functions. Signed-off-by: jvangael <jurgen.vangael@gmail.com>la-knuth
Jurgen Van Gael
17 years ago
10 changed files with 858 additions and 172 deletions
@ -0,0 +1,386 @@ |
|||||
|
// <copyright file="Gamma.cs" company="Math.NET">
|
||||
|
// Math.NET Numerics, part of the Math.NET Project
|
||||
|
// http://mathnet.opensourcedotnet.info
|
||||
|
//
|
||||
|
// Copyright (c) 2009 Math.NET
|
||||
|
//
|
||||
|
// Permission is hereby granted, free of charge, to any person
|
||||
|
// obtaining a copy of this software and associated documentation
|
||||
|
// files (the "Software"), to deal in the Software without
|
||||
|
// restriction, including without limitation the rights to use,
|
||||
|
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
|
// copies of the Software, and to permit persons to whom the
|
||||
|
// Software is furnished to do so, subject to the following
|
||||
|
// conditions:
|
||||
|
//
|
||||
|
// The above copyright notice and this permission notice shall be
|
||||
|
// included in all copies or substantial portions of the Software.
|
||||
|
//
|
||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
|
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
|
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
|
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
|
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
// </copyright>
|
||||
|
|
||||
|
// <contribution>
|
||||
|
// Cephes Math Library, Stephen L. Moshier
|
||||
|
// ALGLIB, Sergey Bochkanov
|
||||
|
// </contribution>
|
||||
|
|
||||
|
namespace MathNet.Numerics |
||||
|
{ |
||||
|
using System; |
||||
|
using Properties; |
||||
|
|
||||
|
public static partial class SpecialFunctions |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The order of the <see cref="GammaLn"/> approximation.
|
||||
|
/// </summary>
|
||||
|
private const int Gamma_n = 10; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Auxiliary variable when evaluating the <see cref="GammaLn"/> function.
|
||||
|
/// </summary>
|
||||
|
private const double Gamma_r = 10.900511; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Polynomial coefficients for the <see cref="GammaLn"/> approximation.
|
||||
|
/// </summary>
|
||||
|
private static readonly double[] Gamma_dk = |
||||
|
new[] |
||||
|
{ |
||||
|
2.48574089138753565546e-5, |
||||
|
1.05142378581721974210, |
||||
|
-3.45687097222016235469, |
||||
|
4.51227709466894823700, |
||||
|
-2.98285225323576655721, |
||||
|
1.05639711577126713077, |
||||
|
-1.95428773191645869583e-1, |
||||
|
1.70970543404441224307e-2, |
||||
|
-5.71926117404305781283e-4, |
||||
|
4.63399473359905636708e-6, |
||||
|
-2.71994908488607703910e-9 |
||||
|
}; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Computes the logarithm of the Gamma function.
|
||||
|
/// </summary>
|
||||
|
/// <param name="z">The argument of the gamma function.</param>
|
||||
|
/// <returns>The logarithm of the gamma function.</returns>
|
||||
|
/// <remarks>
|
||||
|
/// <para>This implementation of the computation of the gamma and logarithm of the gamma function follows the derivation in
|
||||
|
/// "An Analysis Of The Lanczos Gamma Approximation", Glendon Ralph Pugh, 2004.
|
||||
|
/// We use the implementation listed on p. 116 which achieves an accuracy of 16 floating point digits. Although 16 digit accuracy
|
||||
|
/// should be sufficient for double values, improving accuracy is possible (see p. 126 in Pugh).</para>
|
||||
|
/// <para>Our unit tests suggest that the accuracy of the Gamma function is correct up to 14 floating point digits.</para>
|
||||
|
/// </remarks>
|
||||
|
public static double GammaLn(double z) |
||||
|
{ |
||||
|
if (z < 0.5) |
||||
|
{ |
||||
|
double s = Gamma_dk[0]; |
||||
|
for (int i = 1; i <= Gamma_n; i++) |
||||
|
{ |
||||
|
s += Gamma_dk[i] / (i - z); |
||||
|
} |
||||
|
|
||||
|
return Constants.LnPi |
||||
|
- Math.Log(Math.Sin(Math.PI * z)) |
||||
|
- Math.Log(s) |
||||
|
- Constants.LogTwoSqrtEOverPi |
||||
|
- ((0.5 - z) * Math.Log((0.5 - z + Gamma_r) / Math.E)); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
double s = Gamma_dk[0]; |
||||
|
for (int i = 1; i <= Gamma_n; i++) |
||||
|
{ |
||||
|
s += Gamma_dk[i] / (z + i - 1.0); |
||||
|
} |
||||
|
|
||||
|
return Math.Log(s) |
||||
|
+ Constants.LogTwoSqrtEOverPi |
||||
|
+ ((z - 0.5) * Math.Log((z - 0.5 + Gamma_r) / Math.E)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Computes the Gamma function.
|
||||
|
/// </summary>
|
||||
|
/// <param name="z">The argument of the gamma function.</param>
|
||||
|
/// <returns>The logarithm of the gamma function.</returns>
|
||||
|
/// <remarks>
|
||||
|
/// <para>
|
||||
|
/// This implementation of the computation of the gamma and logarithm of the gamma function follows the derivation in
|
||||
|
/// "An Analysis Of The Lanczos Gamma Approximation", Glendon Ralph Pugh, 2004.
|
||||
|
/// We use the implementation listed on p. 116 which should achieve an accuracy of 16 floating point digits. Although 16 digit accuracy
|
||||
|
/// should be sufficient for double values, improving accuracy is possible (see p. 126 in Pugh).
|
||||
|
/// </para>
|
||||
|
/// <para>Our unit tests suggest that the accuracy of the Gamma function is correct up to 13 floating point digits.</para>
|
||||
|
/// </remarks>
|
||||
|
public static double Gamma(double z) |
||||
|
{ |
||||
|
if (z < 0.5) |
||||
|
{ |
||||
|
double s = Gamma_dk[0]; |
||||
|
for (int i = 1; i <= Gamma_n; i++) |
||||
|
{ |
||||
|
s += Gamma_dk[i] / (i - z); |
||||
|
} |
||||
|
|
||||
|
return Math.PI / (Math.Sin(Math.PI * z) |
||||
|
* s |
||||
|
* Constants.TwoSqrtEOverPi |
||||
|
* Math.Pow((0.5 - z + Gamma_r) / Math.E, 0.5 - z)); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
double s = Gamma_dk[0]; |
||||
|
for (int i = 1; i <= Gamma_n; i++) |
||||
|
{ |
||||
|
s += Gamma_dk[i] / (z + i - 1.0); |
||||
|
} |
||||
|
|
||||
|
return s * Constants.TwoSqrtEOverPi * Math.Pow((z - 0.5 + Gamma_r) / Math.E, z - 0.5); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns the upper incomplete regularized gamma function
|
||||
|
/// Q(a,x) = 1/Gamma(a) * int(exp(-t)t^(a-1),t=0..x) for real a > 0, x > 0.
|
||||
|
/// </summary>
|
||||
|
/// <param name="a">The argument for the gamma function.</param>
|
||||
|
/// <param name="x">The lower integral limit.</param>
|
||||
|
/// <returns>The upper incomplete regularized gamma function.</returns>
|
||||
|
public static double GammaUpperRegularized(double a, double x) |
||||
|
{ |
||||
|
double result = 0; |
||||
|
double igammaepsilon = 0; |
||||
|
double igammabignumber = 0; |
||||
|
double igammabignumberinv = 0; |
||||
|
double ans = 0; |
||||
|
double ax = 0; |
||||
|
double c = 0; |
||||
|
double yc = 0; |
||||
|
double r = 0; |
||||
|
double t = 0; |
||||
|
double y = 0; |
||||
|
double z = 0; |
||||
|
double pk = 0; |
||||
|
double pkm1 = 0; |
||||
|
double pkm2 = 0; |
||||
|
double qk = 0; |
||||
|
double qkm1 = 0; |
||||
|
double qkm2 = 0; |
||||
|
|
||||
|
igammaepsilon = 0.000000000000001; |
||||
|
igammabignumber = 4503599627370496.0; |
||||
|
igammabignumberinv = 2.22044604925031308085 * 0.0000000000000001; |
||||
|
if (x <= 0 | a <= 0) |
||||
|
{ |
||||
|
result = 1; |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
if (x < 1 | x < a) |
||||
|
{ |
||||
|
result = 1 - GammaLowerRegularized(a, x); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
ax = a * Math.Log(x) - x - GammaLn(a); |
||||
|
if (ax < -709.78271289338399) |
||||
|
{ |
||||
|
result = 0; |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
ax = Math.Exp(ax); |
||||
|
y = 1 - a; |
||||
|
z = x + y + 1; |
||||
|
c = 0; |
||||
|
pkm2 = 1; |
||||
|
qkm2 = x; |
||||
|
pkm1 = x + 1; |
||||
|
qkm1 = z * x; |
||||
|
ans = pkm1 / qkm1; |
||||
|
do |
||||
|
{ |
||||
|
c = c + 1; |
||||
|
y = y + 1; |
||||
|
z = z + 2; |
||||
|
yc = y * c; |
||||
|
pk = pkm1 * z - pkm2 * yc; |
||||
|
qk = qkm1 * z - qkm2 * yc; |
||||
|
if (qk != 0) |
||||
|
{ |
||||
|
r = pk / qk; |
||||
|
t = Math.Abs((ans - r) / r); |
||||
|
ans = r; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
t = 1; |
||||
|
} |
||||
|
|
||||
|
pkm2 = pkm1; |
||||
|
pkm1 = pk; |
||||
|
qkm2 = qkm1; |
||||
|
qkm1 = qk; |
||||
|
|
||||
|
if (Math.Abs(pk) > igammabignumber) |
||||
|
{ |
||||
|
pkm2 = pkm2 * igammabignumberinv; |
||||
|
pkm1 = pkm1 * igammabignumberinv; |
||||
|
qkm2 = qkm2 * igammabignumberinv; |
||||
|
qkm1 = qkm1 * igammabignumberinv; |
||||
|
} |
||||
|
} |
||||
|
while (t > igammaepsilon); |
||||
|
|
||||
|
result = ans * ax; |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns the upper incomplete gamma function
|
||||
|
/// Gamma(a,x) = 1/Gamma(a) * int(exp(-t)t^(a-1),t=0..x) for real a > 0, x > 0.
|
||||
|
/// </summary>
|
||||
|
/// <param name="a">The argument for the gamma function.</param>
|
||||
|
/// <param name="x">The lower integral limit.</param>
|
||||
|
/// <returns>The upper incomplete gamma function.</returns>
|
||||
|
public static double GammaUpperIncomplete(double a, double x) |
||||
|
{ |
||||
|
return GammaUpperRegularized(a, x) * Gamma(a); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns the lower incomplete gamma function
|
||||
|
/// gamma(a,x) = int(exp(-t)t^(a-1),t=0..x) for real a > 0, x > 0.
|
||||
|
/// </summary>
|
||||
|
/// <param name="a">The argument for the gamma function.</param>
|
||||
|
/// <param name="x">The upper integral limit.</param>
|
||||
|
/// <returns>The lower incomplete gamma function.</returns>
|
||||
|
public static double GammaLowerIncomplete(double a, double x) |
||||
|
{ |
||||
|
return GammaLowerRegularized(a, x) * Gamma(a); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns the lower incomplete regularized gamma function
|
||||
|
/// P(a,x) = 1/Gamma(a) * int(exp(-t)t^(a-1),t=0..x) for real a > 0, x > 0.
|
||||
|
/// </summary>
|
||||
|
/// <param name="a">The argument for the gamma function.</param>
|
||||
|
/// <param name="x">The upper integral limit.</param>
|
||||
|
/// <returns>The lower incomplete gamma function.</returns>
|
||||
|
public static double GammaLowerRegularized(double a, double x) |
||||
|
{ |
||||
|
const double Epsilon = 0.000000000000001; |
||||
|
const double BigNumber = 4503599627370496.0; |
||||
|
const double BigNumberInverse = 2.22044604925031308085e-16; |
||||
|
|
||||
|
if (a < 0d || x < 0d) |
||||
|
{ |
||||
|
throw new ArgumentOutOfRangeException("a,x", Properties.Resources.ArgumentNotNegative); |
||||
|
} |
||||
|
|
||||
|
if (Precision.AlmostZero(a)) |
||||
|
{ |
||||
|
if (Precision.AlmostZero(x)) |
||||
|
{ |
||||
|
// either 0 or 1, depending on the limit direction
|
||||
|
return Double.NaN; |
||||
|
} |
||||
|
|
||||
|
return 1d; |
||||
|
} |
||||
|
|
||||
|
if (Precision.AlmostZero(x)) |
||||
|
{ |
||||
|
return 0d; |
||||
|
} |
||||
|
|
||||
|
double ax = (a * Math.Log(x)) - x - SpecialFunctions.GammaLn(a); |
||||
|
if (ax < -709.78271289338399) |
||||
|
{ |
||||
|
return 1d; |
||||
|
} |
||||
|
|
||||
|
if (x <= 1 || x <= a) |
||||
|
{ |
||||
|
double r2 = a; |
||||
|
double c2 = 1; |
||||
|
double ans2 = 1; |
||||
|
|
||||
|
do |
||||
|
{ |
||||
|
r2 = r2 + 1; |
||||
|
c2 = c2 * x / r2; |
||||
|
ans2 += c2; |
||||
|
} |
||||
|
while ((c2 / ans2) > Epsilon); |
||||
|
|
||||
|
return Math.Exp(ax) * ans2 / a; |
||||
|
} |
||||
|
|
||||
|
int c = 0; |
||||
|
double y = 1 - a; |
||||
|
double z = x + y + 1; |
||||
|
|
||||
|
double p3 = 1; |
||||
|
double q3 = x; |
||||
|
double p2 = x + 1; |
||||
|
double q2 = z * x; |
||||
|
double ans = p2 / q2; |
||||
|
|
||||
|
double error = 0; |
||||
|
|
||||
|
do |
||||
|
{ |
||||
|
c++; |
||||
|
y += 1; |
||||
|
z += 2; |
||||
|
double yc = y * c; |
||||
|
|
||||
|
double p = (p2 * z) - (p3 * yc); |
||||
|
double q = (q2 * z) - (q3 * yc); |
||||
|
|
||||
|
if (q != 0) |
||||
|
{ |
||||
|
double nextans = p / q; |
||||
|
error = Math.Abs((ans - nextans) / nextans); |
||||
|
ans = nextans; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// zero div, skip
|
||||
|
error = 1; |
||||
|
} |
||||
|
|
||||
|
// shift
|
||||
|
p3 = p2; |
||||
|
p2 = p; |
||||
|
q3 = q2; |
||||
|
q2 = q; |
||||
|
|
||||
|
// normalize fraction when the numerator becomes large
|
||||
|
if (Math.Abs(p) > BigNumber) |
||||
|
{ |
||||
|
p3 *= BigNumberInverse; |
||||
|
p2 *= BigNumberInverse; |
||||
|
q3 *= BigNumberInverse; |
||||
|
q2 *= BigNumberInverse; |
||||
|
} |
||||
|
} |
||||
|
while (error > Epsilon); |
||||
|
|
||||
|
return 1d - (Math.Exp(ax) * ans); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,157 @@ |
|||||
|
// <copyright file="GammaTests.cs" company="Math.NET">
|
||||
|
// Math.NET Numerics, part of the Math.NET Project
|
||||
|
// http://mathnet.opensourcedotnet.info
|
||||
|
//
|
||||
|
// Copyright (c) 2009 Math.NET
|
||||
|
//
|
||||
|
// Permission is hereby granted, free of charge, to any person
|
||||
|
// obtaining a copy of this software and associated documentation
|
||||
|
// files (the "Software"), to deal in the Software without
|
||||
|
// restriction, including without limitation the rights to use,
|
||||
|
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
|
// copies of the Software, and to permit persons to whom the
|
||||
|
// Software is furnished to do so, subject to the following
|
||||
|
// conditions:
|
||||
|
//
|
||||
|
// The above copyright notice and this permission notice shall be
|
||||
|
// included in all copies or substantial portions of the Software.
|
||||
|
//
|
||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
|
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
|
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
|
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
|
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
// </copyright>
|
||||
|
|
||||
|
namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests |
||||
|
{ |
||||
|
using System; |
||||
|
using MbUnit.Framework; |
||||
|
using MathNet.Numerics; |
||||
|
|
||||
|
class GammaTests |
||||
|
{ |
||||
|
[Test] |
||||
|
[Row(Double.NaN, Double.NaN)] |
||||
|
[Row(0.1, 2.2527126517342059020062379568954763844479865649307379)] |
||||
|
[Row(1.0, 0.0)] |
||||
|
[Row(1.5, -0.12078223763524522234551844578164721225185272790259947)] |
||||
|
[Row(Constants.Pi / 2, -0.11590380084550241329912089415904874214542604767006895)] |
||||
|
[Row(2.0, 0.0)] |
||||
|
[Row(2.5, 0.28468287047291915963249466968270192432013769555989498)] |
||||
|
[Row(3.0, 0.693147180559945309417232121458176568075500134360255)] |
||||
|
[Row(Constants.Pi, 0.82769459232343710152957855845235995115350173412073715)] |
||||
|
[Row(3.5, 1.2009736023470742248160218814507129957702389154681574)] |
||||
|
[Row(4.0, 1.7917594692280550008124773583807022727229906921830034)] |
||||
|
[Row(4.5, 2.4537365708424422205041425034357161573318235106897606)] |
||||
|
[Row(5.0, 3.1780538303479456196469416012970554088739909609035161)] |
||||
|
[Row(5.5, 3.9578139676187162938774008558225909985513044919750065)] |
||||
|
[Row(10.1, 13.02752673863323715481371189614224148681183971709386)] |
||||
|
public void GammaLn(double x, double f) |
||||
|
{ |
||||
|
AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaLn(x), 14); |
||||
|
} |
||||
|
|
||||
|
[Test] |
||||
|
[Row(Double.NaN, Double.NaN)] |
||||
|
[Row(-1.5, 2.3632718012073547030642233111215269103967326081631802)] |
||||
|
[Row(-0.5, -3.544907701811032054596334966682290365595098912244773)] |
||||
|
[Row(0.1, 9.5135076986687312858079798958252325009137161063903012)] |
||||
|
[Row(1.0, 1.0)] |
||||
|
[Row(1.5, 0.88622692545275801364908374167057259139877472806119326)] |
||||
|
[Row(Constants.Pi / 2, 0.89056089038153932801065963535912100593354196288475879)] |
||||
|
[Row(2.0, 1.0)] |
||||
|
[Row(2.5, 1.3293403881791370204736256125058588870981620920917912)] |
||||
|
[Row(3.0, 2.0)] |
||||
|
[Row(Constants.Pi, 2.2880377953400324179595889090602339228896881533562229)] |
||||
|
[Row(3.5, 3.3233509704478425511840640312646472177454052302294767)] |
||||
|
[Row(4.0, 6.0)] |
||||
|
[Row(4.5, 11.631728396567448929144224109426265262108918305803166)] |
||||
|
[Row(5.0, 24.0)] |
||||
|
[Row(5.5, 52.342777784553520181149008492418193679490132376114268)] |
||||
|
[Row(10.1, 454760.75144158558537612486797710217749925965322893332)] |
||||
|
public void Gamma(double x, double f) |
||||
|
{ |
||||
|
AssertHelpers.AlmostEqual(f, SpecialFunctions.Gamma(x), 13); |
||||
|
} |
||||
|
|
||||
|
[Test] |
||||
|
[Row(double.NaN, Double.NaN, Double.NaN)] |
||||
|
[Row(0.1, 1.0, 0.97587265627367222115949155252812057714751052498477013)] |
||||
|
[Row(0.1, 2.0, 0.99432617602018847196075251078067514034772764693462125)] |
||||
|
[Row(0.1, 8.0, 0.99999507519205198048686442150578226823401842046310854)] |
||||
|
[Row(1.5, 1.0, 0.42759329552912016600095238564127189392715996802703368)] |
||||
|
[Row(1.5, 2.0, 0.73853587005088937779717792402407879809718939080920993)] |
||||
|
[Row(1.5, 8.0, 0.99886601571021467734329986257903021041757398191304284)] |
||||
|
[Row(2.5, 1.0, 0.15085496391539036377410688601371365034788861473418704)] |
||||
|
[Row(2.5, 2.0, 0.45058404864721976739416885516693969548484517509263197)] |
||||
|
[Row(2.5, 8.0, 0.99315592607757956900093935107222761316136944145439676)] |
||||
|
[Row(5.5, 1.0, 0.0015041182825838038421585211353488839717739161316985392)] |
||||
|
[Row(5.5, 2.0, 0.030082976121226050615171484772387355162056796585883967)] |
||||
|
[Row(5.5, 8.0, 0.85886911973294184646060071855669224657735916933487681)] |
||||
|
public void GammaLowerRegularized(double a, double x, double f) |
||||
|
{ |
||||
|
AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaLowerRegularized(a, x), 14); |
||||
|
} |
||||
|
|
||||
|
[Test] |
||||
|
[Row(double.NaN, Double.NaN, Double.NaN)] |
||||
|
[Row(0.1, 1.0, 9.2839720283798852469443229940217320532607158711056334)] |
||||
|
[Row(0.1, 2.0, 9.4595297305559030536119885480983751098528458886962883)] |
||||
|
[Row(0.1, 8.0, 9.5134608464704033372127589212547718314010339263844976)] |
||||
|
[Row(1.5, 1.0, 0.37894469164098470380394366597039213790868855578083847)] |
||||
|
[Row(1.5, 2.0, 0.65451037345177732033319477475056262302270310457635612)] |
||||
|
[Row(1.5, 8.0, 0.88522195804210983776635107858848816480298923071075222)] |
||||
|
[Row(2.5, 1.0, 0.20053759629003473411039172879412733941722170263949)] |
||||
|
[Row(2.5, 2.0, 0.59897957413602228465664030130712917348327070206302442)] |
||||
|
[Row(2.5, 8.0, 1.3202422842943799358198434659248530581833764879301293)] |
||||
|
[Row(5.5, 1.0, 0.078729729026968321691794205337720556329618007004848672)] |
||||
|
[Row(5.5, 2.0, 1.5746265342113649473739798668921124454837064926448459)] |
||||
|
[Row(5.5, 8.0, 44.955595480196465884619737757794960132425035578313584)] |
||||
|
public void GammaLowerIncomplete(double a, double x, double f) |
||||
|
{ |
||||
|
AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaLowerIncomplete(a, x), 14); |
||||
|
} |
||||
|
|
||||
|
[Test] |
||||
|
[Row(double.NaN, Double.NaN, Double.NaN)] |
||||
|
[Row(0.100000, 1.000000, 0.024127343726327778840508447471879422852489475015229)] |
||||
|
[Row(0.100000, 2.000000, 0.0056738239798115280392474892193248596522723530653781)] |
||||
|
[Row(0.100000, 8.000000, 0.0000049248079480195131355784942177317659815795368919702)] |
||||
|
[Row(1.500000, 1.000000, 0.57240670447087983399904761435872810607284003197297)] |
||||
|
[Row(1.500000, 2.000000, 0.26146412994911062220282207597592120190281060919079)] |
||||
|
[Row(1.500000, 8.000000, 0.0011339842897853226567001374209697895824260180869567)] |
||||
|
[Row(2.500000, 1.000000, 0.84914503608460963622589311398628634965211138526581)] |
||||
|
[Row(2.500000, 2.000000, 0.54941595135278023260583114483306030451515482490737)] |
||||
|
[Row(2.500000, 8.000000, 0.0068440739224204309990606489277723868386305585456026)] |
||||
|
[Row(5.500000, 1.000000, 0.9984958817174161961578414788646511160282260838683)] |
||||
|
[Row(5.500000, 2.000000, 0.96991702387877394938482851522761264483794320341412)] |
||||
|
[Row(5.500000, 8.000000, 0.14113088026705815353939928144330775342264083066512)] |
||||
|
public void GammaUpperRegularized(double a, double x, double f) |
||||
|
{ |
||||
|
AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaUpperRegularized(a, x), 14); |
||||
|
} |
||||
|
|
||||
|
[Test] |
||||
|
[Row(double.NaN, Double.NaN, Double.NaN)] |
||||
|
[Row(0.100000, 1.000000, 0.22953567028884603886365690180350044765300023528467)] |
||||
|
[Row(0.100000, 2.000000, 0.053977968112828232195991347726857391060870217694027)] |
||||
|
[Row(0.100000, 8.000000, 0.000046852198327948595220974570460669512682180005810156)] |
||||
|
[Row(1.500000, 1.000000, 0.50728223381177330984514007570018045349008617228036)] |
||||
|
[Row(1.500000, 2.000000, 0.23171655200098069331588896692000996837607162348484)] |
||||
|
[Row(1.500000, 8.000000, 0.0010049674106481758827326630820844265957854973504417)] |
||||
|
[Row(2.500000, 1.000000, 1.1288027918891022863632338837117315476809403894523)] |
||||
|
[Row(2.500000, 2.000000, 0.73036081404311473581698531119872971361489139002877)] |
||||
|
[Row(2.500000, 8.000000, 0.0090981038847570846537821465810058289147856041616617)] |
||||
|
[Row(5.500000, 1.000000, 52.264048055526551859457214287080473123160514369109)] |
||||
|
[Row(5.500000, 2.000000, 50.768151250342155233775028625526081234006425883469)] |
||||
|
[Row(5.500000, 8.000000, 7.3871823043570542965292707346232335470650967978006)] |
||||
|
public void GammaUpperIncomplete(double a, double x, double f) |
||||
|
{ |
||||
|
AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaUpperIncomplete(a, x), 14); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue