Example #1
0
        /// <summary>
        /// Least-Squares fitting the points (x,y) to a k-order polynomial y : x -> p0 + p1*x + p2*x^2 + ... + pk*x^k,
        /// returning a function y' for the best fitting polynomial.
        /// A polynomial with order/degree k has (k+1) coefficients and thus requires at least (k+1) samples.
        /// </summary>
        public static Func <double, double> PolynomialFunc(double[] x, double[] y, int order, DirectRegressionMethod method = DirectRegressionMethod.QR)
        {
            var parameters = Polynomial(x, y, order, method);

            return(z => Evaluate.Polynomial(z, parameters));
        }
Example #2
0
        /// <summary>
        /// Returns the modified Struve function of order 0.
        /// </summary>
        /// <param name="x">The value to compute the function of.</param>
        public static double StruveL0(double x)
        {
            //*********************************************************************72
            //
            //c STRVL0 calculates the modified Struve function of order 0.
            //
            //   DESCRIPTION:
            //
            //      This function calculates the modified Struve function of
            //      order 0, denoted L0(x), defined as the solution of the
            //      second-order equation
            //
            //                  x*D(Df) + Df - x*f  =  2x/pi
            //
            //      This subroutine is set up to work on IEEE machines.
            //      For other machines, you should retrieve the code
            //      from the general MISCFUN archive.
            //
            //
            //   ERROR RETURNS:
            //
            //      If the value of |XVALUE| is too large, the result
            //      would cause an floating-pt overflow. An error message
            //      is printed and the function returns the value of
            //      sign(XVALUE)*XMAX where XMAX is the largest possible
            //      floating-pt argument.
            //
            //
            //   MACHINE-DEPENDENT PARAMETERS:
            //
            //      NTERM1 - INTEGER - The no. of terms for the array ARL0.
            //                         The recommended value is such that
            //                             ABS(ARL0(NTERM1)) < EPS/100
            //
            //      NTERM2 - INTEGER - The no. of terms for the array ARL0AS.
            //                         The recommended value is such that
            //                             ABS(ARL0AS(NTERM2)) < EPS/100
            //
            //      NTERM3 - INTEGER - The no. of terms for the array AI0ML0.
            //                         The recommended value is such that
            //                             ABS(AI0ML0(NTERM3)) < EPS/100
            //
            //      XLOW - DOUBLE PRECISION - The value of x below which L0(x) = 2*x/pi
            //                    to machine precision. The recommended value is
            //                             3*SQRT(EPS)
            //
            //      XHIGH1 - DOUBLE PRECISION - The value beyond which the Chebyshev series
            //                      in the asymptotic expansion of I0 - L0 gives
            //                      1.0 to machine precision. The recommended value
            //                      is   SQRT( 30/EPSNEG )
            //
            //      XHIGH2 - DOUBLE PRECISION - The value beyond which the Chebyshev series
            //                      in the asymptotic expansion of I0 gives 1.0
            //                      to machine precision. The recommended value
            //                      is   28 / EPSNEG
            //
            //      XMAX - DOUBLE PRECISION - The value of XMAX, where XMAX is the
            //                    largest possible floating-pt argument.
            //                    This is used to prevent overflow.
            //
            //      For values of EPS, EPSNEG and XMAX the user should refer
            //      to the file MACHCON.TXT
            //
            //      The machine-arithmetic constants are given in DATA
            //      statements.
            //
            //
            //   INTRINSIC FUNCTIONS USED:
            //
            //      EXP , LOG , SQRT
            //
            //
            //   OTHER MISCFUN SUBROUTINES USED:
            //
            //          CHEVAL , ERRPRN
            //
            //
            //   AUTHOR:
            //          DR. ALLAN J. MACLEOD
            //          DEPT. OF MATHEMATICS AND STATISTICS
            //          UNIVERSITY OF PAISLEY
            //          HIGH ST.
            //          PAISLEY
            //          SCOTLAND
            //          PA1 2BE
            //
            //      (e-mail: [email protected] )
            //
            //
            //   LATEST REVISION:
            //                   12 JANUARY, 1996
            //
            //

            if (x < 0.0)
            {
                return(-StruveL0(-x));
            }

            double[] ARL0 = new double[28];
            ARL0[0]  = 0.42127458349979924863;
            ARL0[1]  = -0.33859536391220612188;
            ARL0[2]  = 0.21898994812710716064;
            ARL0[3]  = -0.12349482820713185712;
            ARL0[4]  = 0.6214209793866958440e-1;
            ARL0[5]  = -0.2817806028109547545e-1;
            ARL0[6]  = 0.1157419676638091209e-1;
            ARL0[7]  = -0.431658574306921179e-2;
            ARL0[8]  = 0.146142349907298329e-2;
            ARL0[9]  = -0.44794211805461478e-3;
            ARL0[10] = 0.12364746105943761e-3;
            ARL0[11] = -0.3049028334797044e-4;
            ARL0[12] = 0.663941401521146e-5;
            ARL0[13] = -0.125538357703889e-5;
            ARL0[14] = 0.20073446451228e-6;
            ARL0[15] = -0.2588260170637e-7;
            ARL0[16] = 0.241143742758e-8;
            ARL0[17] = -0.10159674352e-9;
            ARL0[18] = -0.1202430736e-10;
            ARL0[19] = 0.262906137e-11;
            ARL0[20] = -0.15313190e-12;
            ARL0[21] = -0.1574760e-13;
            ARL0[22] = 0.315635e-14;
            ARL0[23] = -0.4096e-16;
            ARL0[24] = -0.3620e-16;
            ARL0[25] = 0.239e-17;
            ARL0[26] = 0.36e-18;
            ARL0[27] = -0.4e-19;

            double[] ARL0AS = new double[16];
            ARL0AS[0]  = 2.00861308235605888600;
            ARL0AS[1]  = 0.403737966500438470e-2;
            ARL0AS[2]  = -0.25199480286580267e-3;
            ARL0AS[3]  = 0.1605736682811176e-4;
            ARL0AS[4]  = -0.103692182473444e-5;
            ARL0AS[5]  = 0.6765578876305e-7;
            ARL0AS[6]  = -0.444999906756e-8;
            ARL0AS[7]  = 0.29468889228e-9;
            ARL0AS[8]  = -0.1962180522e-10;
            ARL0AS[9]  = 0.131330306e-11;
            ARL0AS[10] = -0.8819190e-13;
            ARL0AS[11] = 0.595376e-14;
            ARL0AS[12] = -0.40389e-15;
            ARL0AS[13] = 0.2651e-16;
            ARL0AS[14] = -0.208e-17;
            ARL0AS[15] = 0.11e-18;

            double[] AI0ML0 = new double[24];
            AI0ML0[0]  = 2.00326510241160643125;
            AI0ML0[1]  = 0.195206851576492081e-2;
            AI0ML0[2]  = 0.38239523569908328e-3;
            AI0ML0[3]  = 0.7534280817054436e-4;
            AI0ML0[4]  = 0.1495957655897078e-4;
            AI0ML0[5]  = 0.299940531210557e-5;
            AI0ML0[6]  = 0.60769604822459e-6;
            AI0ML0[7]  = 0.12399495544506e-6;
            AI0ML0[8]  = 0.2523262552649e-7;
            AI0ML0[9]  = 0.504634857332e-8;
            AI0ML0[10] = 0.97913236230e-9;
            AI0ML0[11] = 0.18389115241e-9;
            AI0ML0[12] = 0.3376309278e-10;
            AI0ML0[13] = 0.611179703e-11;
            AI0ML0[14] = 0.108472972e-11;
            AI0ML0[15] = 0.18861271e-12;
            AI0ML0[16] = 0.3280345e-13;
            AI0ML0[17] = 0.565647e-14;
            AI0ML0[18] = 0.93300e-15;
            AI0ML0[19] = 0.15881e-15;
            AI0ML0[20] = 0.2791e-16;
            AI0ML0[21] = 0.389e-17;
            AI0ML0[22] = 0.70e-18;
            AI0ML0[23] = 0.16e-18;

            // MACHINE-DEPENDENT VALUES (Suitable for IEEE-arithmetic machines)
            const int    nterm1 = 25;
            const int    nterm2 = 14;
            const int    nterm3 = 21;
            const double xlow   = 4.4703484e-8;
            const double xmax   = 1.797693e308;
            const double xhigh1 = 5.1982303e8;
            const double xhigh2 = 2.5220158e17;

            // Code for |xvalue| <= 16
            if (x <= 16.0)
            {
                if (x < xlow)
                {
                    return(Constants.TwoInvPi * x);
                }

                double T = (4.0 * x - 24.0) / (x + 24.0);
                return(Constants.TwoInvPi * x * Evaluate.ChebyshevSum(nterm1, ARL0, T) * System.Math.Exp(x));
            }

            // Code for |xvalue| > 16
            double ch1;

            if (x > xhigh2)
            {
                ch1 = 1.0;
            }
            else
            {
                double T = (x - 28.0) / (4.0 - x);
                ch1 = Evaluate.ChebyshevSum(nterm2, ARL0AS, T);
            }

            double ch2;

            if (x > xhigh1)
            {
                ch2 = 1.0;
            }
            else
            {
                double xsq = x * x;
                double T   = (800.0 - xsq) / (288.0 + xsq);
                ch2 = Evaluate.ChebyshevSum(nterm3, AI0ML0, T);
            }

            double test = System.Math.Log(ch1) - Constants.LogSqrt2Pi - System.Math.Log(x) / 2.0 + x;

            if (test > System.Math.Log(xmax))
            {
                throw new ArithmeticException("ERROR IN MISCFUN FUNCTION STRVL0: ARGUMENT CAUSES OVERFLOW");
            }

            return(System.Math.Exp(test) - Constants.TwoInvPi * ch2 / x);
        }
