P1evl() public static method

Evaluates polynomial of degree N with assumption that coef[N] = 1.0
public static P1evl ( double x, double coef, int n ) : double
x double
coef double
n int
return double
Exemplo n.º 1
0
        /// <summary>
        ///    Normal (Gaussian) inverse cumulative distribution function.
        /// </summary>
        ///
        /// <remarks>
        /// <para>
        ///    For small arguments <c>0 &lt; y &lt; exp(-2)</c>, the program computes <c>z =
        ///    sqrt( -2.0 * log(y) )</c>;  then the approximation is <c>x = z - log(z)/z  -
        ///    (1/z) P(1/z) / Q(1/z)</c>.</para>
        /// <para>
        ///    There are two rational functions P/Q, one for <c>0 &lt; y &lt; exp(-32)</c> and
        ///    the other for <c>y</c> up to <c>exp(-2)</c>. For larger arguments, <c>w = y - 0.5</c>,
        ///    and  <c>x/sqrt(2pi) = w + w^3 * R(w^2)/S(w^2))</c>.</para>
        /// </remarks>
        ///
        /// <returns>
        ///    Returns the value, <c>x</c>, for which the area under the Normal (Gaussian)
        ///    probability density function (integrated from minus infinity to <c>x</c>) is
        ///    equal to the argument <c>y</c> (assumes mean is zero, variance is one).
        /// </returns>
        ///
        public static double Inverse(double y0)
        {
            if (y0 <= 0.0)
            {
                if (y0 == 0)
                {
                    return(Double.NegativeInfinity);
                }
                throw new ArgumentOutOfRangeException("y0");
            }

            if (y0 >= 1.0)
            {
                if (y0 == 1)
                {
                    return(Double.PositiveInfinity);
                }
                throw new ArgumentOutOfRangeException("y0");
            }


            double s2pi = Math.Sqrt(2.0 * Math.PI);
            int    code = 1;
            double y    = y0;
            double x;

            double[] P0 =
            {
                -59.963350101410789,
                98.001075418599967,
                -56.676285746907027,
                13.931260938727968,
                -1.2391658386738125
            };

            double[] Q0 =
            {
                1.9544885833814176,
                4.6762791289888153,
                86.360242139089053,
                -225.46268785411937,
                200.26021238006066,
                -82.037225616833339,
                15.90562251262117,
                -1.1833162112133
            };

            double[] P1 =
            {
                4.0554489230596245,
                31.525109459989388,
                57.162819224642128,
                44.080507389320083,
                14.684956192885803,
                2.1866330685079025,
                -0.14025607917135449,
                -0.035042462682784818,
                -0.00085745678515468545
            };

            double[] Q1 =
            {
                15.779988325646675,
                45.390763512887922,
                41.317203825467203,
                15.04253856929075,
                2.5046494620830941,
                -0.14218292285478779,
                -0.038080640769157827,
                -0.00093325948089545744
            };

            double[] P2 =
            {
                3.2377489177694603,
                6.9152288906898418,
                3.9388102529247444,
                1.3330346081580755,
                0.20148538954917908,
                0.012371663481782003,
                0.00030158155350823543,
                2.6580697468673755E-06,
                6.2397453918498331E-09
            };

            double[] Q2 =
            {
                6.02427039364742,
                3.6798356385616087,
                1.3770209948908132,
                0.21623699359449663,
                0.013420400608854318,
                0.00032801446468212774,
                2.8924786474538068E-06,
                6.7901940800998127E-09
            };

            if (y > 0.8646647167633873)
            {
                y    = 1.0 - y;
                code = 0;
            }

            if (y > 0.1353352832366127)
            {
                y -= 0.5;
                double y2 = y * y;
                x  = y + y * ((y2 * Special.Polevl(y2, P0, 4)) / Special.P1evl(y2, Q0, 8));
                x *= s2pi;
                return(x);
            }

            x = Math.Sqrt(-2.0 * Math.Log(y));
            double x0 = x - Math.Log(x) / x;
            double z  = 1.0 / x;
            double x1;

            if (x < 8.0)
            {
                x1 = (z * Special.Polevl(z, P1, 8)) / Special.P1evl(z, Q1, 8);
            }
            else
            {
                x1 = (z * Special.Polevl(z, P2, 8)) / Special.P1evl(z, Q2, 8);
            }

            x = x0 - x1;

            if (code != 0)
            {
                x = -x;
            }

            return(x);
        }
Exemplo n.º 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;

            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(System.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(System.Math.Log(z));
                }

                x -= 2.0;

                p = x * Special.Polevl(x, log_B, 5) / Special.P1evl(x, log_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, log_A, 4) / x;
            }

            return(q);
        }
Exemplo n.º 3
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(System.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(System.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);
        }
Exemplo n.º 4
0
        /// <summary>
        ///    Normal (Gaussian) inverse cumulative distribution function.
        /// </summary>
        ///
        /// <remarks>
        /// <para>
        ///    For small arguments <c>0 &lt; y &lt; exp(-2)</c>, the program computes <c>z =
        ///    sqrt( -2.0 * log(y) )</c>;  then the approximation is <c>x = z - log(z)/z  -
        ///    (1/z) P(1/z) / Q(1/z)</c>.</para>
        /// <para>
        ///    There are two rational functions P/Q, one for <c>0 &lt; y &lt; exp(-32)</c> and
        ///    the other for <c>y</c> up to <c>exp(-2)</c>. For larger arguments, <c>w = y - 0.5</c>,
        ///    and  <c>x/sqrt(2pi) = w + w^3 * R(w^2)/S(w^2))</c>.</para>
        /// </remarks>
        ///
        /// <returns>
        ///    Returns the value, <c>x</c>, for which the area under the Normal (Gaussian)
        ///    probability density function (integrated from minus infinity to <c>x</c>) is
        ///    equal to the argument <c>y</c> (assumes mean is zero, variance is one).
        /// </returns>
        ///
        public static double Inverse(double y0)
        {
            if (y0 <= 0.0)
            {
                if (y0 == 0)
                {
                    return(Double.NegativeInfinity);
                }
                throw new ArgumentOutOfRangeException("y0");
            }

            if (y0 >= 1.0)
            {
                if (y0 == 1)
                {
                    return(Double.PositiveInfinity);
                }
                throw new ArgumentOutOfRangeException("y0");
            }


            double s2pi = Math.Sqrt(2.0 * Math.PI);
            int    code = 1;
            double y    = y0;
            double x;



            if (y > 0.8646647167633873)
            {
                y    = 1.0 - y;
                code = 0;
            }

            if (y > 0.1353352832366127)
            {
                y -= 0.5;
                double y2 = y * y;
                x  = y + y * ((y2 * Special.Polevl(y2, inverse_P0, 4)) / Special.P1evl(y2, inverse_Q0, 8));
                x *= s2pi;
                return(x);
            }

            x = Math.Sqrt(-2.0 * Math.Log(y));
            double x0 = x - Math.Log(x) / x;
            double z  = 1.0 / x;
            double x1;

            if (x < 8.0)
            {
                x1 = (z * Special.Polevl(z, inverse_P1, 8)) / Special.P1evl(z, inverse_Q1, 8);
            }
            else
            {
                x1 = (z * Special.Polevl(z, inverse_P2, 8)) / Special.P1evl(z, inverse_Q2, 8);
            }

            x = x0 - x1;

            if (code != 0)
            {
                x = -x;
            }

            return(x);
        }