/// <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) * 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 = (Math.Log(ch1) - Constants.LogSqrt2Pi - (Math.Log(x) / 2.0)) + x; if (test > Math.Log(xmax)) { throw new ArithmeticException("ERROR IN MISCFUN FUNCTION STRVL0: ARGUMENT CAUSES OVERFLOW"); } return(Math.Exp(test) - ((Constants.TwoInvPi * ch2) / x)); }
/// <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. /// </summary> public static Func <double, double> PolynomialFunc(double[] x, double[] y, int order) { var parameters = Polynomial(x, y, order); return(z => Evaluate.Polynomial(z, parameters)); }
/// <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) * 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 = (Math.Log(ch1) - Constants.LogSqrt2Pi - (Math.Log(x) / 2.0)) + x; if (test > Math.Log(xmax)) { throw new ArithmeticException("ERROR IN MISCFUN FUNCTION STRVL1: ARGUMENT CAUSES OVERFLOW"); } return(Math.Exp(test) - (Constants.TwoInvPi * ch2)); }
/// <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 = Math.Sqrt(-2 * 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 = Math.Sqrt(-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); }
/// <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 = 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); }
/// <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> private 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[] P = new[] { -0.000508781949658280665617, -0.00836874819741736770379, 0.0334806625409744615033, -0.0126926147662974029034, -0.0365637971411762664006, 0.0219878681111168899165, 0.00822687874676915743155, -0.00538772965071242932965 }; double[] Q = new[] { 1, -0.970005043303290640362, -1.56574558234175846809, 1.56221558398423026363, 0.662328840472002992063, -0.71228902341542847553, -0.0527396382340099713954, 0.0795283687341571680018, -0.00233393759374190016776, 0.000886216390456424707504 }; double g = p * (p + 10); double r = Evaluate.Polynomial(p, P) / Evaluate.Polynomial(p, Q); 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[] P = new[] { -0.202433508355938759655, 0.105264680699391713268, 8.37050328343119927838, 17.6447298408374015486, -18.8510648058714251895, -44.6382324441786960818, 17.445385985570866523, 21.1294655448340526258, -3.67192254707729348546 }; double[] Q = new[] { 1, 6.24264124854247537712, 3.9713437953343869095, -28.6608180499800029974, -20.1432634680485188801, 48.5609213108739935468, 10.8268667355460159008, -22.6436933413139721736, 1.72114765761200282724 }; double g = Math.Sqrt(-2 * Math.Log(q)); double xs = q - 0.25; double r = Evaluate.Polynomial(xs, P) / Evaluate.Polynomial(xs, Q); 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 = Math.Sqrt(-Math.Log(q)); if (x < 3) { // Max error found: 1.089051e-20 const float Y = 0.807220458984375f; double[] P = new[] { -0.131102781679951906451, -0.163794047193317060787, 0.117030156341995252019, 0.387079738972604337464, 0.337785538912035898924, 0.142869534408157156766, 0.0290157910005329060432, 0.00214558995388805277169, -0.679465575181126350155e-6, 0.285225331782217055858e-7, -0.681149956853776992068e-9 }; double[] Q = new[] { 1, 3.46625407242567245975, 5.38168345707006855425, 4.77846592945843778382, 2.59301921623620271374, 0.848854343457902036425, 0.152264338295331783612, 0.01105924229346489121 }; double xs = x - 1.125; double R = Evaluate.Polynomial(xs, P) / Evaluate.Polynomial(xs, Q); result = (Y * x) + (R * x); } else if (x < 6) { // Max error found: 8.389174e-21 const float Y = 0.93995571136474609375f; double[] P = new[] { -0.0350353787183177984712, -0.00222426529213447927281, 0.0185573306514231072324, 0.00950804701325919603619, 0.00187123492819559223345, 0.000157544617424960554631, 0.460469890584317994083e-5, -0.230404776911882601748e-9, 0.266339227425782031962e-11 }; double[] Q = new[] { 1, 1.3653349817554063097, 0.762059164553623404043, 0.220091105764131249824, 0.0341589143670947727934, 0.00263861676657015992959, 0.764675292302794483503e-4 }; double xs = x - 3; double R = Evaluate.Polynomial(xs, P) / Evaluate.Polynomial(xs, Q); result = (Y * x) + (R * x); } else if (x < 18) { // Max error found: 1.481312e-19 const float Y = 0.98362827301025390625f; double[] P = new[] { -0.0167431005076633737133, -0.00112951438745580278863, 0.00105628862152492910091, 0.000209386317487588078668, 0.149624783758342370182e-4, 0.449696789927706453732e-6, 0.462596163522878599135e-8, -0.281128735628831791805e-13, 0.99055709973310326855e-16 }; double[] Q = new[] { 1, 0.591429344886417493481, 0.138151865749083321638, 0.0160746087093676504695, 0.000964011807005165528527, 0.275335474764726041141e-4, 0.282243172016108031869e-6 }; double xs = x - 6; double R = Evaluate.Polynomial(xs, P) / Evaluate.Polynomial(xs, Q); result = (Y * x) + (R * x); } else if (x < 44) { // Max error found: 5.697761e-20 const float Y = 0.99714565277099609375f; double[] P = new[] { -0.0024978212791898131227, -0.779190719229053954292e-5, 0.254723037413027451751e-4, 0.162397777342510920873e-5, 0.396341011304801168516e-7, 0.411632831190944208473e-9, 0.145596286718675035587e-11, -0.116765012397184275695e-17 }; double[] Q = new[] { 1, 0.207123112214422517181, 0.0169410838120975906478, 0.000690538265622684595676, 0.145007359818232637924e-4, 0.144437756628144157666e-6, 0.509761276599778486139e-9 }; double xs = x - 18; double R = Evaluate.Polynomial(xs, P) / Evaluate.Polynomial(xs, Q); result = (Y * x) + (R * x); } else { // Max error found: 1.279746e-20 const float Y = 0.99941349029541015625f; double[] P = new[] { -0.000539042911019078575891, -0.28398759004727721098e-6, 0.899465114892291446442e-6, 0.229345859265920864296e-7, 0.225561444863500149219e-9, 0.947846627503022684216e-12, 0.135880130108924861008e-14, -0.348890393399948882918e-21 }; double[] Q = new[] { 1, 0.0845746234001899436914, 0.00282092984726264681981, 0.468292921940894236786e-4, 0.399968812193862100054e-6, 0.161809290887904476097e-8, 0.231558608310259605225e-11 }; double xs = x - 44; double R = Evaluate.Polynomial(xs, P) / Evaluate.Polynomial(xs, Q); result = (Y * x) + (R * x); } } return(s * result); }
/// <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> private 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 double[] n = new[] { 0.00337916709551257388990745, -0.00073695653048167948530905, -0.374732337392919607868241, 0.0817442448733587196071743, -0.0421089319936548595203468, 0.0070165709512095756344528, -0.00495091255982435110337458, 0.000871646599037922480317225 }; double[] d = new[] { 1, -0.218088218087924645390535, 0.412542972725442099083918, -0.0841891147873106755410271, 0.0655338856400241519690695, -0.0120019604454941768171266, 0.00408165558926174048329689, -0.000615900721557769691924509 }; result = (z * 1.125) + (z * Evaluate.Polynomial(z, n) / Evaluate.Polynomial(z, d)); } } 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 double[] n = new[] { -0.0361790390718262471360258, 0.292251883444882683221149, 0.281447041797604512774415, 0.125610208862766947294894, 0.0274135028268930549240776, 0.00250839672168065762786937 }; double[] d = new[] { 1, 1.8545005897903486499845, 1.43575803037831418074962, 0.582827658753036572454135, 0.124810476932949746447682, 0.0113724176546353285778481 }; r = Evaluate.Polynomial(z - 0.5, n) / Evaluate.Polynomial(z - 0.5, d); b = 0.3440242112F; } else if (z < 1.25) { // Worst case absolute error found: 4.01854729e-21 double[] n = new[] { -0.0397876892611136856954425, 0.153165212467878293257683, 0.191260295600936245503129, 0.10276327061989304213645, 0.029637090615738836726027, 0.0046093486780275489468812, 0.000307607820348680180548455 }; double[] d = new[] { 1, 1.95520072987627704987886, 1.64762317199384860109595, 0.768238607022126250082483, 0.209793185936509782784315, 0.0319569316899913392596356, 0.00213363160895785378615014 }; r = Evaluate.Polynomial(z - 0.75, n) / Evaluate.Polynomial(z - 0.75, d); b = 0.419990927F; } else if (z < 2.25) { // Worst case absolute error found: 2.866005373e-21 double[] n = new[] { -0.0300838560557949717328341, 0.0538578829844454508530552, 0.0726211541651914182692959, 0.0367628469888049348429018, 0.00964629015572527529605267, 0.00133453480075291076745275, 0.778087599782504251917881e-4 }; double[] d = new[] { 1, 1.75967098147167528287343, 1.32883571437961120556307, 0.552528596508757581287907, 0.133793056941332861912279, 0.0179509645176280768640766, 0.00104712440019937356634038, -0.106640381820357337177643e-7 }; r = Evaluate.Polynomial(z - 1.25, n) / Evaluate.Polynomial(z - 1.25, d); b = 0.4898625016F; } else if (z < 3.5) { // Worst case absolute error found: 1.045355789e-21 double[] n = new[] { -0.0117907570137227847827732, 0.014262132090538809896674, 0.0202234435902960820020765, 0.00930668299990432009042239, 0.00213357802422065994322516, 0.00025022987386460102395382, 0.120534912219588189822126e-4 }; double[] d = new[] { 1, 1.50376225203620482047419, 0.965397786204462896346934, 0.339265230476796681555511, 0.0689740649541569716897427, 0.00771060262491768307365526, 0.000371421101531069302990367 }; r = Evaluate.Polynomial(z - 2.25, n) / Evaluate.Polynomial(z - 2.25, d); b = 0.5317370892F; } else if (z < 5.25) { // Worst case absolute error found: 8.300028706e-22 double[] n = new[] { -0.00546954795538729307482955, 0.00404190278731707110245394, 0.0054963369553161170521356, 0.00212616472603945399437862, 0.000394984014495083900689956, 0.365565477064442377259271e-4, 0.135485897109932323253786e-5 }; double[] d = new[] { 1, 1.21019697773630784832251, 0.620914668221143886601045, 0.173038430661142762569515, 0.0276550813773432047594539, 0.00240625974424309709745382, 0.891811817251336577241006e-4, -0.465528836283382684461025e-11 }; r = Evaluate.Polynomial(z - 3.5, n) / Evaluate.Polynomial(z - 3.5, d); b = 0.5489973426F; } else if (z < 8) { // Worst case absolute error found: 1.700157534e-21 double[] n = new[] { -0.00270722535905778347999196, 0.0013187563425029400461378, 0.00119925933261002333923989, 0.00027849619811344664248235, 0.267822988218331849989363e-4, 0.923043672315028197865066e-6 }; double[] d = new[] { 1, 0.814632808543141591118279, 0.268901665856299542168425, 0.0449877216103041118694989, 0.00381759663320248459168994, 0.000131571897888596914350697, 0.404815359675764138445257e-11 }; r = Evaluate.Polynomial(z - 5.25, n) / Evaluate.Polynomial(z - 5.25, d); b = 0.5571740866F; } else if (z < 11.5) { // Worst case absolute error found: 3.002278011e-22 double[] n = new[] { -0.00109946720691742196814323, 0.000406425442750422675169153, 0.000274499489416900707787024, 0.465293770646659383436343e-4, 0.320955425395767463401993e-5, 0.778286018145020892261936e-7 }; double[] d = new[] { 1, 0.588173710611846046373373, 0.139363331289409746077541, 0.0166329340417083678763028, 0.00100023921310234908642639, 0.24254837521587225125068e-4 }; r = Evaluate.Polynomial(z - 8, n) / Evaluate.Polynomial(z - 8, d); b = 0.5609807968F; } else if (z < 17) { // Worst case absolute error found: 6.741114695e-21 double[] n = new[] { -0.00056907993601094962855594, 0.000169498540373762264416984, 0.518472354581100890120501e-4, 0.382819312231928859704678e-5, 0.824989931281894431781794e-7 }; double[] d = new[] { 1, 0.339637250051139347430323, 0.043472647870310663055044, 0.00248549335224637114641629, 0.535633305337152900549536e-4, -0.117490944405459578783846e-12 }; r = Evaluate.Polynomial(z - 11.5, n) / Evaluate.Polynomial(z - 11.5, d); b = 0.5626493692F; } else if (z < 24) { // Worst case absolute error found: 7.802346984e-22 double[] n = new[] { -0.000241313599483991337479091, 0.574224975202501512365975e-4, 0.115998962927383778460557e-4, 0.581762134402593739370875e-6, 0.853971555085673614607418e-8 }; double[] d = new[] { 1, 0.233044138299687841018015, 0.0204186940546440312625597, 0.000797185647564398289151125, 0.117019281670172327758019e-4 }; r = Evaluate.Polynomial(z - 17, n) / Evaluate.Polynomial(z - 17, d); b = 0.5634598136F; } else if (z < 38) { // Worst case absolute error found: 2.414228989e-22 double[] n = new[] { -0.000146674699277760365803642, 0.162666552112280519955647e-4, 0.269116248509165239294897e-5, 0.979584479468091935086972e-7, 0.101994647625723465722285e-8 }; double[] d = new[] { 1, 0.165907812944847226546036, 0.0103361716191505884359634, 0.000286593026373868366935721, 0.298401570840900340874568e-5 }; r = Evaluate.Polynomial(z - 24, n) / Evaluate.Polynomial(z - 24, d); b = 0.5638477802F; } else if (z < 60) { // Worst case absolute error found: 5.896543869e-24 double[] n = new[] { -0.583905797629771786720406e-4, 0.412510325105496173512992e-5, 0.431790922420250949096906e-6, 0.993365155590013193345569e-8, 0.653480510020104699270084e-10 }; double[] d = new[] { 1, 0.105077086072039915406159, 0.00414278428675475620830226, 0.726338754644523769144108e-4, 0.477818471047398785369849e-6 }; r = Evaluate.Polynomial(z - 38, n) / Evaluate.Polynomial(z - 38, d); b = 0.5640528202F; } else if (z < 85) { // Worst case absolute error found: 3.080612264e-21 double[] n = new[] { -0.196457797609229579459841e-4, 0.157243887666800692441195e-5, 0.543902511192700878690335e-7, 0.317472492369117710852685e-9 }; double[] d = new[] { 1, 0.052803989240957632204885, 0.000926876069151753290378112, 0.541011723226630257077328e-5, 0.535093845803642394908747e-15 }; r = Evaluate.Polynomial(z - 60, n) / Evaluate.Polynomial(z - 60, d); b = 0.5641309023F; } else { // Worst case absolute error found: 8.094633491e-22 double[] n = new[] { -0.789224703978722689089794e-5, 0.622088451660986955124162e-6, 0.145728445676882396797184e-7, 0.603715505542715364529243e-10 }; double[] d = new[] { 1, 0.0375328846356293715248719, 0.000467919535974625308126054, 0.193847039275845656900547e-5 }; r = Evaluate.Polynomial(z - 85, n) / Evaluate.Polynomial(z - 85, d); b = 0.5641584396F; } double g = 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); }
/// <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)); }