Example #3
0
        /// <summary>
        /// The implementation of the inverse error function.
        /// </summary>
        /// <param name="p">First intermediate parameter.</param>
        /// <param name="q">Second intermediate parameter.</param>
        /// <param name="s">Third intermediate parameter.</param>
        /// <returns>the inverse error function.</returns>
        static double ErfInvImpl(double p, double q, double s)
        {
            double result;

            if (p <= 0.5)
            {
                // Evaluate inverse erf using the rational approximation:
                //
                // x = p(p+10)(Y+R(p))
                //
                // Where Y is a constant, and R(p) is optimized for a low
                // absolute error compared to |Y|.
                //
                // double: Max error found: 2.001849e-18
                // long double: Max error found: 1.017064e-20
                // Maximum Deviation Found (actual error term at infinite precision) 8.030e-21
                const float y = 0.0891314744949340820313f;
                double      g = p * (p + 10);
                double      r = Evaluate.Polynomial(p, ErvInvImpAn) / Evaluate.Polynomial(p, ErvInvImpAd);
                result = (g * y) + (g * r);
            }
            else if (q >= 0.25)
            {
                // Rational approximation for 0.5 > q >= 0.25
                //
                // x = sqrt(-2*log(q)) / (Y + R(q))
                //
                // Where Y is a constant, and R(q) is optimized for a low
                // absolute error compared to Y.
                //
                // double : Max error found: 7.403372e-17
                // long double : Max error found: 6.084616e-20
                // Maximum Deviation Found (error term) 4.811e-20
                const float y  = 2.249481201171875f;
                double      g  = System.Math.Sqrt(-2 * System.Math.Log(q));
                double      xs = q - 0.25;
                double      r  = Evaluate.Polynomial(xs, ErvInvImpBn) / Evaluate.Polynomial(xs, ErvInvImpBd);
                result = g / (y + r);
            }
            else
            {
                // For q < 0.25 we have a series of rational approximations all
                // of the general form:
                //
                // let: x = sqrt(-log(q))
                //
                // Then the result is given by:
                //
                // x(Y+R(x-B))
                //
                // where Y is a constant, B is the lowest value of x for which
                // the approximation is valid, and R(x-B) is optimized for a low
                // absolute error compared to Y.
                //
                // Note that almost all code will really go through the first
                // or maybe second approximation.  After than we're dealing with very
                // small input values indeed: 80 and 128 bit long double's go all the
                // way down to ~ 1e-5000 so the "tail" is rather long...
                double x = System.Math.Sqrt(-System.Math.Log(q));
                if (x < 3)
                {
                    // Max error found: 1.089051e-20
                    const float y  = 0.807220458984375f;
                    double      xs = x - 1.125;
                    double      r  = Evaluate.Polynomial(xs, ErvInvImpCn) / Evaluate.Polynomial(xs, ErvInvImpCd);
                    result = (y * x) + (r * x);
                }
                else if (x < 6)
                {
                    // Max error found: 8.389174e-21
                    const float y  = 0.93995571136474609375f;
                    double      xs = x - 3;
                    double      r  = Evaluate.Polynomial(xs, ErvInvImpDn) / Evaluate.Polynomial(xs, ErvInvImpDd);
                    result = (y * x) + (r * x);
                }
                else if (x < 18)
                {
                    // Max error found: 1.481312e-19
                    const float y  = 0.98362827301025390625f;
                    double      xs = x - 6;
                    double      r  = Evaluate.Polynomial(xs, ErvInvImpEn) / Evaluate.Polynomial(xs, ErvInvImpEd);
                    result = (y * x) + (r * x);
                }
                else if (x < 44)
                {
                    // Max error found: 5.697761e-20
                    const float y  = 0.99714565277099609375f;
                    double      xs = x - 18;
                    double      r  = Evaluate.Polynomial(xs, ErvInvImpFn) / Evaluate.Polynomial(xs, ErvInvImpFd);
                    result = (y * x) + (r * x);
                }
                else
                {
                    // Max error found: 1.279746e-20
                    const float y  = 0.99941349029541015625f;
                    double      xs = x - 44;
                    double      r  = Evaluate.Polynomial(xs, ErvInvImpGn) / Evaluate.Polynomial(xs, ErvInvImpGd);
                    result = (y * x) + (r * x);
                }
            }

            return(s * result);
        }
