Exemple #1
0
        /// <summary>
        ///     Gamma function of the specified value.
        /// </summary>
        public static double Function(double x)
        {
            double[] P =
            {
                1.60119522476751861407E-4,
                1.19135147006586384913E-3,
                1.04213797561761569935E-2,
                4.76367800457137231464E-2,
                2.07448227648435975150E-1,
                4.94214826801497100753E-1,
                9.99999999999999996796E-1
            };

            double[] Q =
            {
                -2.31581873324120129819E-5,
                5.39605580493303397842E-4,
                -4.45641913851797240494E-3,
                1.18139785222060435552E-2,
                3.58236398605498653373E-2,
                -2.34591795718243348568E-1,
                7.14304917030273074085E-2,
                1.00000000000000000320E0
            };

            double p, z;

            double q = Math.Abs(x);

            if (q > 33.0)
            {
                if (x < 0.0)
                {
                    p = Math.Floor(q);

                    if (p == q)
                    {
                        throw new OverflowException();
                    }

                    z = q - p;
                    if (z > 0.5)
                    {
                        p += 1.0;
                        z  = q - p;
                    }
                    z = q * Math.Sin(Math.PI * z);

                    if (z == 0.0)
                    {
                        throw new OverflowException();
                    }

                    z = Math.Abs(z);
                    z = Math.PI / (z * Stirling(q));

                    return(-z);
                }
                return(Stirling(x));
            }

            z = 1.0;
            while (x >= 3.0)
            {
                x -= 1.0;
                z *= x;
            }

            while (x < 0.0)
            {
                if (x == 0.0)
                {
                    throw new ArithmeticException();
                }
                if (x > -1.0E-9)
                {
                    return(z / ((1.0 + 0.5772156649015329 * x) * x));
                }
                z /= x;
                x += 1.0;
            }

            while (x < 2.0)
            {
                if (x == 0.0)
                {
                    throw new ArithmeticException();
                }
                if (x < 1.0E-9)
                {
                    return(z / ((1.0 + 0.5772156649015329 * x) * x));
                }

                z /= x;
                x += 1.0;
            }

            if ((x == 2.0) || (x == 3.0))
            {
                return(z);
            }

            x -= 2.0;
            p  = Special.Polevl(x, P, 6);
            q  = Special.Polevl(x, Q, 7);
            return(z * p / q);
        }
Exemple #2
0
        /// <summary>
        ///     Natural logarithm of the gamma function.
        /// </summary>
        public static double Log(double x)
        {
            if (x == 0)
            {
                return(Double.PositiveInfinity);
            }

            double p, q, w, z;

            double[] A =
            {
                8.11614167470508450300E-4,
                -5.95061904284301438324E-4,
                7.93650340457716943945E-4,
                -2.77777777730099687205E-3,
                8.33333333333331927722E-2
            };

            double[] B =
            {
                -1.37825152569120859100E3,
                -3.88016315134637840924E4,
                -3.31612992738871184744E5,
                -1.16237097492762307383E6,
                -1.72173700820839662146E6,
                -8.53555664245765465627E5
            };

            double[] C =
            {
                -3.51815701436523470549E2,
                -1.70642106651881159223E4,
                -2.20528590553854454839E5,
                -1.13933444367982507207E6,
                -2.53252307177582951285E6,
                -2.01889141433532773231E6
            };

            if (x < -34.0)
            {
                q = -x;
                w = Log(q);
                p = Math.Floor(q);

                if (p == q)
                {
                    throw new OverflowException();
                }

                z = q - p;
                if (z > 0.5)
                {
                    p += 1.0;
                    z  = p - q;
                }
                z = q * Math.Sin(Math.PI * z);

                if (z == 0.0)
                {
                    throw new OverflowException();
                }

                z = Constants.LogPI - Math.Log(z) - w;
                return(z);
            }

            if (x < 13.0)
            {
                z = 1.0;
                while (x >= 3.0)
                {
                    x -= 1.0;
                    z *= x;
                }
                while (x < 2.0)
                {
                    if (x == 0.0)
                    {
                        throw new OverflowException();
                    }

                    z /= x;
                    x += 1.0;
                }

                if (z < 0.0)
                {
                    z = -z;
                }

                if (x == 2.0)
                {
                    return(Math.Log(z));
                }

                x -= 2.0;

                p = x * Special.Polevl(x, B, 5) / Special.P1evl(x, C, 6);

                return(Math.Log(z) + p);
            }

            if (x > 2.556348e305)
            {
                throw new OverflowException();
            }

            q = (x - 0.5) * Math.Log(x) - x + 0.91893853320467274178;

            if (x > 1.0e8)
            {
                return(q);
            }

            p = 1.0 / (x * x);

            if (x >= 1000.0)
            {
                q += ((7.9365079365079365079365e-4 * p
                       - 2.7777777777777777777778e-3) * p
                      + 0.0833333333333333333333) / x;
            }
            else
            {
                q += Special.Polevl(p, A, 4) / x;
            }

            return(q);
        }