Example #4
0
        /// <summary>
        /// Returns the modified Struve function of order 1.
        /// </summary>
        /// <param name="x">The value to compute the function of.</param>
        public static double StruveL1(double x)
        {
            //*********************************************************************72
            //
            //c STRVL1 calculates the modified Struve function of order 1.
            //
            //   DESCRIPTION:
            //
            //      This function calculates the modified Struve function of
            //      order 1, denoted L1(x), defined as the solution of
            //
            //               x*x*D(Df) + x*Df - (x*x+1)f = 2*x*x/pi
            //
            //      This subroutine is set up to work on IEEE machines.
            //      For other machines, you should retrieve the code
            //      from the general MISCFUN archive.
            //
            //
            //   ERROR RETURNS:
            //
            //      If the value of |XVALUE| is too large, the result
            //      would cause an floating-pt overflow. An error message
            //      is printed and the function returns the value of
            //      sign(XVALUE)*XMAX where XMAX is the largest possible
            //      floating-pt argument.
            //
            //
            //   MACHINE-DEPENDENT PARAMETERS:
            //
            //      NTERM1 - INTEGER - The no. of terms for the array ARL1.
            //                         The recommended value is such that
            //                             ABS(ARL1(NTERM1)) < EPS/100
            //
            //      NTERM2 - INTEGER - The no. of terms for the array ARL1AS.
            //                         The recommended value is such that
            //                             ABS(ARL1AS(NTERM2)) < EPS/100
            //
            //      NTERM3 - INTEGER - The no. of terms for the array AI1ML1.
            //                         The recommended value is such that
            //                             ABS(AI1ML1(NTERM3)) < EPS/100
            //
            //      XLOW1 - DOUBLE PRECISION - The value of x below which
            //                                     L1(x) = 2*x*x/(3*pi)
            //                                 to machine precision. The recommended
            //                                 value is     SQRT(15*EPS)
            //
            //      XLOW2 - DOUBLE PRECISION - The value of x below which L1(x) set to 0.0.
            //                     This is used to prevent underflow. The
            //                     recommended value is
            //                              SQRT(5*XMIN)
            //
            //      XHIGH1 - DOUBLE PRECISION - The value of |x| above which the Chebyshev
            //                      series in the asymptotic expansion of I1
            //                      equals 1.0 to machine precision. The
            //                      recommended value is  SQRT( 30 / EPSNEG ).
            //
            //      XHIGH2 - DOUBLE PRECISION - The value of |x| above which the Chebyshev
            //                      series in the asymptotic expansion of I1 - L1
            //                      equals 1.0 to machine precision. The recommended
            //                      value is   30 / EPSNEG.
            //
            //      XMAX - DOUBLE PRECISION - The value of XMAX, where XMAX is the
            //                    largest possible floating-pt argument.
            //                    This is used to prevent overflow.
            //
            //      For values of EPS, EPSNEG, XMIN, and XMAX the user should refer
            //      to the file MACHCON.TXT
            //
            //      The machine-arithmetic constants are given in DATA
            //      statements.
            //
            //
            //   INTRINSIC FUNCTIONS USED:
            //
            //      EXP , LOG , SQRT
            //
            //
            //   OTHER MISCFUN SUBROUTINES USED:
            //
            //          CHEVAL , ERRPRN
            //
            //
            //   AUTHOR:
            //          DR. ALLAN J. MACLEOD
            //          DEPT. OF MATHEMATICS AND STATISTICS
            //          UNIVERSITY OF PAISLEY
            //          HIGH ST.
            //          PAISLEY
            //          SCOTLAND
            //          PA1 2BE
            //
            //          (e-mail: [email protected] )
            //
            //
            //   LATEST UPDATE:
            //                 12 JANUARY, 1996
            //
            //

            if (x < 0.0)
            {
                return(StruveL1(-x));
            }

            double[] ARL1 = new double[27];
            ARL1[0]  = 0.38996027351229538208;
            ARL1[1]  = -0.33658096101975749366;
            ARL1[2]  = 0.23012467912501645616;
            ARL1[3]  = -0.13121594007960832327;
            ARL1[4]  = 0.6425922289912846518e-1;
            ARL1[5]  = -0.2750032950616635833e-1;
            ARL1[6]  = 0.1040234148637208871e-1;
            ARL1[7]  = -0.350532294936388080e-2;
            ARL1[8]  = 0.105748498421439717e-2;
            ARL1[9]  = -0.28609426403666558e-3;
            ARL1[10] = 0.6925708785942208e-4;
            ARL1[11] = -0.1489693951122717e-4;
            ARL1[12] = 0.281035582597128e-5;
            ARL1[13] = -0.45503879297776e-6;
            ARL1[14] = 0.6090171561770e-7;
            ARL1[15] = -0.623543724808e-8;
            ARL1[16] = 0.38430012067e-9;
            ARL1[17] = 0.790543916e-11;
            ARL1[18] = -0.489824083e-11;
            ARL1[19] = 0.46356884e-12;
            ARL1[20] = 0.684205e-14;
            ARL1[21] = -0.569748e-14;
            ARL1[22] = 0.35324e-15;
            ARL1[23] = 0.4244e-16;
            ARL1[24] = -0.644e-17;
            ARL1[25] = -0.21e-18;
            ARL1[26] = 0.9e-19;

            double[] ARL1AS = new double[17];
            ARL1AS[0]  = 1.97540378441652356868;
            ARL1AS[1]  = -0.1195130555088294181e-1;
            ARL1AS[2]  = 0.33639485269196046e-3;
            ARL1AS[3]  = -0.1009115655481549e-4;
            ARL1AS[4]  = 0.30638951321998e-6;
            ARL1AS[5]  = -0.953704370396e-8;
            ARL1AS[6]  = 0.29524735558e-9;
            ARL1AS[7]  = -0.951078318e-11;
            ARL1AS[8]  = 0.28203667e-12;
            ARL1AS[9]  = -0.1134175e-13;
            ARL1AS[10] = 0.147e-17;
            ARL1AS[11] = -0.6232e-16;
            ARL1AS[12] = -0.751e-17;
            ARL1AS[13] = -0.17e-18;
            ARL1AS[14] = 0.51e-18;
            ARL1AS[15] = 0.23e-18;
            ARL1AS[16] = 0.5e-19;

            double[] AI1ML1 = new double[26];
            AI1ML1[0]  = 1.99679361896789136501;
            AI1ML1[1]  = -0.190663261409686132e-2;
            AI1ML1[2]  = -0.36094622410174481e-3;
            AI1ML1[3]  = -0.6841847304599820e-4;
            AI1ML1[4]  = -0.1299008228509426e-4;
            AI1ML1[5]  = -0.247152188705765e-5;
            AI1ML1[6]  = -0.47147839691972e-6;
            AI1ML1[7]  = -0.9020819982592e-7;
            AI1ML1[8]  = -0.1730458637504e-7;
            AI1ML1[9]  = -0.332323670159e-8;
            AI1ML1[10] = -0.63736421735e-9;
            AI1ML1[11] = -0.12180239756e-9;
            AI1ML1[12] = -0.2317346832e-10;
            AI1ML1[13] = -0.439068833e-11;
            AI1ML1[14] = -0.82847110e-12;
            AI1ML1[15] = -0.15562249e-12;
            AI1ML1[16] = -0.2913112e-13;
            AI1ML1[17] = -0.543965e-14;
            AI1ML1[18] = -0.101177e-14;
            AI1ML1[19] = -0.18767e-15;
            AI1ML1[20] = -0.3484e-16;
            AI1ML1[21] = -0.643e-17;
            AI1ML1[22] = -0.118e-17;
            AI1ML1[23] = -0.22e-18;
            AI1ML1[24] = -0.4e-19;
            AI1ML1[25] = -0.1e-19;

            // MACHINE-DEPENDENT VALUES (Suitable for IEEE-arithmetic machines)
            const int    nterm1 = 24;
            const int    nterm2 = 13;
            const int    nterm3 = 22;
            const double xlow1  = 5.7711949e-8;
            const double xlow2  = 3.3354714e-154;
            const double xmax   = 1.797693e308;
            const double xhigh1 = 5.19823025e8;
            const double xhigh2 = 2.7021597e17;

            // CODE FOR |x| <= 16
            if (x <= 16.0)
            {
                if (x <= xlow2)
                {
                    return(0.0);
                }

                double xsq = x * x;
                if (x < xlow1)
                {
                    return(xsq / Constants.Pi3Over2);
                }

                double t = (4.0 * x - 24.0) / (x + 24.0);
                return(xsq * Evaluate.ChebyshevSum(nterm1, ARL1, t) * System.Math.Exp(x) / Constants.Pi3Over2);
            }

            // CODE FOR |x| > 16
            double ch1;

            if (x > xhigh2)
            {
                ch1 = 1.0;
            }
            else
            {
                double t = (x - 30.0) / (2.0 - x);
                ch1 = Evaluate.ChebyshevSum(nterm2, ARL1AS, t);
            }

            double ch2;

            if (x > xhigh1)
            {
                ch2 = 1.0;
            }
            else
            {
                double xsq = x * x;
                double t   = (800.0 - xsq) / (288.0 + xsq);
                ch2 = Evaluate.ChebyshevSum(nterm3, AI1ML1, t);
            }

            double test = System.Math.Log(ch1) - Constants.LogSqrt2Pi - System.Math.Log(x) / 2.0 + x;

            if (test > System.Math.Log(xmax))
            {
                throw new ArithmeticException("ERROR IN MISCFUN FUNCTION STRVL1: ARGUMENT CAUSES OVERFLOW");
            }

            return(System.Math.Exp(test) - Constants.TwoInvPi * ch2);
        }
Example #5
0
        /// <summary>
        /// Implementation of the error function.
        /// </summary>
        /// <param name="z">Where to evaluate the error function.</param>
        /// <param name="invert">Whether to compute 1 - the error function.</param>
        /// <returns>the error function.</returns>
        static double ErfImp(double z, bool invert)
        {
            if (z < 0)
            {
                if (!invert)
                {
                    return(-ErfImp(-z, false));
                }

                if (z < -0.5)
                {
                    return(2 - ErfImp(-z, true));
                }

                return(1 + ErfImp(-z, false));
            }

            double result;

            // Big bunch of selection statements now to pick which
            // implementation to use, try to put most likely options
            // first:
            if (z < 0.5)
            {
                // We're going to calculate erf:
                if (z < 1e-10)
                {
                    result = (z * 1.125) + (z * 0.003379167095512573896158903121545171688);
                }
                else
                {
                    // Worst case absolute error found: 6.688618532e-21
                    result = (z * 1.125) + (z * Evaluate.Polynomial(z, ErfImpAn) / Evaluate.Polynomial(z, ErfImpAd));
                }
            }
            else if ((z < 110) || ((z < 110) && invert))
            {
                // We'll be calculating erfc:
                invert = !invert;
                double r, b;
                if (z < 0.75)
                {
                    // Worst case absolute error found: 5.582813374e-21
                    r = Evaluate.Polynomial(z - 0.5, ErfImpBn) / Evaluate.Polynomial(z - 0.5, ErfImpBd);
                    b = 0.3440242112F;
                }
                else if (z < 1.25)
                {
                    // Worst case absolute error found: 4.01854729e-21
                    r = Evaluate.Polynomial(z - 0.75, ErfImpCn) / Evaluate.Polynomial(z - 0.75, ErfImpCd);
                    b = 0.419990927F;
                }
                else if (z < 2.25)
                {
                    // Worst case absolute error found: 2.866005373e-21
                    r = Evaluate.Polynomial(z - 1.25, ErfImpDn) / Evaluate.Polynomial(z - 1.25, ErfImpDd);
                    b = 0.4898625016F;
                }
                else if (z < 3.5)
                {
                    // Worst case absolute error found: 1.045355789e-21
                    r = Evaluate.Polynomial(z - 2.25, ErfImpEn) / Evaluate.Polynomial(z - 2.25, ErfImpEd);
                    b = 0.5317370892F;
                }
                else if (z < 5.25)
                {
                    // Worst case absolute error found: 8.300028706e-22
                    r = Evaluate.Polynomial(z - 3.5, ErfImpFn) / Evaluate.Polynomial(z - 3.5, ErfImpFd);
                    b = 0.5489973426F;
                }
                else if (z < 8)
                {
                    // Worst case absolute error found: 1.700157534e-21
                    r = Evaluate.Polynomial(z - 5.25, ErfImpGn) / Evaluate.Polynomial(z - 5.25, ErfImpGd);
                    b = 0.5571740866F;
                }
                else if (z < 11.5)
                {
                    // Worst case absolute error found: 3.002278011e-22
                    r = Evaluate.Polynomial(z - 8, ErfImpHn) / Evaluate.Polynomial(z - 8, ErfImpHd);
                    b = 0.5609807968F;
                }
                else if (z < 17)
                {
                    // Worst case absolute error found: 6.741114695e-21
                    r = Evaluate.Polynomial(z - 11.5, ErfImpIn) / Evaluate.Polynomial(z - 11.5, ErfImpId);
                    b = 0.5626493692F;
                }
                else if (z < 24)
                {
                    // Worst case absolute error found: 7.802346984e-22
                    r = Evaluate.Polynomial(z - 17, ErfImpJn) / Evaluate.Polynomial(z - 17, ErfImpJd);
                    b = 0.5634598136F;
                }
                else if (z < 38)
                {
                    // Worst case absolute error found: 2.414228989e-22
                    r = Evaluate.Polynomial(z - 24, ErfImpKn) / Evaluate.Polynomial(z - 24, ErfImpKd);
                    b = 0.5638477802F;
                }
                else if (z < 60)
                {
                    // Worst case absolute error found: 5.896543869e-24
                    r = Evaluate.Polynomial(z - 38, ErfImpLn) / Evaluate.Polynomial(z - 38, ErfImpLd);
                    b = 0.5640528202F;
                }
                else if (z < 85)
                {
                    // Worst case absolute error found: 3.080612264e-21
                    r = Evaluate.Polynomial(z - 60, ErfImpMn) / Evaluate.Polynomial(z - 60, ErfImpMd);
                    b = 0.5641309023F;
                }
                else
                {
                    // Worst case absolute error found: 8.094633491e-22
                    r = Evaluate.Polynomial(z - 85, ErfImpNn) / Evaluate.Polynomial(z - 85, ErfImpNd);
                    b = 0.5641584396F;
                }

                double g = System.Math.Exp(-z * z) / z;
                result = (g * b) + (g * r);
            }
            else
            {
                // Any value of z larger than 28 will underflow to zero:
                result = 0;
                invert = !invert;
            }

            if (invert)
            {
                result = 1 - result;
            }

            return(result);
        }