File indexing completed on 2024-05-12 03:47:49
0001 /* 0002 SPDX-FileCopyrightText: 2012 Massachusetts Institute of Technology 0003 SPDX-License-Identifier: MIT 0004 */ 0005 0006 /* (Note that this file can be compiled with either C++, in which 0007 case it uses C++ std::complex<double>, or C, in which case it 0008 uses C99 double complex.) */ 0009 0010 /* Available at: http://ab-initio.mit.edu/Faddeeva 0011 0012 Computes various error functions (erf, erfc, erfi, erfcx), 0013 including the Dawson integral, in the complex plane, based 0014 on algorithms for the computation of the Faddeeva function 0015 w(z) = exp(-z^2) * erfc(-i*z). 0016 Given w(z), the error functions are mostly straightforward 0017 to compute, except for certain regions where we have to 0018 switch to Taylor expansions to avoid cancellation errors 0019 [e.g. near the origin for erf(z)]. 0020 0021 To compute the Faddeeva function, we use a combination of two 0022 algorithms: 0023 0024 For sufficiently large |z|, we use a continued-fraction expansion 0025 for w(z) similar to those described in: 0026 0027 Walter Gautschi, "Efficient computation of the complex error 0028 function," SIAM J. Numer. Anal. 7(1), pp. 187-198 (1970) 0029 0030 G. P. M. Poppe and C. M. J. Wijers, "More efficient computation 0031 of the complex error function," ACM Trans. Math. Soft. 16(1), 0032 pp. 38-46 (1990). 0033 0034 Unlike those papers, however, we switch to a completely different 0035 algorithm for smaller |z|: 0036 0037 Mofreh R. Zaghloul and Ahmed N. Ali, "Algorithm 916: Computing the 0038 Faddeyeva and Voigt Functions," ACM Trans. Math. Soft. 38(2), 15 0039 (2011). 0040 0041 (I initially used this algorithm for all z, but it turned out to be 0042 significantly slower than the continued-fraction expansion for 0043 larger |z|. On the other hand, it is competitive for smaller |z|, 0044 and is significantly more accurate than the Poppe & Wijers code 0045 in some regions, e.g. in the vicinity of z=1+1i.) 0046 0047 Note that this is an INDEPENDENT RE-IMPLEMENTATION of these algorithms, 0048 based on the description in the papers ONLY. In particular, I did 0049 not refer to the authors' Fortran or Matlab implementations, respectively, 0050 (which are under restrictive ACM copyright terms and therefore unusable 0051 in free/open-source software). 0052 0053 Steven G. Johnson, Massachusetts Institute of Technology 0054 https://math.mit.edu/~stevenj 0055 October 2012. 0056 0057 -- Note that Algorithm 916 assumes that the erfc(x) function, 0058 or rather the scaled function erfcx(x) = exp(x*x)*erfc(x), 0059 is supplied for REAL arguments x. I originally used an 0060 erfcx routine derived from DERFC in SLATEC, but I have 0061 since replaced it with a much faster routine written by 0062 me which uses a combination of continued-fraction expansions 0063 and a lookup table of Chebyshev polynomials. For speed, 0064 I implemented a similar algorithm for Im[w(x)] of real x, 0065 since this comes up frequently in the other error functions. 0066 0067 A small test program is included the end, which checks 0068 the w(z) etc. results against several known values. To compile 0069 the test function, compile with -DTEST_FADDEEVA (that is, 0070 #define TEST_FADDEEVA). 0071 0072 If HAVE_CONFIG_H is #defined (e.g. by compiling with -DHAVE_CONFIG_H), 0073 then we #include "config.h", which is assumed to be a GNU autoconf-style 0074 header defining HAVE_* macros to indicate the presence of features. In 0075 particular, if HAVE_ISNAN and HAVE_ISINF are #defined, we use those 0076 functions in math.h instead of defining our own, and if HAVE_ERF and/or 0077 HAVE_ERFC are defined we use those functions from <cmath> for erf and 0078 erfc of real arguments, respectively, instead of defining our own. 0079 0080 REVISION HISTORY: 0081 4 October 2012: Initial public release (SGJ) 0082 5 October 2012: Revised (SGJ) to fix spelling error, 0083 start summation for large x at round(x/a) (> 1) 0084 rather than ceil(x/a) as in the original 0085 paper, which should slightly improve performance 0086 (and, apparently, slightly improves accuracy) 0087 19 October 2012: Revised (SGJ) to fix bugs for large x, large -y, 0088 and 15<x<26. Performance improvements. Prototype 0089 now supplies default value for relerr. 0090 24 October 2012: Switch to continued-fraction expansion for 0091 sufficiently large z, for performance reasons. 0092 Also, avoid spurious overflow for |z| > 1e154. 0093 Set relerr argument to min(relerr,0.1). 0094 27 October 2012: Enhance accuracy in Re[w(z)] taken by itself, 0095 by switching to Alg. 916 in a region near 0096 the real-z axis where continued fractions 0097 have poor relative accuracy in Re[w(z)]. Thanks 0098 to M. Zaghloul for the tip. 0099 29 October 2012: Replace SLATEC-derived erfcx routine with 0100 completely rewritten code by me, using a very 0101 different algorithm which is much faster. 0102 30 October 2012: Implemented special-case code for real z 0103 (where real part is exp(-x^2) and imag part is 0104 Dawson integral), using algorithm similar to erfx. 0105 Export ImFaddeeva_w function to make Dawson's 0106 integral directly accessible. 0107 3 November 2012: Provide implementations of erf, erfc, erfcx, 0108 and Dawson functions in Faddeeva:: namespace, 0109 in addition to Faddeeva::w. Provide header 0110 file Faddeeva.hh. 0111 4 November 2012: Slightly faster erf for real arguments. 0112 Updated MATLAB and Octave plugins. 0113 27 November 2012: Support compilation with either C++ or 0114 plain C (using C99 complex numbers). 0115 For real x, use standard-library erf(x) 0116 and erfc(x) if available (for C99 or C++11). 0117 #include "config.h" if HAVE_CONFIG_H is #defined. 0118 15 December 2012: Portability fixes (copysign, Inf/NaN creation), 0119 use CMPLX/__builtin_complex if available in C, 0120 slight accuracy improvements to erf and dawson 0121 functions near the origin. Use gnulib functions 0122 if GNULIB_NAMESPACE is defined. 0123 18 December 2012: Slight tweaks (remove recomputation of x*x in Dawson) 0124 12 May 2015: Bugfix for systems lacking copysign function. 0125 */ 0126 0127 ///////////////////////////////////////////////////////////////////////// 0128 /* If this file is compiled as a part of a larger project, 0129 support using an autoconf-style config.h header file 0130 (with various "HAVE_*" #defines to indicate features) 0131 if HAVE_CONFIG_H is #defined (in GNU autotools style). */ 0132 0133 #ifdef HAVE_CONFIG_H 0134 # include "config.h" 0135 #endif 0136 0137 ///////////////////////////////////////////////////////////////////////// 0138 // macros to allow us to use either C++ or C (with C99 features) 0139 0140 #ifdef __cplusplus 0141 0142 # include "Faddeeva.hh" 0143 0144 # include <cfloat> 0145 # include <cmath> 0146 # include <limits> 0147 using namespace std; 0148 0149 // use std::numeric_limits, since 1./0. and 0./0. fail with some compilers (MS) 0150 # define Inf numeric_limits<double>::infinity() 0151 # define NaN numeric_limits<double>::quiet_NaN() 0152 0153 typedef complex<double> cmplx; 0154 0155 // Use C-like complex syntax, since the C syntax is more restrictive 0156 # define cexp(z) exp(z) 0157 # define creal(z) real(z) 0158 # define cimag(z) imag(z) 0159 # define cpolar(r,t) polar(r,t) 0160 0161 # define C(a,b) cmplx(a,b) 0162 0163 # define FADDEEVA(name) Faddeeva::name 0164 # define FADDEEVA_RE(name) Faddeeva::name 0165 0166 // isnan/isinf were introduced in C++11 0167 # if (__cplusplus < 201103L) && (!defined(HAVE_ISNAN) || !defined(HAVE_ISINF)) 0168 static inline bool my_isnan(double x) { return x != x; } 0169 # define isnan my_isnan 0170 static inline bool my_isinf(double x) { return 1/x == 0.; } 0171 # define isinf my_isinf 0172 # elif (__cplusplus >= 201103L) 0173 // g++ gets confused between the C and C++ isnan/isinf functions 0174 # define isnan std::isnan 0175 # define isinf std::isinf 0176 # endif 0177 0178 // copysign was introduced in C++11 (and is also in POSIX and C99) 0179 # if defined(_WIN32) || defined(__WIN32__) 0180 # define copysign _copysign // of course MS had to be different 0181 # elif defined(GNULIB_NAMESPACE) // we are using using gnulib <cmath> 0182 # define copysign GNULIB_NAMESPACE::copysign 0183 # elif (__cplusplus < 201103L) && !defined(HAVE_COPYSIGN) && !defined(__linux__) && !(defined(__APPLE__) && defined(__MACH__)) && !defined(_AIX) 0184 static inline double my_copysign(double x, double y) { return x<0 != y<0 ? -x : x; } 0185 # define copysign my_copysign 0186 # endif 0187 0188 // If we are using the gnulib <cmath> (e.g. in the GNU Octave sources), 0189 // gnulib generates a link warning if we use ::floor instead of gnulib::floor. 0190 // This warning is completely innocuous because the only difference between 0191 // gnulib::floor and the system ::floor (and only on ancient OSF systems) 0192 // has to do with floor(-0), which doesn't occur in the usage below, but 0193 // the Octave developers prefer that we silence the warning. 0194 # ifdef GNULIB_NAMESPACE 0195 # define floor GNULIB_NAMESPACE::floor 0196 # endif 0197 0198 #else // !__cplusplus, i.e. pure C (requires C99 features) 0199 0200 # include "Faddeeva.h" 0201 0202 # ifndef _GNU_SOURCE 0203 # define _GNU_SOURCE // enable GNU libc NAN extension if possible 0204 # endif 0205 0206 # include <float.h> 0207 # include <math.h> 0208 0209 typedef double complex cmplx; 0210 0211 # define FADDEEVA(name) Faddeeva_ ## name 0212 # define FADDEEVA_RE(name) Faddeeva_ ## name ## _re 0213 0214 /* Constructing complex numbers like 0+i*NaN is problematic in C99 0215 without the C11 CMPLX macro, because 0.+I*NAN may give NaN+i*NAN if 0216 I is a complex (rather than imaginary) constant. For some reason, 0217 however, it works fine in (pre-4.7) gcc if I define Inf and NaN as 0218 1/0 and 0/0 (and only if I compile with optimization -O1 or more), 0219 but not if I use the INFINITY or NAN macros. */ 0220 0221 /* __builtin_complex was introduced in gcc 4.7, but the C11 CMPLX macro 0222 may not be defined unless we are using a recent (2012) version of 0223 glibc and compile with -std=c11... note that icc lies about being 0224 gcc and probably doesn't have this builtin(?), so exclude icc explicitly */ 0225 # if !defined(CMPLX) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !(defined(__ICC) || defined(__INTEL_COMPILER)) 0226 # define CMPLX(a,b) __builtin_complex((double) (a), (double) (b)) 0227 # endif 0228 0229 # ifdef CMPLX // C11 0230 # define C(a,b) CMPLX(a,b) 0231 # define Inf INFINITY // C99 infinity 0232 # ifdef NAN // GNU libc extension 0233 # define NaN NAN 0234 # else 0235 # define NaN (0./0.) // NaN 0236 # endif 0237 # else 0238 # define C(a,b) ((a) + I*(b)) 0239 # define Inf (1./0.) 0240 # define NaN (0./0.) 0241 # endif 0242 0243 static inline cmplx cpolar(double r, double t) 0244 { 0245 if (r == 0.0 && !isnan(t)) 0246 return 0.0; 0247 else 0248 return C(r * cos(t), r * sin(t)); 0249 } 0250 0251 #endif // !__cplusplus, i.e. pure C (requires C99 features) 0252 0253 ///////////////////////////////////////////////////////////////////////// 0254 // Auxiliary routines to compute other special functions based on w(z) 0255 0256 // compute erfcx(z) = exp(z^2) erfz(z) 0257 cmplx FADDEEVA(erfcx)(cmplx z, double relerr) 0258 { 0259 return FADDEEVA(w)(C(-cimag(z), creal(z)), relerr); 0260 } 0261 0262 // compute the error function erf(x) 0263 double FADDEEVA_RE(erf)(double x) 0264 { 0265 #if !defined(__cplusplus) 0266 return erf(x); // C99 supplies erf in math.h 0267 #elif (defined(__cplusplus) && __cplusplus >= 201103L) || defined(HAVE_ERF) 0268 return ::erf(x); // C++11 supplies std::erf in cmath 0269 #else 0270 double mx2 = -x*x; 0271 if (mx2 < -750) // underflow 0272 return (x >= 0 ? 1.0 : -1.0); 0273 0274 if (x >= 0) { 0275 if (x < 8e-2) goto taylor; 0276 return 1.0 - exp(mx2) * FADDEEVA_RE(erfcx)(x); 0277 } 0278 else { // x < 0 0279 if (x > -8e-2) goto taylor; 0280 return exp(mx2) * FADDEEVA_RE(erfcx)(-x) - 1.0; 0281 } 0282 0283 // Use Taylor series for small |x|, to avoid cancellation inaccuracy 0284 // erf(x) = 2/sqrt(pi) * x * (1 - x^2/3 + x^4/10 - x^6/42 + x^8/216 + ...) 0285 taylor: 0286 return x * (1.1283791670955125739 0287 + mx2 * (0.37612638903183752464 0288 + mx2 * (0.11283791670955125739 0289 + mx2 * (0.026866170645131251760 0290 + mx2 * 0.0052239776254421878422)))); 0291 #endif 0292 } 0293 0294 // compute the error function erf(z) 0295 cmplx FADDEEVA(erf)(cmplx z, double relerr) 0296 { 0297 double x = creal(z), y = cimag(z); 0298 0299 if (y == 0) 0300 return C(FADDEEVA_RE(erf)(x), 0301 y); // preserve sign of 0 0302 if (x == 0) // handle separately for speed & handling of y = Inf or NaN 0303 return C(x, // preserve sign of 0 0304 /* handle y -> Inf limit manually, since 0305 exp(y^2) -> Inf but Im[w(y)] -> 0, so 0306 IEEE will give us a NaN when it should be Inf */ 0307 y*y > 720 ? (y > 0 ? Inf : -Inf) 0308 : exp(y*y) * FADDEEVA(w_im)(y)); 0309 0310 double mRe_z2 = (y - x) * (x + y); // Re(-z^2), being careful of overflow 0311 double mIm_z2 = -2*x*y; // Im(-z^2) 0312 if (mRe_z2 < -750) // underflow 0313 return (x >= 0 ? 1.0 : -1.0); 0314 0315 /* Handle positive and negative x via different formulas, 0316 using the mirror symmetries of w, to avoid overflow/underflow 0317 problems from multiplying exponentially large and small quantities. */ 0318 if (x >= 0) { 0319 if (x < 8e-2) { 0320 if (fabs(y) < 1e-2) 0321 goto taylor; 0322 else if (fabs(mIm_z2) < 5e-3 && x < 5e-3) 0323 goto taylor_erfi; 0324 } 0325 /* don't use complex exp function, since that will produce spurious NaN 0326 values when multiplying w in an overflow situation. */ 0327 return 1.0 - exp(mRe_z2) * 0328 (C(cos(mIm_z2), sin(mIm_z2)) 0329 * FADDEEVA(w)(C(-y,x), relerr)); 0330 } 0331 else { // x < 0 0332 if (x > -8e-2) { // duplicate from above to avoid fabs(x) call 0333 if (fabs(y) < 1e-2) 0334 goto taylor; 0335 else if (fabs(mIm_z2) < 5e-3 && x > -5e-3) 0336 goto taylor_erfi; 0337 } 0338 else if (isnan(x)) 0339 return C(NaN, y == 0 ? 0 : NaN); 0340 /* don't use complex exp function, since that will produce spurious NaN 0341 values when multiplying w in an overflow situation. */ 0342 return exp(mRe_z2) * 0343 (C(cos(mIm_z2), sin(mIm_z2)) 0344 * FADDEEVA(w)(C(y,-x), relerr)) - 1.0; 0345 } 0346 0347 // Use Taylor series for small |z|, to avoid cancellation inaccuracy 0348 // erf(z) = 2/sqrt(pi) * z * (1 - z^2/3 + z^4/10 - z^6/42 + z^8/216 + ...) 0349 taylor: 0350 { 0351 cmplx mz2 = C(mRe_z2, mIm_z2); // -z^2 0352 return z * (1.1283791670955125739 0353 + mz2 * (0.37612638903183752464 0354 + mz2 * (0.11283791670955125739 0355 + mz2 * (0.026866170645131251760 0356 + mz2 * 0.0052239776254421878422)))); 0357 } 0358 0359 /* for small |x| and small |xy|, 0360 use Taylor series to avoid cancellation inaccuracy: 0361 erf(x+iy) = erf(iy) 0362 + 2*exp(y^2)/sqrt(pi) * 0363 [ x * (1 - x^2 * (1+2y^2)/3 + x^4 * (3+12y^2+4y^4)/30 + ... 0364 - i * x^2 * y * (1 - x^2 * (3+2y^2)/6 + ...) ] 0365 where: 0366 erf(iy) = exp(y^2) * Im[w(y)] 0367 */ 0368 taylor_erfi: 0369 { 0370 double x2 = x*x, y2 = y*y; 0371 double expy2 = exp(y2); 0372 return C 0373 (expy2 * x * (1.1283791670955125739 0374 - x2 * (0.37612638903183752464 0375 + 0.75225277806367504925*y2) 0376 + x2*x2 * (0.11283791670955125739 0377 + y2 * (0.45135166683820502956 0378 + 0.15045055561273500986*y2))), 0379 expy2 * (FADDEEVA(w_im)(y) 0380 - x2*y * (1.1283791670955125739 0381 - x2 * (0.56418958354775628695 0382 + 0.37612638903183752464*y2)))); 0383 } 0384 } 0385 0386 // erfi(z) = -i erf(iz) 0387 cmplx FADDEEVA(erfi)(cmplx z, double relerr) 0388 { 0389 cmplx e = FADDEEVA(erf)(C(-cimag(z),creal(z)), relerr); 0390 return C(cimag(e), -creal(e)); 0391 } 0392 0393 // erfi(x) = -i erf(ix) 0394 double FADDEEVA_RE(erfi)(double x) 0395 { 0396 return x*x > 720 ? (x > 0 ? Inf : -Inf) 0397 : exp(x*x) * FADDEEVA(w_im)(x); 0398 } 0399 0400 // erfc(x) = 1 - erf(x) 0401 double FADDEEVA_RE(erfc)(double x) 0402 { 0403 #if !defined(__cplusplus) 0404 return erfc(x); // C99 supplies erfc in math.h 0405 #elif (defined(__cplusplus) && __cplusplus >= 201103L) || defined(HAVE_ERFC) 0406 return ::erfc(x); // C++11 supplies std::erfc in cmath 0407 #else 0408 if (x*x > 750) // underflow 0409 return (x >= 0 ? 0.0 : 2.0); 0410 return x >= 0 ? exp(-x*x) * FADDEEVA_RE(erfcx)(x) 0411 : 2. - exp(-x*x) * FADDEEVA_RE(erfcx)(-x); 0412 #endif 0413 } 0414 0415 // erfc(z) = 1 - erf(z) 0416 cmplx FADDEEVA(erfc)(cmplx z, double relerr) 0417 { 0418 double x = creal(z), y = cimag(z); 0419 0420 if (x == 0.) 0421 return C(1, 0422 /* handle y -> Inf limit manually, since 0423 exp(y^2) -> Inf but Im[w(y)] -> 0, so 0424 IEEE will give us a NaN when it should be Inf */ 0425 y*y > 720 ? (y > 0 ? -Inf : Inf) 0426 : -exp(y*y) * FADDEEVA(w_im)(y)); 0427 if (y == 0.) { 0428 if (x*x > 750) // underflow 0429 return C(x >= 0 ? 0.0 : 2.0, 0430 -y); // preserve sign of 0 0431 return C(x >= 0 ? exp(-x*x) * FADDEEVA_RE(erfcx)(x) 0432 : 2. - exp(-x*x) * FADDEEVA_RE(erfcx)(-x), 0433 -y); // preserve sign of zero 0434 } 0435 0436 double mRe_z2 = (y - x) * (x + y); // Re(-z^2), being careful of overflow 0437 double mIm_z2 = -2*x*y; // Im(-z^2) 0438 if (mRe_z2 < -750) // underflow 0439 return (x >= 0 ? 0.0 : 2.0); 0440 0441 if (x >= 0) 0442 return cexp(C(mRe_z2, mIm_z2)) 0443 * FADDEEVA(w)(C(-y,x), relerr); 0444 else 0445 return 2.0 - cexp(C(mRe_z2, mIm_z2)) 0446 * FADDEEVA(w)(C(y,-x), relerr); 0447 } 0448 0449 // compute Dawson(x) = sqrt(pi)/2 * exp(-x^2) * erfi(x) 0450 double FADDEEVA_RE(Dawson)(double x) 0451 { 0452 const double spi2 = 0.8862269254527580136490837416705725913990; // sqrt(pi)/2 0453 return spi2 * FADDEEVA(w_im)(x); 0454 } 0455 0456 // compute Dawson(z) = sqrt(pi)/2 * exp(-z^2) * erfi(z) 0457 cmplx FADDEEVA(Dawson)(cmplx z, double relerr) 0458 { 0459 const double spi2 = 0.8862269254527580136490837416705725913990; // sqrt(pi)/2 0460 double x = creal(z), y = cimag(z); 0461 0462 // handle axes separately for speed & proper handling of x or y = Inf or NaN 0463 if (y == 0) 0464 return C(spi2 * FADDEEVA(w_im)(x), 0465 -y); // preserve sign of 0 0466 if (x == 0) { 0467 double y2 = y*y; 0468 if (y2 < 2.5e-5) { // Taylor expansion 0469 return C(x, // preserve sign of 0 0470 y * (1. 0471 + y2 * (0.6666666666666666666666666666666666666667 0472 + y2 * 0.26666666666666666666666666666666666667))); 0473 } 0474 return C(x, // preserve sign of 0 0475 spi2 * (y >= 0 0476 ? exp(y2) - FADDEEVA_RE(erfcx)(y) 0477 : FADDEEVA_RE(erfcx)(-y) - exp(y2))); 0478 } 0479 0480 double mRe_z2 = (y - x) * (x + y); // Re(-z^2), being careful of overflow 0481 double mIm_z2 = -2*x*y; // Im(-z^2) 0482 cmplx mz2 = C(mRe_z2, mIm_z2); // -z^2 0483 0484 /* Handle positive and negative x via different formulas, 0485 using the mirror symmetries of w, to avoid overflow/underflow 0486 problems from multiplying exponentially large and small quantities. */ 0487 if (y >= 0) { 0488 if (y < 5e-3) { 0489 if (fabs(x) < 5e-3) 0490 goto taylor; 0491 else if (fabs(mIm_z2) < 5e-3) 0492 goto taylor_realaxis; 0493 } 0494 cmplx res = cexp(mz2) - FADDEEVA(w)(z, relerr); 0495 return spi2 * C(-cimag(res), creal(res)); 0496 } 0497 else { // y < 0 0498 if (y > -5e-3) { // duplicate from above to avoid fabs(x) call 0499 if (fabs(x) < 5e-3) 0500 goto taylor; 0501 else if (fabs(mIm_z2) < 5e-3) 0502 goto taylor_realaxis; 0503 } 0504 else if (isnan(y)) 0505 return C(x == 0 ? 0 : NaN, NaN); 0506 cmplx res = FADDEEVA(w)(-z, relerr) - cexp(mz2); 0507 return spi2 * C(-cimag(res), creal(res)); 0508 } 0509 0510 // Use Taylor series for small |z|, to avoid cancellation inaccuracy 0511 // dawson(z) = z - 2/3 z^3 + 4/15 z^5 + ... 0512 taylor: 0513 return z * (1. 0514 + mz2 * (0.6666666666666666666666666666666666666667 0515 + mz2 * 0.2666666666666666666666666666666666666667)); 0516 0517 /* for small |y| and small |xy|, 0518 use Taylor series to avoid cancellation inaccuracy: 0519 dawson(x + iy) 0520 = D + y^2 (D + x - 2Dx^2) 0521 + y^4 (D/2 + 5x/6 - 2Dx^2 - x^3/3 + 2Dx^4/3) 0522 + iy [ (1-2Dx) + 2/3 y^2 (1 - 3Dx - x^2 + 2Dx^3) 0523 + y^4/15 (4 - 15Dx - 9x^2 + 20Dx^3 + 2x^4 - 4Dx^5) ] + ... 0524 where D = dawson(x) 0525 0526 However, for large |x|, 2Dx -> 1 which gives cancellation problems in 0527 this series (many of the leading terms cancel). So, for large |x|, 0528 we need to substitute a continued-fraction expansion for D. 0529 0530 dawson(x) = 0.5 / (x-0.5/(x-1/(x-1.5/(x-2/(x-2.5/(x...)))))) 0531 0532 The 6 terms shown here seems to be the minimum needed to be 0533 accurate as soon as the simpler Taylor expansion above starts 0534 breaking down. Using this 6-term expansion, factoring out the 0535 denominator, and simplifying with Maple, we obtain: 0536 0537 Re dawson(x + iy) * (-15 + 90x^2 - 60x^4 + 8x^6) / x 0538 = 33 - 28x^2 + 4x^4 + y^2 (18 - 4x^2) + 4 y^4 0539 Im dawson(x + iy) * (-15 + 90x^2 - 60x^4 + 8x^6) / y 0540 = -15 + 24x^2 - 4x^4 + 2/3 y^2 (6x^2 - 15) - 4 y^4 0541 0542 Finally, for |x| > 5e7, we can use a simpler 1-term continued-fraction 0543 expansion for the real part, and a 2-term expansion for the imaginary 0544 part. (This avoids overflow problems for huge |x|.) This yields: 0545 0546 Re dawson(x + iy) = [1 + y^2 (1 + y^2/2 - (xy)^2/3)] / (2x) 0547 Im dawson(x + iy) = y [ -1 - 2/3 y^2 + y^4/15 (2x^2 - 4) ] / (2x^2 - 1) 0548 0549 */ 0550 taylor_realaxis: 0551 { 0552 double x2 = x*x; 0553 if (x2 > 1600) { // |x| > 40 0554 double y2 = y*y; 0555 if (x2 > 25e14) {// |x| > 5e7 0556 double xy2 = (x*y)*(x*y); 0557 return C((0.5 + y2 * (0.5 + 0.25*y2 0558 - 0.16666666666666666667*xy2)) / x, 0559 y * (-1 + y2 * (-0.66666666666666666667 0560 + 0.13333333333333333333*xy2 0561 - 0.26666666666666666667*y2)) 0562 / (2*x2 - 1)); 0563 } 0564 return (1. / (-15 + x2*(90 + x2*(-60 + 8*x2)))) * 0565 C(x * (33 + x2 * (-28 + 4*x2) 0566 + y2 * (18 - 4*x2 + 4*y2)), 0567 y * (-15 + x2 * (24 - 4*x2) 0568 + y2 * (4*x2 - 10 - 4*y2))); 0569 } 0570 else { 0571 double D = spi2 * FADDEEVA(w_im)(x); 0572 double y2 = y*y; 0573 return C 0574 (D + y2 * (D + x - 2*D*x2) 0575 + y2*y2 * (D * (0.5 - x2 * (2 - 0.66666666666666666667*x2)) 0576 + x * (0.83333333333333333333 0577 - 0.33333333333333333333 * x2)), 0578 y * (1 - 2*D*x 0579 + y2 * 0.66666666666666666667 * (1 - x2 - D*x * (3 - 2*x2)) 0580 + y2*y2 * (0.26666666666666666667 - 0581 x2 * (0.6 - 0.13333333333333333333 * x2) 0582 - D*x * (1 - x2 * (1.3333333333333333333 0583 - 0.26666666666666666667 * x2))))); 0584 } 0585 } 0586 } 0587 0588 ///////////////////////////////////////////////////////////////////////// 0589 0590 // return sinc(x) = sin(x)/x, given both x and sin(x) 0591 // [since we only use this in cases where sin(x) has already been computed] 0592 static inline double sinc(double x, double sinx) { 0593 return fabs(x) < 1e-4 ? 1 - (0.1666666666666666666667)*x*x : sinx / x; 0594 } 0595 0596 // sinh(x) via Taylor series, accurate to machine precision for |x| < 1e-2 0597 static inline double sinh_taylor(double x) { 0598 return x * (1 + (x*x) * (0.1666666666666666666667 0599 + 0.00833333333333333333333 * (x*x))); 0600 } 0601 0602 static inline double sqr(double x) { return x*x; } 0603 0604 // precomputed table of expa2n2[n-1] = exp(-a2*n*n) 0605 // for double-precision a2 = 0.26865... in FADDEEVA(w), below. 0606 const int expa2n2_size=52; 0607 static const double expa2n2[] = { 0608 7.64405281671221563e-01, 0609 3.41424527166548425e-01, 0610 8.91072646929412548e-02, 0611 1.35887299055460086e-02, 0612 1.21085455253437481e-03, 0613 6.30452613933449404e-05, 0614 1.91805156577114683e-06, 0615 3.40969447714832381e-08, 0616 3.54175089099469393e-10, 0617 2.14965079583260682e-12, 0618 7.62368911833724354e-15, 0619 1.57982797110681093e-17, 0620 1.91294189103582677e-20, 0621 1.35344656764205340e-23, 0622 5.59535712428588720e-27, 0623 1.35164257972401769e-30, 0624 1.90784582843501167e-34, 0625 1.57351920291442930e-38, 0626 7.58312432328032845e-43, 0627 2.13536275438697082e-47, 0628 3.51352063787195769e-52, 0629 3.37800830266396920e-57, 0630 1.89769439468301000e-62, 0631 6.22929926072668851e-68, 0632 1.19481172006938722e-73, 0633 1.33908181133005953e-79, 0634 8.76924303483223939e-86, 0635 3.35555576166254986e-92, 0636 7.50264110688173024e-99, 0637 9.80192200745410268e-106, 0638 7.48265412822268959e-113, 0639 3.33770122566809425e-120, 0640 8.69934598159861140e-128, 0641 1.32486951484088852e-135, 0642 1.17898144201315253e-143, 0643 6.13039120236180012e-152, 0644 1.86258785950822098e-160, 0645 3.30668408201432783e-169, 0646 3.43017280887946235e-178, 0647 2.07915397775808219e-187, 0648 7.36384545323984966e-197, 0649 1.52394760394085741e-206, 0650 1.84281935046532100e-216, 0651 1.30209553802992923e-226, 0652 5.37588903521080531e-237, 0653 1.29689584599763145e-247, 0654 1.82813078022866562e-258, 0655 1.50576355348684241e-269, 0656 7.24692320799294194e-281, 0657 2.03797051314726829e-292, 0658 3.34880215927873807e-304, 0659 0.0 // underflow (also prevents reads past array end, below) 0660 }; 0661 0662 ///////////////////////////////////////////////////////////////////////// 0663 0664 cmplx FADDEEVA(w)(cmplx z, double relerr) 0665 { 0666 if (creal(z) == 0.0) 0667 return C(FADDEEVA_RE(erfcx)(cimag(z)), 0668 creal(z)); // give correct sign of 0 in cimag(w) 0669 else if (cimag(z) == 0) 0670 return C(exp(-sqr(creal(z))), 0671 FADDEEVA(w_im)(creal(z))); 0672 0673 double a, a2, c; 0674 if (relerr <= DBL_EPSILON) { 0675 relerr = DBL_EPSILON; 0676 a = 0.518321480430085929872; // pi / sqrt(-log(eps*0.5)) 0677 c = 0.329973702884629072537; // (2/pi) * a; 0678 a2 = 0.268657157075235951582; // a^2 0679 } 0680 else { 0681 const double pi = 3.14159265358979323846264338327950288419716939937510582; 0682 if (relerr > 0.1) relerr = 0.1; // not sensible to compute < 1 digit 0683 a = pi / sqrt(-log(relerr*0.5)); 0684 c = (2/pi)*a; 0685 a2 = a*a; 0686 } 0687 const double x = fabs(creal(z)); 0688 const double y = cimag(z), ya = fabs(y); 0689 0690 cmplx ret = 0.; // return value 0691 0692 double sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0, sum5 = 0; 0693 0694 #define USE_CONTINUED_FRACTION 1 // 1 to use continued fraction for large |z| 0695 0696 #if USE_CONTINUED_FRACTION 0697 if (ya > 7 || (x > 6 // continued fraction is faster 0698 /* As pointed out by M. Zaghloul, the continued 0699 fraction seems to give a large relative error in 0700 Re w(z) for |x| ~ 6 and small |y|, so use 0701 algorithm 816 in this region: */ 0702 && (ya > 0.1 || (x > 8 && ya > 1e-10) || x > 28))) { 0703 0704 /* Poppe & Wijers suggest using a number of terms 0705 nu = 3 + 1442 / (26*rho + 77) 0706 where rho = sqrt((x/x0)^2 + (y/y0)^2) where x0=6.3, y0=4.4. 0707 (They only use this expansion for rho >= 1, but rho a little less 0708 than 1 seems okay too.) 0709 Instead, I did my own fit to a slightly different function 0710 that avoids the hypotenuse calculation, using NLopt to minimize 0711 the sum of the squares of the errors in nu with the constraint 0712 that the estimated nu be >= minimum nu to attain machine precision. 0713 I also separate the regions where nu == 2 and nu == 1. */ 0714 const double ispi = 0.56418958354775628694807945156; // 1 / sqrt(pi) 0715 double xs = y < 0 ? -creal(z) : creal(z); // compute for -z if y < 0 0716 if (x + ya > 4000) { // nu <= 2 0717 if (x + ya > 1e7) { // nu == 1, w(z) = i/sqrt(pi) / z 0718 // scale to avoid overflow 0719 if (x > ya) { 0720 double yax = ya / xs; 0721 double denom = ispi / (xs + yax*ya); 0722 ret = C(denom*yax, denom); 0723 } 0724 else if (isinf(ya)) 0725 return ((isnan(x) || y < 0) 0726 ? C(NaN,NaN) : C(0,0)); 0727 else { 0728 double xya = xs / ya; 0729 double denom = ispi / (xya*xs + ya); 0730 ret = C(denom, denom*xya); 0731 } 0732 } 0733 else { // nu == 2, w(z) = i/sqrt(pi) * z / (z*z - 0.5) 0734 double dr = xs*xs - ya*ya - 0.5, di = 2*xs*ya; 0735 double denom = ispi / (dr*dr + di*di); 0736 ret = C(denom * (xs*di-ya*dr), denom * (xs*dr+ya*di)); 0737 } 0738 } 0739 else { // compute nu(z) estimate and do general continued fraction 0740 const double c0=3.9, c1=11.398, c2=0.08254, c3=0.1421, c4=0.2023; // fit 0741 double nu = floor(c0 + c1 / (c2*x + c3*ya + c4)); 0742 double wr = xs, wi = ya; 0743 for (nu = 0.5 * (nu - 1); nu > 0.4; nu -= 0.5) { 0744 // w <- z - nu/w: 0745 double denom = nu / (wr*wr + wi*wi); 0746 wr = xs - wr * denom; 0747 wi = ya + wi * denom; 0748 } 0749 { // w(z) = i/sqrt(pi) / w: 0750 double denom = ispi / (wr*wr + wi*wi); 0751 ret = C(denom*wi, denom*wr); 0752 } 0753 } 0754 if (y < 0) { 0755 // use w(z) = 2.0*exp(-z*z) - w(-z), 0756 // but be careful of overflow in exp(-z*z) 0757 // = exp(-(xs*xs-ya*ya) -2*i*xs*ya) 0758 return 2.0*cexp(C((ya-xs)*(xs+ya), 2*xs*y)) - ret; 0759 } 0760 else 0761 return ret; 0762 } 0763 #else // !USE_CONTINUED_FRACTION 0764 if (x + ya > 1e7) { // w(z) = i/sqrt(pi) / z, to machine precision 0765 const double ispi = 0.56418958354775628694807945156; // 1 / sqrt(pi) 0766 double xs = y < 0 ? -creal(z) : creal(z); // compute for -z if y < 0 0767 // scale to avoid overflow 0768 if (x > ya) { 0769 double yax = ya / xs; 0770 double denom = ispi / (xs + yax*ya); 0771 ret = C(denom*yax, denom); 0772 } 0773 else { 0774 double xya = xs / ya; 0775 double denom = ispi / (xya*xs + ya); 0776 ret = C(denom, denom*xya); 0777 } 0778 if (y < 0) { 0779 // use w(z) = 2.0*exp(-z*z) - w(-z), 0780 // but be careful of overflow in exp(-z*z) 0781 // = exp(-(xs*xs-ya*ya) -2*i*xs*ya) 0782 return 2.0*cexp(C((ya-xs)*(xs+ya), 2*xs*y)) - ret; 0783 } 0784 else 0785 return ret; 0786 } 0787 #endif // !USE_CONTINUED_FRACTION 0788 0789 /* Note: The test that seems to be suggested in the paper is x < 0790 sqrt(-log(DBL_MIN)), about 26.6, since otherwise exp(-x^2) 0791 underflows to zero and sum1,sum2,sum4 are zero. However, long 0792 before this occurs, the sum1,sum2,sum4 contributions are 0793 negligible in double precision; I find that this happens for x > 0794 about 6, for all y. On the other hand, I find that the case 0795 where we compute all of the sums is faster (at least with the 0796 precomputed expa2n2 table) until about x=10. Furthermore, if we 0797 try to compute all of the sums for x > 20, I find that we 0798 sometimes run into numerical problems because underflow/overflow 0799 problems start to appear in the various coefficients of the sums, 0800 below. Therefore, we use x < 10 here. */ 0801 else if (x < 10) { 0802 double prod2ax = 1, prodm2ax = 1; 0803 double expx2; 0804 0805 if (isnan(y)) 0806 return C(y,y); 0807 0808 /* Somewhat ugly copy-and-paste duplication here, but I see significant 0809 speedups from using the special-case code with the precomputed 0810 exponential, and the x < 5e-4 special case is needed for accuracy. */ 0811 0812 if (relerr == DBL_EPSILON) { // use precomputed exp(-a2*(n*n)) table 0813 if (x < 5e-4) { // compute sum4 and sum5 together as sum5-sum4 0814 const double x2 = x*x; 0815 expx2 = 1 - x2 * (1 - 0.5*x2); // exp(-x*x) via Taylor 0816 // compute exp(2*a*x) and exp(-2*a*x) via Taylor, to double precision 0817 const double ax2 = 1.036642960860171859744*x; // 2*a*x 0818 const double exp2ax = 0819 1 + ax2 * (1 + ax2 * (0.5 + 0.166666666666666666667*ax2)); 0820 const double expm2ax = 0821 1 - ax2 * (1 - ax2 * (0.5 - 0.166666666666666666667*ax2)); 0822 for (int n = 1; n <= expa2n2_size; ++n) { 0823 const double coef = expa2n2[n-1] * expx2 / (a2*(n*n) + y*y); 0824 prod2ax *= exp2ax; 0825 prodm2ax *= expm2ax; 0826 sum1 += coef; 0827 sum2 += coef * prodm2ax; 0828 sum3 += coef * prod2ax; 0829 0830 // really = sum5 - sum4 0831 sum5 += coef * (2*a) * n * sinh_taylor((2*a)*n*x); 0832 0833 // test convergence via sum3 0834 if (coef * prod2ax < relerr * sum3) break; 0835 } 0836 } 0837 else { // x > 5e-4, compute sum4 and sum5 separately 0838 expx2 = exp(-x*x); 0839 const double exp2ax = exp((2*a)*x), expm2ax = 1 / exp2ax; 0840 for (int n = 1; n <= expa2n2_size; ++n) { 0841 const double coef = expa2n2[n-1] * expx2 / (a2*(n*n) + y*y); 0842 prod2ax *= exp2ax; 0843 prodm2ax *= expm2ax; 0844 sum1 += coef; 0845 sum2 += coef * prodm2ax; 0846 sum4 += (coef * prodm2ax) * (a*n); 0847 sum3 += coef * prod2ax; 0848 sum5 += (coef * prod2ax) * (a*n); 0849 // test convergence via sum5, since this sum has the slowest decay 0850 if ((coef * prod2ax) * (a*n) < relerr * sum5) break; 0851 } 0852 } 0853 } 0854 else { // relerr != DBL_EPSILON, compute exp(-a2*(n*n)) on the fly 0855 const double exp2ax = exp((2*a)*x), expm2ax = 1 / exp2ax; 0856 if (x < 5e-4) { // compute sum4 and sum5 together as sum5-sum4 0857 const double x2 = x*x; 0858 expx2 = 1 - x2 * (1 - 0.5*x2); // exp(-x*x) via Taylor 0859 for (int n = 1; 1; ++n) { 0860 const double coef = exp(-a2*(n*n)) * expx2 / (a2*(n*n) + y*y); 0861 prod2ax *= exp2ax; 0862 prodm2ax *= expm2ax; 0863 sum1 += coef; 0864 sum2 += coef * prodm2ax; 0865 sum3 += coef * prod2ax; 0866 0867 // really = sum5 - sum4 0868 sum5 += coef * (2*a) * n * sinh_taylor((2*a)*n*x); 0869 0870 // test convergence via sum3 0871 if (coef * prod2ax < relerr * sum3) break; 0872 } 0873 } 0874 else { // x > 5e-4, compute sum4 and sum5 separately 0875 expx2 = exp(-x*x); 0876 for (int n = 1; 1; ++n) { 0877 const double coef = exp(-a2*(n*n)) * expx2 / (a2*(n*n) + y*y); 0878 prod2ax *= exp2ax; 0879 prodm2ax *= expm2ax; 0880 sum1 += coef; 0881 sum2 += coef * prodm2ax; 0882 sum4 += (coef * prodm2ax) * (a*n); 0883 sum3 += coef * prod2ax; 0884 sum5 += (coef * prod2ax) * (a*n); 0885 // test convergence via sum5, since this sum has the slowest decay 0886 if ((coef * prod2ax) * (a*n) < relerr * sum5) break; 0887 } 0888 } 0889 } 0890 const double expx2erfcxy = // avoid spurious overflow for large negative y 0891 y > -6 // for y < -6, erfcx(y) = 2*exp(y*y) to double precision 0892 ? expx2*FADDEEVA_RE(erfcx)(y) : 2*exp(y*y-x*x); 0893 if (y > 5) { // imaginary terms cancel 0894 const double sinxy = sin(x*y); 0895 ret = (expx2erfcxy - c*y*sum1) * cos(2*x*y) 0896 + (c*x*expx2) * sinxy * sinc(x*y, sinxy); 0897 } 0898 else { 0899 double xs = creal(z); 0900 const double sinxy = sin(xs*y); 0901 const double sin2xy = sin(2*xs*y), cos2xy = cos(2*xs*y); 0902 const double coef1 = expx2erfcxy - c*y*sum1; 0903 const double coef2 = c*xs*expx2; 0904 ret = C(coef1 * cos2xy + coef2 * sinxy * sinc(xs*y, sinxy), 0905 coef2 * sinc(2*xs*y, sin2xy) - coef1 * sin2xy); 0906 } 0907 } 0908 else { // x large: only sum3 & sum5 contribute (see above note) 0909 if (isnan(x)) 0910 return C(x,x); 0911 if (isnan(y)) 0912 return C(y,y); 0913 0914 #if USE_CONTINUED_FRACTION 0915 ret = exp(-x*x); // |y| < 1e-10, so we only need exp(-x*x) term 0916 #else 0917 if (y < 0) { 0918 /* erfcx(y) ~ 2*exp(y*y) + (< 1) if y < 0, so 0919 erfcx(y)*exp(-x*x) ~ 2*exp(y*y-x*x) term may not be negligible 0920 if y*y - x*x > -36 or so. So, compute this term just in case. 0921 We also need the -exp(-x*x) term to compute Re[w] accurately 0922 in the case where y is very small. */ 0923 ret = cpolar(2*exp(y*y-x*x) - exp(-x*x), -2*creal(z)*y); 0924 } 0925 else 0926 ret = exp(-x*x); // not negligible in real part if y very small 0927 #endif 0928 // (round instead of ceil as in original paper; note that x/a > 1 here) 0929 double n0 = floor(x/a + 0.5); // sum in both directions, starting at n0 0930 double dx = a*n0 - x; 0931 sum3 = exp(-dx*dx) / (a2*(n0*n0) + y*y); 0932 sum5 = a*n0 * sum3; 0933 double exp1 = exp(4*a*dx), exp1dn = 1; 0934 int dn; 0935 for (dn = 1; n0 - dn > 0; ++dn) { // loop over n0-dn and n0+dn terms 0936 double np = n0 + dn, nm = n0 - dn; 0937 double tp = exp(-sqr(a*dn+dx)); 0938 double tm = tp * (exp1dn *= exp1); // trick to get tm from tp 0939 tp /= (a2*(np*np) + y*y); 0940 tm /= (a2*(nm*nm) + y*y); 0941 sum3 += tp + tm; 0942 sum5 += a * (np * tp + nm * tm); 0943 if (a * (np * tp + nm * tm) < relerr * sum5) goto finish; 0944 } 0945 while (1) { // loop over n0+dn terms only (since n0-dn <= 0) 0946 double np = n0 + dn++; 0947 double tp = exp(-sqr(a*dn+dx)) / (a2*(np*np) + y*y); 0948 sum3 += tp; 0949 sum5 += a * np * tp; 0950 if (a * np * tp < relerr * sum5) goto finish; 0951 } 0952 } 0953 finish: 0954 return ret + C((0.5*c)*y*(sum2+sum3), 0955 (0.5*c)*copysign(sum5-sum4, creal(z))); 0956 } 0957 0958 ///////////////////////////////////////////////////////////////////////// 0959 0960 /* erfcx(x) = exp(x^2) erfc(x) function, for real x, written by 0961 Steven G. Johnson, October 2012. 0962 0963 This function combines a few different ideas. 0964 0965 First, for x > 50, it uses a continued-fraction expansion (same as 0966 for the Faddeeva function, but with algebraic simplifications for z=i*x). 0967 0968 Second, for 0 <= x <= 50, it uses Chebyshev polynomial approximations, 0969 but with two twists: 0970 0971 a) It maps x to y = 4 / (4+x) in [0,1]. This simple transformation, 0972 inspired by a similar transformation in the octave-forge/specfun 0973 erfcx by Soren Hauberg, results in much faster Chebyshev convergence 0974 than other simple transformations I have examined. 0975 0976 b) Instead of using a single Chebyshev polynomial for the entire 0977 [0,1] y interval, we break the interval up into 100 equal 0978 subintervals, with a switch/lookup table, and use much lower 0979 degree Chebyshev polynomials in each subinterval. This greatly 0980 improves performance in my tests. 0981 0982 For x < 0, we use the relationship erfcx(-x) = 2 exp(x^2) - erfc(x), 0983 with the usual checks for overflow etcetera. 0984 0985 Performance-wise, it seems to be substantially faster than either 0986 the SLATEC DERFC function [or an erfcx function derived therefrom] 0987 or Cody's CALERF function (from netlib.org/specfun), while 0988 retaining near machine precision in accuracy. */ 0989 0990 /* Given y100=100*y, where y = 4/(4+x) for x >= 0, compute erfc(x). 0991 0992 Uses a look-up table of 100 different Chebyshev polynomials 0993 for y intervals [0,0.01], [0.01,0.02], ...., [0.99,1], generated 0994 with the help of Maple and a little shell script. This allows 0995 the Chebyshev polynomials to be of significantly lower degree (about 1/4) 0996 compared to fitting the whole [0,1] interval with a single polynomial. */ 0997 static double erfcx_y100(double y100) 0998 { 0999 switch ((int) y100) { 1000 case 0: { 1001 double t = 2*y100 - 1; 1002 return 0.70878032454106438663e-3 + (0.71234091047026302958e-3 + (0.35779077297597742384e-5 + (0.17403143962587937815e-7 + (0.81710660047307788845e-10 + (0.36885022360434957634e-12 + 0.15917038551111111111e-14 * t) * t) * t) * t) * t) * t; 1003 } 1004 case 1: { 1005 double t = 2*y100 - 3; 1006 return 0.21479143208285144230e-2 + (0.72686402367379996033e-3 + (0.36843175430938995552e-5 + (0.18071841272149201685e-7 + (0.85496449296040325555e-10 + (0.38852037518534291510e-12 + 0.16868473576888888889e-14 * t) * t) * t) * t) * t) * t; 1007 } 1008 case 2: { 1009 double t = 2*y100 - 5; 1010 return 0.36165255935630175090e-2 + (0.74182092323555510862e-3 + (0.37948319957528242260e-5 + (0.18771627021793087350e-7 + (0.89484715122415089123e-10 + (0.40935858517772440862e-12 + 0.17872061464888888889e-14 * t) * t) * t) * t) * t) * t; 1011 } 1012 case 3: { 1013 double t = 2*y100 - 7; 1014 return 0.51154983860031979264e-2 + (0.75722840734791660540e-3 + (0.39096425726735703941e-5 + (0.19504168704300468210e-7 + (0.93687503063178993915e-10 + (0.43143925959079664747e-12 + 0.18939926435555555556e-14 * t) * t) * t) * t) * t) * t; 1015 } 1016 case 4: { 1017 double t = 2*y100 - 9; 1018 return 0.66457513172673049824e-2 + (0.77310406054447454920e-3 + (0.40289510589399439385e-5 + (0.20271233238288381092e-7 + (0.98117631321709100264e-10 + (0.45484207406017752971e-12 + 0.20076352213333333333e-14 * t) * t) * t) * t) * t) * t; 1019 } 1020 case 5: { 1021 double t = 2*y100 - 11; 1022 return 0.82082389970241207883e-2 + (0.78946629611881710721e-3 + (0.41529701552622656574e-5 + (0.21074693344544655714e-7 + (0.10278874108587317989e-9 + (0.47965201390613339638e-12 + 0.21285907413333333333e-14 * t) * t) * t) * t) * t) * t; 1023 } 1024 case 6: { 1025 double t = 2*y100 - 13; 1026 return 0.98039537275352193165e-2 + (0.80633440108342840956e-3 + (0.42819241329736982942e-5 + (0.21916534346907168612e-7 + (0.10771535136565470914e-9 + (0.50595972623692822410e-12 + 0.22573462684444444444e-14 * t) * t) * t) * t) * t) * t; 1027 } 1028 case 7: { 1029 double t = 2*y100 - 15; 1030 return 0.11433927298290302370e-1 + (0.82372858383196561209e-3 + (0.44160495311765438816e-5 + (0.22798861426211986056e-7 + (0.11291291745879239736e-9 + (0.53386189365816880454e-12 + 0.23944209546666666667e-14 * t) * t) * t) * t) * t) * t; 1031 } 1032 case 8: { 1033 double t = 2*y100 - 17; 1034 return 0.13099232878814653979e-1 + (0.84167002467906968214e-3 + (0.45555958988457506002e-5 + (0.23723907357214175198e-7 + (0.11839789326602695603e-9 + (0.56346163067550237877e-12 + 0.25403679644444444444e-14 * t) * t) * t) * t) * t) * t; 1035 } 1036 case 9: { 1037 double t = 2*y100 - 19; 1038 return 0.14800987015587535621e-1 + (0.86018092946345943214e-3 + (0.47008265848816866105e-5 + (0.24694040760197315333e-7 + (0.12418779768752299093e-9 + (0.59486890370320261949e-12 + 0.26957764568888888889e-14 * t) * t) * t) * t) * t) * t; 1039 } 1040 case 10: { 1041 double t = 2*y100 - 21; 1042 return 0.16540351739394069380e-1 + (0.87928458641241463952e-3 + (0.48520195793001753903e-5 + (0.25711774900881709176e-7 + (0.13030128534230822419e-9 + (0.62820097586874779402e-12 + 0.28612737351111111111e-14 * t) * t) * t) * t) * t) * t; 1043 } 1044 case 11: { 1045 double t = 2*y100 - 23; 1046 return 0.18318536789842392647e-1 + (0.89900542647891721692e-3 + (0.50094684089553365810e-5 + (0.26779777074218070482e-7 + (0.13675822186304615566e-9 + (0.66358287745352705725e-12 + 0.30375273884444444444e-14 * t) * t) * t) * t) * t) * t; 1047 } 1048 case 12: { 1049 double t = 2*y100 - 25; 1050 return 0.20136801964214276775e-1 + (0.91936908737673676012e-3 + (0.51734830914104276820e-5 + (0.27900878609710432673e-7 + (0.14357976402809042257e-9 + (0.70114790311043728387e-12 + 0.32252476000000000000e-14 * t) * t) * t) * t) * t) * t; 1051 } 1052 case 13: { 1053 double t = 2*y100 - 27; 1054 return 0.21996459598282740954e-1 + (0.94040248155366777784e-3 + (0.53443911508041164739e-5 + (0.29078085538049374673e-7 + (0.15078844500329731137e-9 + (0.74103813647499204269e-12 + 0.34251892320000000000e-14 * t) * t) * t) * t) * t) * t; 1055 } 1056 case 14: { 1057 double t = 2*y100 - 29; 1058 return 0.23898877187226319502e-1 + (0.96213386835900177540e-3 + (0.55225386998049012752e-5 + (0.30314589961047687059e-7 + (0.15840826497296335264e-9 + (0.78340500472414454395e-12 + 0.36381553564444444445e-14 * t) * t) * t) * t) * t) * t; 1059 } 1060 case 15: { 1061 double t = 2*y100 - 31; 1062 return 0.25845480155298518485e-1 + (0.98459293067820123389e-3 + (0.57082915920051843672e-5 + (0.31613782169164830118e-7 + (0.16646478745529630813e-9 + (0.82840985928785407942e-12 + 0.38649975768888888890e-14 * t) * t) * t) * t) * t) * t; 1063 } 1064 case 16: { 1065 double t = 2*y100 - 33; 1066 return 0.27837754783474696598e-1 + (0.10078108563256892757e-2 + (0.59020366493792212221e-5 + (0.32979263553246520417e-7 + (0.17498524159268458073e-9 + (0.87622459124842525110e-12 + 0.41066206488888888890e-14 * t) * t) * t) * t) * t) * t; 1067 } 1068 case 17: { 1069 double t = 2*y100 - 35; 1070 return 0.29877251304899307550e-1 + (0.10318204245057349310e-2 + (0.61041829697162055093e-5 + (0.34414860359542720579e-7 + (0.18399863072934089607e-9 + (0.92703227366365046533e-12 + 0.43639844053333333334e-14 * t) * t) * t) * t) * t) * t; 1071 } 1072 case 18: { 1073 double t = 2*y100 - 37; 1074 return 0.31965587178596443475e-1 + (0.10566560976716574401e-2 + (0.63151633192414586770e-5 + (0.35924638339521924242e-7 + (0.19353584758781174038e-9 + (0.98102783859889264382e-12 + 0.46381060817777777779e-14 * t) * t) * t) * t) * t) * t; 1075 } 1076 case 19: { 1077 double t = 2*y100 - 39; 1078 return 0.34104450552588334840e-1 + (0.10823541191350532574e-2 + (0.65354356159553934436e-5 + (0.37512918348533521149e-7 + (0.20362979635817883229e-9 + (0.10384187833037282363e-11 + 0.49300625262222222221e-14 * t) * t) * t) * t) * t) * t; 1079 } 1080 case 20: { 1081 double t = 2*y100 - 41; 1082 return 0.36295603928292425716e-1 + (0.11089526167995268200e-2 + (0.67654845095518363577e-5 + (0.39184292949913591646e-7 + (0.21431552202133775150e-9 + (0.10994259106646731797e-11 + 0.52409949102222222221e-14 * t) * t) * t) * t) * t) * t; 1083 } 1084 case 21: { 1085 double t = 2*y100 - 43; 1086 return 0.38540888038840509795e-1 + (0.11364917134175420009e-2 + (0.70058230641246312003e-5 + (0.40943644083718586939e-7 + (0.22563034723692881631e-9 + (0.11642841011361992885e-11 + 0.55721092871111111110e-14 * t) * t) * t) * t) * t) * t; 1087 } 1088 case 22: { 1089 double t = 2*y100 - 45; 1090 return 0.40842225954785960651e-1 + (0.11650136437945673891e-2 + (0.72569945502343006619e-5 + (0.42796161861855042273e-7 + (0.23761401711005024162e-9 + (0.12332431172381557035e-11 + 0.59246802364444444445e-14 * t) * t) * t) * t) * t) * t; 1091 } 1092 case 23: { 1093 double t = 2*y100 - 47; 1094 return 0.43201627431540222422e-1 + (0.11945628793917272199e-2 + (0.75195743532849206263e-5 + (0.44747364553960993492e-7 + (0.25030885216472953674e-9 + (0.13065684400300476484e-11 + 0.63000532853333333334e-14 * t) * t) * t) * t) * t) * t; 1095 } 1096 case 24: { 1097 double t = 2*y100 - 49; 1098 return 0.45621193513810471438e-1 + (0.12251862608067529503e-2 + (0.77941720055551920319e-5 + (0.46803119830954460212e-7 + (0.26375990983978426273e-9 + (0.13845421370977119765e-11 + 0.66996477404444444445e-14 * t) * t) * t) * t) * t) * t; 1099 } 1100 case 25: { 1101 double t = 2*y100 - 51; 1102 return 0.48103121413299865517e-1 + (0.12569331386432195113e-2 + (0.80814333496367673980e-5 + (0.48969667335682018324e-7 + (0.27801515481905748484e-9 + (0.14674637611609884208e-11 + 0.71249589351111111110e-14 * t) * t) * t) * t) * t) * t; 1103 } 1104 case 26: { 1105 double t = 2*y100 - 53; 1106 return 0.50649709676983338501e-1 + (0.12898555233099055810e-2 + (0.83820428414568799654e-5 + (0.51253642652551838659e-7 + (0.29312563849675507232e-9 + (0.15556512782814827846e-11 + 0.75775607822222222221e-14 * t) * t) * t) * t) * t) * t; 1107 } 1108 case 27: { 1109 double t = 2*y100 - 55; 1110 return 0.53263363664388864181e-1 + (0.13240082443256975769e-2 + (0.86967260015007658418e-5 + (0.53662102750396795566e-7 + (0.30914568786634796807e-9 + (0.16494420240828493176e-11 + 0.80591079644444444445e-14 * t) * t) * t) * t) * t) * t; 1111 } 1112 case 28: { 1113 double t = 2*y100 - 57; 1114 return 0.55946601353500013794e-1 + (0.13594491197408190706e-2 + (0.90262520233016380987e-5 + (0.56202552975056695376e-7 + (0.32613310410503135996e-9 + (0.17491936862246367398e-11 + 0.85713381688888888890e-14 * t) * t) * t) * t) * t) * t; 1115 } 1116 case 29: { 1117 double t = 2*y100 - 59; 1118 return 0.58702059496154081813e-1 + (0.13962391363223647892e-2 + (0.93714365487312784270e-5 + (0.58882975670265286526e-7 + (0.34414937110591753387e-9 + (0.18552853109751857859e-11 + 0.91160736711111111110e-14 * t) * t) * t) * t) * t) * t; 1119 } 1120 case 30: { 1121 double t = 2*y100 - 61; 1122 return 0.61532500145144778048e-1 + (0.14344426411912015247e-2 + (0.97331446201016809696e-5 + (0.61711860507347175097e-7 + (0.36325987418295300221e-9 + (0.19681183310134518232e-11 + 0.96952238400000000000e-14 * t) * t) * t) * t) * t) * t; 1123 } 1124 case 31: { 1125 double t = 2*y100 - 63; 1126 return 0.64440817576653297993e-1 + (0.14741275456383131151e-2 + (0.10112293819576437838e-4 + (0.64698236605933246196e-7 + (0.38353412915303665586e-9 + (0.20881176114385120186e-11 + 0.10310784480000000000e-13 * t) * t) * t) * t) * t) * t; 1127 } 1128 case 32: { 1129 double t = 2*y100 - 65; 1130 return 0.67430045633130393282e-1 + (0.15153655418916540370e-2 + (0.10509857606888328667e-4 + (0.67851706529363332855e-7 + (0.40504602194811140006e-9 + (0.22157325110542534469e-11 + 0.10964842115555555556e-13 * t) * t) * t) * t) * t) * t; 1131 } 1132 case 33: { 1133 double t = 2*y100 - 67; 1134 return 0.70503365513338850709e-1 + (0.15582323336495709827e-2 + (0.10926868866865231089e-4 + (0.71182482239613507542e-7 + (0.42787405890153386710e-9 + (0.23514379522274416437e-11 + 0.11659571751111111111e-13 * t) * t) * t) * t) * t) * t; 1135 } 1136 case 34: { 1137 double t = 2*y100 - 69; 1138 return 0.73664114037944596353e-1 + (0.16028078812438820413e-2 + (0.11364423678778207991e-4 + (0.74701423097423182009e-7 + (0.45210162777476488324e-9 + (0.24957355004088569134e-11 + 0.12397238257777777778e-13 * t) * t) * t) * t) * t) * t; 1139 } 1140 case 35: { 1141 double t = 2*y100 - 71; 1142 return 0.76915792420819562379e-1 + (0.16491766623447889354e-2 + (0.11823685320041302169e-4 + (0.78420075993781544386e-7 + (0.47781726956916478925e-9 + (0.26491544403815724749e-11 + 0.13180196462222222222e-13 * t) * t) * t) * t) * t) * t; 1143 } 1144 case 36: { 1145 double t = 2*y100 - 73; 1146 return 0.80262075578094612819e-1 + (0.16974279491709504117e-2 + (0.12305888517309891674e-4 + (0.82350717698979042290e-7 + (0.50511496109857113929e-9 + (0.28122528497626897696e-11 + 0.14010889635555555556e-13 * t) * t) * t) * t) * t) * t; 1147 } 1148 case 37: { 1149 double t = 2*y100 - 75; 1150 return 0.83706822008980357446e-1 + (0.17476561032212656962e-2 + (0.12812343958540763368e-4 + (0.86506399515036435592e-7 + (0.53409440823869467453e-9 + (0.29856186620887555043e-11 + 0.14891851591111111111e-13 * t) * t) * t) * t) * t) * t; 1151 } 1152 case 38: { 1153 double t = 2*y100 - 77; 1154 return 0.87254084284461718231e-1 + (0.17999608886001962327e-2 + (0.13344443080089492218e-4 + (0.90900994316429008631e-7 + (0.56486134972616465316e-9 + (0.31698707080033956934e-11 + 0.15825697795555555556e-13 * t) * t) * t) * t) * t) * t; 1155 } 1156 case 39: { 1157 double t = 2*y100 - 79; 1158 return 0.90908120182172748487e-1 + (0.18544478050657699758e-2 + (0.13903663143426120077e-4 + (0.95549246062549906177e-7 + (0.59752787125242054315e-9 + (0.33656597366099099413e-11 + 0.16815130613333333333e-13 * t) * t) * t) * t) * t) * t; 1159 } 1160 case 40: { 1161 double t = 2*y100 - 81; 1162 return 0.94673404508075481121e-1 + (0.19112284419887303347e-2 + (0.14491572616545004930e-4 + (0.10046682186333613697e-6 + (0.63221272959791000515e-9 + (0.35736693975589130818e-11 + 0.17862931591111111111e-13 * t) * t) * t) * t) * t) * t; 1163 } 1164 case 41: { 1165 double t = 2*y100 - 83; 1166 return 0.98554641648004456555e-1 + (0.19704208544725622126e-2 + (0.15109836875625443935e-4 + (0.10567036667675984067e-6 + (0.66904168640019354565e-9 + (0.37946171850824333014e-11 + 0.18971959040000000000e-13 * t) * t) * t) * t) * t) * t; 1167 } 1168 case 42: { 1169 double t = 2*y100 - 85; 1170 return 0.10255677889470089531e0 + (0.20321499629472857418e-2 + (0.15760224242962179564e-4 + (0.11117756071353507391e-6 + (0.70814785110097658502e-9 + (0.40292553276632563925e-11 + 0.20145143075555555556e-13 * t) * t) * t) * t) * t) * t; 1171 } 1172 case 43: { 1173 double t = 2*y100 - 87; 1174 return 0.10668502059865093318e0 + (0.20965479776148731610e-2 + (0.16444612377624983565e-4 + (0.11700717962026152749e-6 + (0.74967203250938418991e-9 + (0.42783716186085922176e-11 + 0.21385479360000000000e-13 * t) * t) * t) * t) * t) * t; 1175 } 1176 case 44: { 1177 double t = 2*y100 - 89; 1178 return 0.11094484319386444474e0 + (0.21637548491908170841e-2 + (0.17164995035719657111e-4 + (0.12317915750735938089e-6 + (0.79376309831499633734e-9 + (0.45427901763106353914e-11 + 0.22696025653333333333e-13 * t) * t) * t) * t) * t) * t; 1179 } 1180 case 45: { 1181 double t = 2*y100 - 91; 1182 return 0.11534201115268804714e0 + (0.22339187474546420375e-2 + (0.17923489217504226813e-4 + (0.12971465288245997681e-6 + (0.84057834180389073587e-9 + (0.48233721206418027227e-11 + 0.24079890062222222222e-13 * t) * t) * t) * t) * t) * t; 1183 } 1184 case 46: { 1185 double t = 2*y100 - 93; 1186 return 0.11988259392684094740e0 + (0.23071965691918689601e-2 + (0.18722342718958935446e-4 + (0.13663611754337957520e-6 + (0.89028385488493287005e-9 + (0.51210161569225846701e-11 + 0.25540227111111111111e-13 * t) * t) * t) * t) * t) * t; 1187 } 1188 case 47: { 1189 double t = 2*y100 - 95; 1190 return 0.12457298393509812907e0 + (0.23837544771809575380e-2 + (0.19563942105711612475e-4 + (0.14396736847739470782e-6 + (0.94305490646459247016e-9 + (0.54366590583134218096e-11 + 0.27080225920000000000e-13 * t) * t) * t) * t) * t) * t; 1191 } 1192 case 48: { 1193 double t = 2*y100 - 97; 1194 return 0.12941991566142438816e0 + (0.24637684719508859484e-2 + (0.20450821127475879816e-4 + (0.15173366280523906622e-6 + (0.99907632506389027739e-9 + (0.57712760311351625221e-11 + 0.28703099555555555556e-13 * t) * t) * t) * t) * t) * t; 1195 } 1196 case 49: { 1197 double t = 2*y100 - 99; 1198 return 0.13443048593088696613e0 + (0.25474249981080823877e-2 + (0.21385669591362915223e-4 + (0.15996177579900443030e-6 + (0.10585428844575134013e-8 + (0.61258809536787882989e-11 + 0.30412080142222222222e-13 * t) * t) * t) * t) * t) * t; 1199 } 1200 case 50: { 1201 double t = 2*y100 - 101; 1202 return 0.13961217543434561353e0 + (0.26349215871051761416e-2 + (0.22371342712572567744e-4 + (0.16868008199296822247e-6 + (0.11216596910444996246e-8 + (0.65015264753090890662e-11 + 0.32210394506666666666e-13 * t) * t) * t) * t) * t) * t; 1203 } 1204 case 51: { 1205 double t = 2*y100 - 103; 1206 return 0.14497287157673800690e0 + (0.27264675383982439814e-2 + (0.23410870961050950197e-4 + (0.17791863939526376477e-6 + (0.11886425714330958106e-8 + (0.68993039665054288034e-11 + 0.34101266222222222221e-13 * t) * t) * t) * t) * t) * t; 1207 } 1208 case 52: { 1209 double t = 2*y100 - 105; 1210 return 0.15052089272774618151e0 + (0.28222846410136238008e-2 + (0.24507470422713397006e-4 + (0.18770927679626136909e-6 + (0.12597184587583370712e-8 + (0.73203433049229821618e-11 + 0.36087889048888888890e-13 * t) * t) * t) * t) * t) * t; 1211 } 1212 case 53: { 1213 double t = 2*y100 - 107; 1214 return 0.15626501395774612325e0 + (0.29226079376196624949e-2 + (0.25664553693768450545e-4 + (0.19808568415654461964e-6 + (0.13351257759815557897e-8 + (0.77658124891046760667e-11 + 0.38173420035555555555e-13 * t) * t) * t) * t) * t) * t; 1215 } 1216 case 54: { 1217 double t = 2*y100 - 109; 1218 return 0.16221449434620737567e0 + (0.30276865332726475672e-2 + (0.26885741326534564336e-4 + (0.20908350604346384143e-6 + (0.14151148144240728728e-8 + (0.82369170665974313027e-11 + 0.40360957457777777779e-13 * t) * t) * t) * t) * t) * t; 1219 } 1220 case 55: { 1221 double t = 2*y100 - 111; 1222 return 0.16837910595412130659e0 + (0.31377844510793082301e-2 + (0.28174873844911175026e-4 + (0.22074043807045782387e-6 + (0.14999481055996090039e-8 + (0.87348993661930809254e-11 + 0.42653528977777777779e-13 * t) * t) * t) * t) * t) * t; 1223 } 1224 case 56: { 1225 double t = 2*y100 - 113; 1226 return 0.17476916455659369953e0 + (0.32531815370903068316e-2 + (0.29536024347344364074e-4 + (0.23309632627767074202e-6 + (0.15899007843582444846e-8 + (0.92610375235427359475e-11 + 0.45054073102222222221e-13 * t) * t) * t) * t) * t) * t; 1227 } 1228 case 57: { 1229 double t = 2*y100 - 115; 1230 return 0.18139556223643701364e0 + (0.33741744168096996041e-2 + (0.30973511714709500836e-4 + (0.24619326937592290996e-6 + (0.16852609412267750744e-8 + (0.98166442942854895573e-11 + 0.47565418097777777779e-13 * t) * t) * t) * t) * t) * t; 1231 } 1232 case 58: { 1233 double t = 2*y100 - 117; 1234 return 0.18826980194443664549e0 + (0.35010775057740317997e-2 + (0.32491914440014267480e-4 + (0.26007572375886319028e-6 + (0.17863299617388376116e-8 + (0.10403065638343878679e-10 + 0.50190265831111111110e-13 * t) * t) * t) * t) * t) * t; 1235 } 1236 case 59: { 1237 double t = 2*y100 - 119; 1238 return 0.19540403413693967350e0 + (0.36342240767211326315e-2 + (0.34096085096200907289e-4 + (0.27479061117017637474e-6 + (0.18934228504790032826e-8 + (0.11021679075323598664e-10 + 0.52931171733333333334e-13 * t) * t) * t) * t) * t) * t; 1239 } 1240 case 60: { 1241 double t = 2*y100 - 121; 1242 return 0.20281109560651886959e0 + (0.37739673859323597060e-2 + (0.35791165457592409054e-4 + (0.29038742889416172404e-6 + (0.20068685374849001770e-8 + (0.11673891799578381999e-10 + 0.55790523093333333334e-13 * t) * t) * t) * t) * t) * t; 1243 } 1244 case 61: { 1245 double t = 2*y100 - 123; 1246 return 0.21050455062669334978e0 + (0.39206818613925652425e-2 + (0.37582602289680101704e-4 + (0.30691836231886877385e-6 + (0.21270101645763677824e-8 + (0.12361138551062899455e-10 + 0.58770520160000000000e-13 * t) * t) * t) * t) * t) * t; 1247 } 1248 case 62: { 1249 double t = 2*y100 - 125; 1250 return 0.21849873453703332479e0 + (0.40747643554689586041e-2 + (0.39476163820986711501e-4 + (0.32443839970139918836e-6 + (0.22542053491518680200e-8 + (0.13084879235290858490e-10 + 0.61873153262222222221e-13 * t) * t) * t) * t) * t) * t; 1251 } 1252 case 63: { 1253 double t = 2*y100 - 127; 1254 return 0.22680879990043229327e0 + (0.42366354648628516935e-2 + (0.41477956909656896779e-4 + (0.34300544894502810002e-6 + (0.23888264229264067658e-8 + (0.13846596292818514601e-10 + 0.65100183751111111110e-13 * t) * t) * t) * t) * t) * t; 1255 } 1256 case 64: { 1257 double t = 2*y100 - 129; 1258 return 0.23545076536988703937e0 + (0.44067409206365170888e-2 + (0.43594444916224700881e-4 + (0.36268045617760415178e-6 + (0.25312606430853202748e-8 + (0.14647791812837903061e-10 + 0.68453122631111111110e-13 * t) * t) * t) * t) * t) * t; 1259 } 1260 case 65: { 1261 double t = 2*y100 - 131; 1262 return 0.24444156740777432838e0 + (0.45855530511605787178e-2 + (0.45832466292683085475e-4 + (0.38352752590033030472e-6 + (0.26819103733055603460e-8 + (0.15489984390884756993e-10 + 0.71933206364444444445e-13 * t) * t) * t) * t) * t) * t; 1263 } 1264 case 66: { 1265 double t = 2*y100 - 133; 1266 return 0.25379911500634264643e0 + (0.47735723208650032167e-2 + (0.48199253896534185372e-4 + (0.40561404245564732314e-6 + (0.28411932320871165585e-8 + (0.16374705736458320149e-10 + 0.75541379822222222221e-13 * t) * t) * t) * t) * t) * t; 1267 } 1268 case 67: { 1269 double t = 2*y100 - 135; 1270 return 0.26354234756393613032e0 + (0.49713289477083781266e-2 + (0.50702455036930367504e-4 + (0.42901079254268185722e-6 + (0.30095422058900481753e-8 + (0.17303497025347342498e-10 + 0.79278273368888888890e-13 * t) * t) * t) * t) * t) * t; 1271 } 1272 case 68: { 1273 double t = 2*y100 - 137; 1274 return 0.27369129607732343398e0 + (0.51793846023052643767e-2 + (0.53350152258326602629e-4 + (0.45379208848865015485e-6 + (0.31874057245814381257e-8 + (0.18277905010245111046e-10 + 0.83144182364444444445e-13 * t) * t) * t) * t) * t) * t; 1275 } 1276 case 69: { 1277 double t = 2*y100 - 139; 1278 return 0.28426714781640316172e0 + (0.53983341916695141966e-2 + (0.56150884865255810638e-4 + (0.48003589196494734238e-6 + (0.33752476967570796349e-8 + (0.19299477888083469086e-10 + 0.87139049137777777779e-13 * t) * t) * t) * t) * t) * t; 1279 } 1280 case 70: { 1281 double t = 2*y100 - 141; 1282 return 0.29529231465348519920e0 + (0.56288077305420795663e-2 + (0.59113671189913307427e-4 + (0.50782393781744840482e-6 + (0.35735475025851713168e-8 + (0.20369760937017070382e-10 + 0.91262442613333333334e-13 * t) * t) * t) * t) * t) * t; 1283 } 1284 case 71: { 1285 double t = 2*y100 - 143; 1286 return 0.30679050522528838613e0 + (0.58714723032745403331e-2 + (0.62248031602197686791e-4 + (0.53724185766200945789e-6 + (0.37827999418960232678e-8 + (0.21490291930444538307e-10 + 0.95513539182222222221e-13 * t) * t) * t) * t) * t) * t; 1287 } 1288 case 72: { 1289 double t = 2*y100 - 145; 1290 return 0.31878680111173319425e0 + (0.61270341192339103514e-2 + (0.65564012259707640976e-4 + (0.56837930287837738996e-6 + (0.40035151353392378882e-8 + (0.22662596341239294792e-10 + 0.99891109760000000000e-13 * t) * t) * t) * t) * t) * t; 1291 } 1292 case 73: { 1293 double t = 2*y100 - 147; 1294 return 0.33130773722152622027e0 + (0.63962406646798080903e-2 + (0.69072209592942396666e-4 + (0.60133006661885941812e-6 + (0.42362183765883466691e-8 + (0.23888182347073698382e-10 + 0.10439349811555555556e-12 * t) * t) * t) * t) * t) * t; 1295 } 1296 case 74: { 1297 double t = 2*y100 - 149; 1298 return 0.34438138658041336523e0 + (0.66798829540414007258e-2 + (0.72783795518603561144e-4 + (0.63619220443228800680e-6 + (0.44814499336514453364e-8 + (0.25168535651285475274e-10 + 0.10901861383111111111e-12 * t) * t) * t) * t) * t) * t; 1299 } 1300 case 75: { 1301 double t = 2*y100 - 151; 1302 return 0.35803744972380175583e0 + (0.69787978834882685031e-2 + (0.76710543371454822497e-4 + (0.67306815308917386747e-6 + (0.47397647975845228205e-8 + (0.26505114141143050509e-10 + 0.11376390933333333333e-12 * t) * t) * t) * t) * t) * t; 1303 } 1304 case 76: { 1305 double t = 2*y100 - 153; 1306 return 0.37230734890119724188e0 + (0.72938706896461381003e-2 + (0.80864854542670714092e-4 + (0.71206484718062688779e-6 + (0.50117323769745883805e-8 + (0.27899342394100074165e-10 + 0.11862637614222222222e-12 * t) * t) * t) * t) * t) * t; 1307 } 1308 case 77: { 1309 double t = 2*y100 - 155; 1310 return 0.38722432730555448223e0 + (0.76260375162549802745e-2 + (0.85259785810004603848e-4 + (0.75329383305171327677e-6 + (0.52979361368388119355e-8 + (0.29352606054164086709e-10 + 0.12360253370666666667e-12 * t) * t) * t) * t) * t) * t; 1311 } 1312 case 78: { 1313 double t = 2*y100 - 157; 1314 return 0.40282355354616940667e0 + (0.79762880915029728079e-2 + (0.89909077342438246452e-4 + (0.79687137961956194579e-6 + (0.55989731807360403195e-8 + (0.30866246101464869050e-10 + 0.12868841946666666667e-12 * t) * t) * t) * t) * t) * t; 1315 } 1316 case 79: { 1317 double t = 2*y100 - 159; 1318 return 0.41914223158913787649e0 + (0.83456685186950463538e-2 + (0.94827181359250161335e-4 + (0.84291858561783141014e-6 + (0.59154537751083485684e-8 + (0.32441553034347469291e-10 + 0.13387957943111111111e-12 * t) * t) * t) * t) * t) * t; 1319 } 1320 case 80: { 1321 double t = 2*y100 - 161; 1322 return 0.43621971639463786896e0 + (0.87352841828289495773e-2 + (0.10002929142066799966e-3 + (0.89156148280219880024e-6 + (0.62480008150788597147e-8 + (0.34079760983458878910e-10 + 0.13917107176888888889e-12 * t) * t) * t) * t) * t) * t; 1323 } 1324 case 81: { 1325 double t = 2*y100 - 163; 1326 return 0.45409763548534330981e0 + (0.91463027755548240654e-2 + (0.10553137232446167258e-3 + (0.94293113464638623798e-6 + (0.65972492312219959885e-8 + (0.35782041795476563662e-10 + 0.14455745872000000000e-12 * t) * t) * t) * t) * t) * t; 1327 } 1328 case 82: { 1329 double t = 2*y100 - 165; 1330 return 0.47282001668512331468e0 + (0.95799574408860463394e-2 + (0.11135019058000067469e-3 + (0.99716373005509038080e-6 + (0.69638453369956970347e-8 + (0.37549499088161345850e-10 + 0.15003280712888888889e-12 * t) * t) * t) * t) * t) * t; 1331 } 1332 case 83: { 1333 double t = 2*y100 - 167; 1334 return 0.49243342227179841649e0 + (0.10037550043909497071e-1 + (0.11750334542845234952e-3 + (0.10544006716188967172e-5 + (0.73484461168242224872e-8 + (0.39383162326435752965e-10 + 0.15559069118222222222e-12 * t) * t) * t) * t) * t) * t; 1335 } 1336 case 84: { 1337 double t = 2*y100 - 169; 1338 return 0.51298708979209258326e0 + (0.10520454564612427224e-1 + (0.12400930037494996655e-3 + (0.11147886579371265246e-5 + (0.77517184550568711454e-8 + (0.41283980931872622611e-10 + 0.16122419680000000000e-12 * t) * t) * t) * t) * t) * t; 1339 } 1340 case 85: { 1341 double t = 2*y100 - 171; 1342 return 0.53453307979101369843e0 + (0.11030120618800726938e-1 + (0.13088741519572269581e-3 + (0.11784797595374515432e-5 + (0.81743383063044825400e-8 + (0.43252818449517081051e-10 + 0.16692592640000000000e-12 * t) * t) * t) * t) * t) * t; 1343 } 1344 case 86: { 1345 double t = 2*y100 - 173; 1346 return 0.55712643071169299478e0 + (0.11568077107929735233e-1 + (0.13815797838036651289e-3 + (0.12456314879260904558e-5 + (0.86169898078969313597e-8 + (0.45290446811539652525e-10 + 0.17268801084444444444e-12 * t) * t) * t) * t) * t) * t; 1347 } 1348 case 87: { 1349 double t = 2*y100 - 175; 1350 return 0.58082532122519320968e0 + (0.12135935999503877077e-1 + (0.14584223996665838559e-3 + (0.13164068573095710742e-5 + (0.90803643355106020163e-8 + (0.47397540713124619155e-10 + 0.17850211608888888889e-12 * t) * t) * t) * t) * t) * t; 1351 } 1352 case 88: { 1353 double t = 2*y100 - 177; 1354 return 0.60569124025293375554e0 + (0.12735396239525550361e-1 + (0.15396244472258863344e-3 + (0.13909744385382818253e-5 + (0.95651595032306228245e-8 + (0.49574672127669041550e-10 + 0.18435945564444444444e-12 * t) * t) * t) * t) * t) * t; 1355 } 1356 case 89: { 1357 double t = 2*y100 - 179; 1358 return 0.63178916494715716894e0 + (0.13368247798287030927e-1 + (0.16254186562762076141e-3 + (0.14695084048334056083e-5 + (0.10072078109604152350e-7 + (0.51822304995680707483e-10 + 0.19025081422222222222e-12 * t) * t) * t) * t) * t) * t; 1359 } 1360 case 90: { 1361 double t = 2*y100 - 181; 1362 return 0.65918774689725319200e0 + (0.14036375850601992063e-1 + (0.17160483760259706354e-3 + (0.15521885688723188371e-5 + (0.10601827031535280590e-7 + (0.54140790105837520499e-10 + 0.19616655146666666667e-12 * t) * t) * t) * t) * t) * t; 1363 } 1364 case 91: { 1365 double t = 2*y100 - 183; 1366 return 0.68795950683174433822e0 + (0.14741765091365869084e-1 + (0.18117679143520433835e-3 + (0.16392004108230585213e-5 + (0.11155116068018043001e-7 + (0.56530360194925690374e-10 + 0.20209663662222222222e-12 * t) * t) * t) * t) * t) * t; 1367 } 1368 case 92: { 1369 double t = 2*y100 - 185; 1370 return 0.71818103808729967036e0 + (0.15486504187117112279e-1 + (0.19128428784550923217e-3 + (0.17307350969359975848e-5 + (0.11732656736113607751e-7 + (0.58991125287563833603e-10 + 0.20803065333333333333e-12 * t) * t) * t) * t) * t) * t; 1371 } 1372 case 93: { 1373 double t = 2*y100 - 187; 1374 return 0.74993321911726254661e0 + (0.16272790364044783382e-1 + (0.20195505163377912645e-3 + (0.18269894883203346953e-5 + (0.12335161021630225535e-7 + (0.61523068312169087227e-10 + 0.21395783431111111111e-12 * t) * t) * t) * t) * t) * t; 1375 } 1376 case 94: { 1377 double t = 2*y100 - 189; 1378 return 0.78330143531283492729e0 + (0.17102934132652429240e-1 + (0.21321800585063327041e-3 + (0.19281661395543913713e-5 + (0.12963340087354341574e-7 + (0.64126040998066348872e-10 + 0.21986708942222222222e-12 * t) * t) * t) * t) * t) * t; 1379 } 1380 case 95: { 1381 double t = 2*y100 - 191; 1382 return 0.81837581041023811832e0 + (0.17979364149044223802e-1 + (0.22510330592753129006e-3 + (0.20344732868018175389e-5 + (0.13617902941839949718e-7 + (0.66799760083972474642e-10 + 0.22574701262222222222e-12 * t) * t) * t) * t) * t) * t; 1383 } 1384 case 96: { 1385 double t = 2*y100 - 193; 1386 return 0.85525144775685126237e0 + (0.18904632212547561026e-1 + (0.23764237370371255638e-3 + (0.21461248251306387979e-5 + (0.14299555071870523786e-7 + (0.69543803864694171934e-10 + 0.23158593688888888889e-12 * t) * t) * t) * t) * t) * t; 1387 } 1388 case 97: { 1389 double t = 2*y100 - 195; 1390 return 0.89402868170849933734e0 + (0.19881418399127202569e-1 + (0.25086793128395995798e-3 + (0.22633402747585233180e-5 + (0.15008997042116532283e-7 + (0.72357609075043941261e-10 + 0.23737194737777777778e-12 * t) * t) * t) * t) * t) * t; 1391 } 1392 case 98: { 1393 double t = 2*y100 - 197; 1394 return 0.93481333942870796363e0 + (0.20912536329780368893e-1 + (0.26481403465998477969e-3 + (0.23863447359754921676e-5 + (0.15746923065472184451e-7 + (0.75240468141720143653e-10 + 0.24309291271111111111e-12 * t) * t) * t) * t) * t) * t; 1395 } 1396 case 99: { 1397 double t = 2*y100 - 199; 1398 return 0.97771701335885035464e0 + (0.22000938572830479551e-1 + (0.27951610702682383001e-3 + (0.25153688325245314530e-5 + (0.16514019547822821453e-7 + (0.78191526829368231251e-10 + 0.24873652355555555556e-12 * t) * t) * t) * t) * t) * t; 1399 } 1400 } 1401 // we only get here if y = 1, i.e. |x| < 4*eps, in which case 1402 // erfcx is within 1e-15 of 1.. 1403 return 1.0; 1404 } 1405 1406 double FADDEEVA_RE(erfcx)(double x) 1407 { 1408 if (x >= 0) { 1409 if (x > 50) { // continued-fraction expansion is faster 1410 const double ispi = 0.56418958354775628694807945156; // 1 / sqrt(pi) 1411 if (x > 5e7) // 1-term expansion, important to avoid overflow 1412 return ispi / x; 1413 /* 5-term expansion (rely on compiler for CSE), simplified from: 1414 ispi / (x+0.5/(x+1/(x+1.5/(x+2/x)))) */ 1415 return ispi*((x*x) * (x*x+4.5) + 2) / (x * ((x*x) * (x*x+5) + 3.75)); 1416 } 1417 return erfcx_y100(400/(4+x)); 1418 } 1419 else 1420 return x < -26.7 ? HUGE_VAL : (x < -6.1 ? 2*exp(x*x) 1421 : 2*exp(x*x) - erfcx_y100(400/(4-x))); 1422 } 1423 1424 ///////////////////////////////////////////////////////////////////////// 1425 /* Compute a scaled Dawson integral 1426 FADDEEVA(w_im)(x) = 2*Dawson(x)/sqrt(pi) 1427 equivalent to the imaginary part w(x) for real x. 1428 1429 Uses methods similar to the erfcx calculation above: continued fractions 1430 for large |x|, a lookup table of Chebyshev polynomials for smaller |x|, 1431 and finally a Taylor expansion for |x|<0.01. 1432 1433 Steven G. Johnson, October 2012. */ 1434 1435 /* Given y100=100*y, where y = 1/(1+x) for x >= 0, compute w_im(x). 1436 1437 Uses a look-up table of 100 different Chebyshev polynomials 1438 for y intervals [0,0.01], [0.01,0.02], ...., [0.99,1], generated 1439 with the help of Maple and a little shell script. This allows 1440 the Chebyshev polynomials to be of significantly lower degree (about 1/30) 1441 compared to fitting the whole [0,1] interval with a single polynomial. */ 1442 static double w_im_y100(double y100, double x) { 1443 switch ((int) y100) { 1444 case 0: { 1445 double t = 2*y100 - 1; 1446 return 0.28351593328822191546e-2 + (0.28494783221378400759e-2 + (0.14427470563276734183e-4 + (0.10939723080231588129e-6 + (0.92474307943275042045e-9 + (0.89128907666450075245e-11 + 0.92974121935111111110e-13 * t) * t) * t) * t) * t) * t; 1447 } 1448 case 1: { 1449 double t = 2*y100 - 3; 1450 return 0.85927161243940350562e-2 + (0.29085312941641339862e-2 + (0.15106783707725582090e-4 + (0.11716709978531327367e-6 + (0.10197387816021040024e-8 + (0.10122678863073360769e-10 + 0.10917479678400000000e-12 * t) * t) * t) * t) * t) * t; 1451 } 1452 case 2: { 1453 double t = 2*y100 - 5; 1454 return 0.14471159831187703054e-1 + (0.29703978970263836210e-2 + (0.15835096760173030976e-4 + (0.12574803383199211596e-6 + (0.11278672159518415848e-8 + (0.11547462300333495797e-10 + 0.12894535335111111111e-12 * t) * t) * t) * t) * t) * t; 1455 } 1456 case 3: { 1457 double t = 2*y100 - 7; 1458 return 0.20476320420324610618e-1 + (0.30352843012898665856e-2 + (0.16617609387003727409e-4 + (0.13525429711163116103e-6 + (0.12515095552507169013e-8 + (0.13235687543603382345e-10 + 0.15326595042666666667e-12 * t) * t) * t) * t) * t) * t; 1459 } 1460 case 4: { 1461 double t = 2*y100 - 9; 1462 return 0.26614461952489004566e-1 + (0.31034189276234947088e-2 + (0.17460268109986214274e-4 + (0.14582130824485709573e-6 + (0.13935959083809746345e-8 + (0.15249438072998932900e-10 + 0.18344741882133333333e-12 * t) * t) * t) * t) * t) * t; 1463 } 1464 case 5: { 1465 double t = 2*y100 - 11; 1466 return 0.32892330248093586215e-1 + (0.31750557067975068584e-2 + (0.18369907582308672632e-4 + (0.15761063702089457882e-6 + (0.15577638230480894382e-8 + (0.17663868462699097951e-10 + (0.22126732680711111111e-12 + 0.30273474177737853668e-14 * t) * t) * t) * t) * t) * t) * t; 1467 } 1468 case 6: { 1469 double t = 2*y100 - 13; 1470 return 0.39317207681134336024e-1 + (0.32504779701937539333e-2 + (0.19354426046513400534e-4 + (0.17081646971321290539e-6 + (0.17485733959327106250e-8 + (0.20593687304921961410e-10 + (0.26917401949155555556e-12 + 0.38562123837725712270e-14 * t) * t) * t) * t) * t) * t) * t; 1471 } 1472 case 7: { 1473 double t = 2*y100 - 15; 1474 return 0.45896976511367738235e-1 + (0.33300031273110976165e-2 + (0.20423005398039037313e-4 + (0.18567412470376467303e-6 + (0.19718038363586588213e-8 + (0.24175006536781219807e-10 + (0.33059982791466666666e-12 + 0.49756574284439426165e-14 * t) * t) * t) * t) * t) * t) * t; 1475 } 1476 case 8: { 1477 double t = 2*y100 - 17; 1478 return 0.52640192524848962855e-1 + (0.34139883358846720806e-2 + (0.21586390240603337337e-4 + (0.20247136501568904646e-6 + (0.22348696948197102935e-8 + (0.28597516301950162548e-10 + (0.41045502119111111110e-12 + 0.65151614515238361946e-14 * t) * t) * t) * t) * t) * t) * t; 1479 } 1480 case 9: { 1481 double t = 2*y100 - 19; 1482 return 0.59556171228656770456e-1 + (0.35028374386648914444e-2 + (0.22857246150998562824e-4 + (0.22156372146525190679e-6 + (0.25474171590893813583e-8 + (0.34122390890697400584e-10 + (0.51593189879111111110e-12 + 0.86775076853908006938e-14 * t) * t) * t) * t) * t) * t) * t; 1483 } 1484 case 10: { 1485 double t = 2*y100 - 21; 1486 return 0.66655089485108212551e-1 + (0.35970095381271285568e-2 + (0.24250626164318672928e-4 + (0.24339561521785040536e-6 + (0.29221990406518411415e-8 + (0.41117013527967776467e-10 + (0.65786450716444444445e-12 + 0.11791885745450623331e-13 * t) * t) * t) * t) * t) * t) * t; 1487 } 1488 case 11: { 1489 double t = 2*y100 - 23; 1490 return 0.73948106345519174661e-1 + (0.36970297216569341748e-2 + (0.25784588137312868792e-4 + (0.26853012002366752770e-6 + (0.33763958861206729592e-8 + (0.50111549981376976397e-10 + (0.85313857496888888890e-12 + 0.16417079927706899860e-13 * t) * t) * t) * t) * t) * t) * t; 1491 } 1492 case 12: { 1493 double t = 2*y100 - 25; 1494 return 0.81447508065002963203e-1 + (0.38035026606492705117e-2 + (0.27481027572231851896e-4 + (0.29769200731832331364e-6 + (0.39336816287457655076e-8 + (0.61895471132038157624e-10 + (0.11292303213511111111e-11 + 0.23558532213703884304e-13 * t) * t) * t) * t) * t) * t) * t; 1495 } 1496 case 13: { 1497 double t = 2*y100 - 27; 1498 return 0.89166884027582716628e-1 + (0.39171301322438946014e-2 + (0.29366827260422311668e-4 + (0.33183204390350724895e-6 + (0.46276006281647330524e-8 + (0.77692631378169813324e-10 + (0.15335153258844444444e-11 + 0.35183103415916026911e-13 * t) * t) * t) * t) * t) * t) * t; 1499 } 1500 case 14: { 1501 double t = 2*y100 - 29; 1502 return 0.97121342888032322019e-1 + (0.40387340353207909514e-2 + (0.31475490395950776930e-4 + (0.37222714227125135042e-6 + (0.55074373178613809996e-8 + (0.99509175283990337944e-10 + (0.21552645758222222222e-11 + 0.55728651431872687605e-13 * t) * t) * t) * t) * t) * t) * t; 1503 } 1504 case 15: { 1505 double t = 2*y100 - 31; 1506 return 0.10532778218603311137e0 + (0.41692873614065380607e-2 + (0.33849549774889456984e-4 + (0.42064596193692630143e-6 + (0.66494579697622432987e-8 + (0.13094103581931802337e-9 + (0.31896187409777777778e-11 + 0.97271974184476560742e-13 * t) * t) * t) * t) * t) * t) * t; 1507 } 1508 case 16: { 1509 double t = 2*y100 - 33; 1510 return 0.11380523107427108222e0 + (0.43099572287871821013e-2 + (0.36544324341565929930e-4 + (0.47965044028581857764e-6 + (0.81819034238463698796e-8 + (0.17934133239549647357e-9 + (0.50956666166186293627e-11 + (0.18850487318190638010e-12 + 0.79697813173519853340e-14 * t) * t) * t) * t) * t) * t) * t) * t; 1511 } 1512 case 17: { 1513 double t = 2*y100 - 35; 1514 return 0.12257529703447467345e0 + (0.44621675710026986366e-2 + (0.39634304721292440285e-4 + (0.55321553769873381819e-6 + (0.10343619428848520870e-7 + (0.26033830170470368088e-9 + (0.87743837749108025357e-11 + (0.34427092430230063401e-12 + 0.10205506615709843189e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1515 } 1516 case 18: { 1517 double t = 2*y100 - 37; 1518 return 0.13166276955656699478e0 + (0.46276970481783001803e-2 + (0.43225026380496399310e-4 + (0.64799164020016902656e-6 + (0.13580082794704641782e-7 + (0.39839800853954313927e-9 + (0.14431142411840000000e-10 + 0.42193457308830027541e-12 * t) * t) * t) * t) * t) * t) * t; 1519 } 1520 case 19: { 1521 double t = 2*y100 - 39; 1522 return 0.14109647869803356475e0 + (0.48088424418545347758e-2 + (0.47474504753352150205e-4 + (0.77509866468724360352e-6 + (0.18536851570794291724e-7 + (0.60146623257887570439e-9 + (0.18533978397305276318e-10 + (0.41033845938901048380e-13 - 0.46160680279304825485e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1523 } 1524 case 20: { 1525 double t = 2*y100 - 41; 1526 return 0.15091057940548936603e0 + (0.50086864672004685703e-2 + (0.52622482832192230762e-4 + (0.95034664722040355212e-6 + (0.25614261331144718769e-7 + (0.80183196716888606252e-9 + (0.12282524750534352272e-10 + (-0.10531774117332273617e-11 - 0.86157181395039646412e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1527 } 1528 case 21: { 1529 double t = 2*y100 - 43; 1530 return 0.16114648116017010770e0 + (0.52314661581655369795e-2 + (0.59005534545908331315e-4 + (0.11885518333915387760e-5 + (0.33975801443239949256e-7 + (0.82111547144080388610e-9 + (-0.12357674017312854138e-10 + (-0.24355112256914479176e-11 - 0.75155506863572930844e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1531 } 1532 case 22: { 1533 double t = 2*y100 - 45; 1534 return 0.17185551279680451144e0 + (0.54829002967599420860e-2 + (0.67013226658738082118e-4 + (0.14897400671425088807e-5 + (0.40690283917126153701e-7 + (0.44060872913473778318e-9 + (-0.52641873433280000000e-10 - 0.30940587864543343124e-11 * t) * t) * t) * t) * t) * t) * t; 1535 } 1536 case 23: { 1537 double t = 2*y100 - 47; 1538 return 0.18310194559815257381e0 + (0.57701559375966953174e-2 + (0.76948789401735193483e-4 + (0.18227569842290822512e-5 + (0.41092208344387212276e-7 + (-0.44009499965694442143e-9 + (-0.92195414685628803451e-10 + (-0.22657389705721753299e-11 + 0.10004784908106839254e-12 * t) * t) * t) * t) * t) * t) * t) * t; 1539 } 1540 case 24: { 1541 double t = 2*y100 - 49; 1542 return 0.19496527191546630345e0 + (0.61010853144364724856e-2 + (0.88812881056342004864e-4 + (0.21180686746360261031e-5 + (0.30652145555130049203e-7 + (-0.16841328574105890409e-8 + (-0.11008129460612823934e-9 + (-0.12180794204544515779e-12 + 0.15703325634590334097e-12 * t) * t) * t) * t) * t) * t) * t) * t; 1543 } 1544 case 25: { 1545 double t = 2*y100 - 51; 1546 return 0.20754006813966575720e0 + (0.64825787724922073908e-2 + (0.10209599627522311893e-3 + (0.22785233392557600468e-5 + (0.73495224449907568402e-8 + (-0.29442705974150112783e-8 + (-0.94082603434315016546e-10 + (0.23609990400179321267e-11 + 0.14141908654269023788e-12 * t) * t) * t) * t) * t) * t) * t) * t; 1547 } 1548 case 26: { 1549 double t = 2*y100 - 53; 1550 return 0.22093185554845172146e0 + (0.69182878150187964499e-2 + (0.11568723331156335712e-3 + (0.22060577946323627739e-5 + (-0.26929730679360840096e-7 + (-0.38176506152362058013e-8 + (-0.47399503861054459243e-10 + (0.40953700187172127264e-11 + 0.69157730376118511127e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1551 } 1552 case 27: { 1553 double t = 2*y100 - 55; 1554 return 0.23524827304057813918e0 + (0.74063350762008734520e-2 + (0.12796333874615790348e-3 + (0.18327267316171054273e-5 + (-0.66742910737957100098e-7 + (-0.40204740975496797870e-8 + (0.14515984139495745330e-10 + (0.44921608954536047975e-11 - 0.18583341338983776219e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1555 } 1556 case 28: { 1557 double t = 2*y100 - 57; 1558 return 0.25058626331812744775e0 + (0.79377285151602061328e-2 + (0.13704268650417478346e-3 + (0.11427511739544695861e-5 + (-0.10485442447768377485e-6 + (-0.34850364756499369763e-8 + (0.72656453829502179208e-10 + (0.36195460197779299406e-11 - 0.84882136022200714710e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1559 } 1560 case 29: { 1561 double t = 2*y100 - 59; 1562 return 0.26701724900280689785e0 + (0.84959936119625864274e-2 + (0.14112359443938883232e-3 + (0.17800427288596909634e-6 + (-0.13443492107643109071e-6 + (-0.23512456315677680293e-8 + (0.11245846264695936769e-9 + (0.19850501334649565404e-11 - 0.11284666134635050832e-12 * t) * t) * t) * t) * t) * t) * t) * t; 1563 } 1564 case 30: { 1565 double t = 2*y100 - 61; 1566 return 0.28457293586253654144e0 + (0.90581563892650431899e-2 + (0.13880520331140646738e-3 + (-0.97262302362522896157e-6 + (-0.15077100040254187366e-6 + (-0.88574317464577116689e-9 + (0.12760311125637474581e-9 + (0.20155151018282695055e-12 - 0.10514169375181734921e-12 * t) * t) * t) * t) * t) * t) * t) * t; 1567 } 1568 case 31: { 1569 double t = 2*y100 - 63; 1570 return 0.30323425595617385705e0 + (0.95968346790597422934e-2 + (0.12931067776725883939e-3 + (-0.21938741702795543986e-5 + (-0.15202888584907373963e-6 + (0.61788350541116331411e-9 + (0.11957835742791248256e-9 + (-0.12598179834007710908e-11 - 0.75151817129574614194e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1571 } 1572 case 32: { 1573 double t = 2*y100 - 65; 1574 return 0.32292521181517384379e0 + (0.10082957727001199408e-1 + (0.11257589426154962226e-3 + (-0.33670890319327881129e-5 + (-0.13910529040004008158e-6 + (0.19170714373047512945e-8 + (0.94840222377720494290e-10 + (-0.21650018351795353201e-11 - 0.37875211678024922689e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1575 } 1576 case 33: { 1577 double t = 2*y100 - 67; 1578 return 0.34351233557911753862e0 + (0.10488575435572745309e-1 + (0.89209444197248726614e-4 + (-0.43893459576483345364e-5 + (-0.11488595830450424419e-6 + (0.28599494117122464806e-8 + (0.61537542799857777779e-10 - 0.24935749227658002212e-11 * t) * t) * t) * t) * t) * t) * t; 1579 } 1580 case 34: { 1581 double t = 2*y100 - 69; 1582 return 0.36480946642143669093e0 + (0.10789304203431861366e-1 + (0.60357993745283076834e-4 + (-0.51855862174130669389e-5 + (-0.83291664087289801313e-7 + (0.33898011178582671546e-8 + (0.27082948188277716482e-10 + (-0.23603379397408694974e-11 + 0.19328087692252869842e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1583 } 1584 case 35: { 1585 double t = 2*y100 - 71; 1586 return 0.38658679935694939199e0 + (0.10966119158288804999e-1 + (0.27521612041849561426e-4 + (-0.57132774537670953638e-5 + (-0.48404772799207914899e-7 + (0.35268354132474570493e-8 + (-0.32383477652514618094e-11 + (-0.19334202915190442501e-11 + 0.32333189861286460270e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1587 } 1588 case 36: { 1589 double t = 2*y100 - 73; 1590 return 0.40858275583808707870e0 + (0.11006378016848466550e-1 + (-0.76396376685213286033e-5 + (-0.59609835484245791439e-5 + (-0.13834610033859313213e-7 + (0.33406952974861448790e-8 + (-0.26474915974296612559e-10 + (-0.13750229270354351983e-11 + 0.36169366979417390637e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1591 } 1592 case 37: { 1593 double t = 2*y100 - 75; 1594 return 0.43051714914006682977e0 + (0.10904106549500816155e-1 + (-0.43477527256787216909e-4 + (-0.59429739547798343948e-5 + (0.17639200194091885949e-7 + (0.29235991689639918688e-8 + (-0.41718791216277812879e-10 + (-0.81023337739508049606e-12 + 0.33618915934461994428e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1595 } 1596 case 38: { 1597 double t = 2*y100 - 77; 1598 return 0.45210428135559607406e0 + (0.10659670756384400554e-1 + (-0.78488639913256978087e-4 + (-0.56919860886214735936e-5 + (0.44181850467477733407e-7 + (0.23694306174312688151e-8 + (-0.49492621596685443247e-10 + (-0.31827275712126287222e-12 + 0.27494438742721623654e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1599 } 1600 case 39: { 1601 double t = 2*y100 - 79; 1602 return 0.47306491195005224077e0 + (0.10279006119745977570e-1 + (-0.11140268171830478306e-3 + (-0.52518035247451432069e-5 + (0.64846898158889479518e-7 + (0.17603624837787337662e-8 + (-0.51129481592926104316e-10 + (0.62674584974141049511e-13 + 0.20055478560829935356e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1603 } 1604 case 40: { 1605 double t = 2*y100 - 81; 1606 return 0.49313638965719857647e0 + (0.97725799114772017662e-2 + (-0.14122854267291533334e-3 + (-0.46707252568834951907e-5 + (0.79421347979319449524e-7 + (0.11603027184324708643e-8 + (-0.48269605844397175946e-10 + (0.32477251431748571219e-12 + 0.12831052634143527985e-13 * t) * t) * t) * t) * t) * t) * t) * t; 1607 } 1608 case 41: { 1609 double t = 2*y100 - 83; 1610 return 0.51208057433416004042e0 + (0.91542422354009224951e-2 + (-0.16726530230228647275e-3 + (-0.39964621752527649409e-5 + (0.88232252903213171454e-7 + (0.61343113364949928501e-9 + (-0.42516755603130443051e-10 + (0.47910437172240209262e-12 + 0.66784341874437478953e-14 * t) * t) * t) * t) * t) * t) * t) * t; 1611 } 1612 case 42: { 1613 double t = 2*y100 - 85; 1614 return 0.52968945458607484524e0 + (0.84400880445116786088e-2 + (-0.18908729783854258774e-3 + (-0.32725905467782951931e-5 + (0.91956190588652090659e-7 + (0.14593989152420122909e-9 + (-0.35239490687644444445e-10 + 0.54613829888448694898e-12 * t) * t) * t) * t) * t) * t) * t; 1615 } 1616 case 43: { 1617 double t = 2*y100 - 87; 1618 return 0.54578857454330070965e0 + (0.76474155195880295311e-2 + (-0.20651230590808213884e-3 + (-0.25364339140543131706e-5 + (0.91455367999510681979e-7 + (-0.23061359005297528898e-9 + (-0.27512928625244444444e-10 + 0.54895806008493285579e-12 * t) * t) * t) * t) * t) * t) * t; 1619 } 1620 case 44: { 1621 double t = 2*y100 - 89; 1622 return 0.56023851910298493910e0 + (0.67938321739997196804e-2 + (-0.21956066613331411760e-3 + (-0.18181127670443266395e-5 + (0.87650335075416845987e-7 + (-0.51548062050366615977e-9 + (-0.20068462174044444444e-10 + 0.50912654909758187264e-12 * t) * t) * t) * t) * t) * t) * t; 1623 } 1624 case 45: { 1625 double t = 2*y100 - 91; 1626 return 0.57293478057455721150e0 + (0.58965321010394044087e-2 + (-0.22841145229276575597e-3 + (-0.11404605562013443659e-5 + (0.81430290992322326296e-7 + (-0.71512447242755357629e-9 + (-0.13372664928000000000e-10 + 0.44461498336689298148e-12 * t) * t) * t) * t) * t) * t) * t; 1627 } 1628 case 46: { 1629 double t = 2*y100 - 93; 1630 return 0.58380635448407827360e0 + (0.49717469530842831182e-2 + (-0.23336001540009645365e-3 + (-0.51952064448608850822e-6 + (0.73596577815411080511e-7 + (-0.84020916763091566035e-9 + (-0.76700972702222222221e-11 + 0.36914462807972467044e-12 * t) * t) * t) * t) * t) * t) * t; 1631 } 1632 case 47: { 1633 double t = 2*y100 - 95; 1634 return 0.59281340237769489597e0 + (0.40343592069379730568e-2 + (-0.23477963738658326185e-3 + (0.34615944987790224234e-7 + (0.64832803248395814574e-7 + (-0.90329163587627007971e-9 + (-0.30421940400000000000e-11 + 0.29237386653743536669e-12 * t) * t) * t) * t) * t) * t) * t; 1635 } 1636 case 48: { 1637 double t = 2*y100 - 97; 1638 return 0.59994428743114271918e0 + (0.30976579788271744329e-2 + (-0.23308875765700082835e-3 + (0.51681681023846925160e-6 + (0.55694594264948268169e-7 + (-0.91719117313243464652e-9 + (0.53982743680000000000e-12 + 0.22050829296187771142e-12 * t) * t) * t) * t) * t) * t) * t; 1639 } 1640 case 49: { 1641 double t = 2*y100 - 99; 1642 return 0.60521224471819875444e0 + (0.21732138012345456060e-2 + (-0.22872428969625997456e-3 + (0.92588959922653404233e-6 + (0.46612665806531930684e-7 + (-0.89393722514414153351e-9 + (0.31718550353777777778e-11 + 0.15705458816080549117e-12 * t) * t) * t) * t) * t) * t) * t; 1643 } 1644 case 50: { 1645 double t = 2*y100 - 101; 1646 return 0.60865189969791123620e0 + (0.12708480848877451719e-2 + (-0.22212090111534847166e-3 + (0.12636236031532793467e-5 + (0.37904037100232937574e-7 + (-0.84417089968101223519e-9 + (0.49843180828444444445e-11 + 0.10355439441049048273e-12 * t) * t) * t) * t) * t) * t) * t; 1647 } 1648 case 51: { 1649 double t = 2*y100 - 103; 1650 return 0.61031580103499200191e0 + (0.39867436055861038223e-3 + (-0.21369573439579869291e-3 + (0.15339402129026183670e-5 + (0.29787479206646594442e-7 + (-0.77687792914228632974e-9 + (0.61192452741333333334e-11 + 0.60216691829459295780e-13 * t) * t) * t) * t) * t) * t) * t; 1651 } 1652 case 52: { 1653 double t = 2*y100 - 105; 1654 return 0.61027109047879835868e0 + (-0.43680904508059878254e-3 + (-0.20383783788303894442e-3 + (0.17421743090883439959e-5 + (0.22400425572175715576e-7 + (-0.69934719320045128997e-9 + (0.67152759655111111110e-11 + 0.26419960042578359995e-13 * t) * t) * t) * t) * t) * t) * t; 1655 } 1656 case 53: { 1657 double t = 2*y100 - 107; 1658 return 0.60859639489217430521e0 + (-0.12305921390962936873e-2 + (-0.19290150253894682629e-3 + (0.18944904654478310128e-5 + (0.15815530398618149110e-7 + (-0.61726850580964876070e-9 + 0.68987888999111111110e-11 * t) * t) * t) * t) * t) * t; 1659 } 1660 case 54: { 1661 double t = 2*y100 - 109; 1662 return 0.60537899426486075181e0 + (-0.19790062241395705751e-2 + (-0.18120271393047062253e-3 + (0.19974264162313241405e-5 + (0.10055795094298172492e-7 + (-0.53491997919318263593e-9 + (0.67794550295111111110e-11 - 0.17059208095741511603e-13 * t) * t) * t) * t) * t) * t) * t; 1663 } 1664 case 55: { 1665 double t = 2*y100 - 111; 1666 return 0.60071229457904110537e0 + (-0.26795676776166354354e-2 + (-0.16901799553627508781e-3 + (0.20575498324332621581e-5 + (0.51077165074461745053e-8 + (-0.45536079828057221858e-9 + (0.64488005516444444445e-11 - 0.29311677573152766338e-13 * t) * t) * t) * t) * t) * t) * t; 1667 } 1668 case 56: { 1669 double t = 2*y100 - 113; 1670 return 0.59469361520112714738e0 + (-0.33308208190600993470e-2 + (-0.15658501295912405679e-3 + (0.20812116912895417272e-5 + (0.93227468760614182021e-9 + (-0.38066673740116080415e-9 + (0.59806790359111111110e-11 - 0.36887077278950440597e-13 * t) * t) * t) * t) * t) * t) * t; 1671 } 1672 case 57: { 1673 double t = 2*y100 - 115; 1674 return 0.58742228631775388268e0 + (-0.39321858196059227251e-2 + (-0.14410441141450122535e-3 + (0.20743790018404020716e-5 + (-0.25261903811221913762e-8 + (-0.31212416519526924318e-9 + (0.54328422462222222221e-11 - 0.40864152484979815972e-13 * t) * t) * t) * t) * t) * t) * t; 1675 } 1676 case 58: { 1677 double t = 2*y100 - 117; 1678 return 0.57899804200033018447e0 + (-0.44838157005618913447e-2 + (-0.13174245966501437965e-3 + (0.20425306888294362674e-5 + (-0.53330296023875447782e-8 + (-0.25041289435539821014e-9 + (0.48490437205333333334e-11 - 0.42162206939169045177e-13 * t) * t) * t) * t) * t) * t) * t; 1679 } 1680 case 59: { 1681 double t = 2*y100 - 119; 1682 return 0.56951968796931245974e0 + (-0.49864649488074868952e-2 + (-0.11963416583477567125e-3 + (0.19906021780991036425e-5 + (-0.75580140299436494248e-8 + (-0.19576060961919820491e-9 + (0.42613011928888888890e-11 - 0.41539443304115604377e-13 * t) * t) * t) * t) * t) * t) * t; 1683 } 1684 case 60: { 1685 double t = 2*y100 - 121; 1686 return 0.55908401930063918964e0 + (-0.54413711036826877753e-2 + (-0.10788661102511914628e-3 + (0.19229663322982839331e-5 + (-0.92714731195118129616e-8 + (-0.14807038677197394186e-9 + (0.36920870298666666666e-11 - 0.39603726688419162617e-13 * t) * t) * t) * t) * t) * t) * t; 1687 } 1688 case 61: { 1689 double t = 2*y100 - 123; 1690 return 0.54778496152925675315e0 + (-0.58501497933213396670e-2 + (-0.96582314317855227421e-4 + (0.18434405235069270228e-5 + (-0.10541580254317078711e-7 + (-0.10702303407788943498e-9 + (0.31563175582222222222e-11 - 0.36829748079110481422e-13 * t) * t) * t) * t) * t) * t) * t; 1691 } 1692 case 62: { 1693 double t = 2*y100 - 125; 1694 return 0.53571290831682823999e0 + (-0.62147030670760791791e-2 + (-0.85782497917111760790e-4 + (0.17553116363443470478e-5 + (-0.11432547349815541084e-7 + (-0.72157091369041330520e-10 + (0.26630811607111111111e-11 - 0.33578660425893164084e-13 * t) * t) * t) * t) * t) * t) * t; 1695 } 1696 case 63: { 1697 double t = 2*y100 - 127; 1698 return 0.52295422962048434978e0 + (-0.65371404367776320720e-2 + (-0.75530164941473343780e-4 + (0.16613725797181276790e-5 + (-0.12003521296598910761e-7 + (-0.42929753689181106171e-10 + (0.22170894940444444444e-11 - 0.30117697501065110505e-13 * t) * t) * t) * t) * t) * t) * t; 1699 } 1700 case 64: { 1701 double t = 2*y100 - 129; 1702 return 0.50959092577577886140e0 + (-0.68197117603118591766e-2 + (-0.65852936198953623307e-4 + (0.15639654113906716939e-5 + (-0.12308007991056524902e-7 + (-0.18761997536910939570e-10 + (0.18198628922666666667e-11 - 0.26638355362285200932e-13 * t) * t) * t) * t) * t) * t) * t; 1703 } 1704 case 65: { 1705 double t = 2*y100 - 131; 1706 return 0.49570040481823167970e0 + (-0.70647509397614398066e-2 + (-0.56765617728962588218e-4 + (0.14650274449141448497e-5 + (-0.12393681471984051132e-7 + (0.92904351801168955424e-12 + (0.14706755960177777778e-11 - 0.23272455351266325318e-13 * t) * t) * t) * t) * t) * t) * t; 1707 } 1708 case 66: { 1709 double t = 2*y100 - 133; 1710 return 0.48135536250935238066e0 + (-0.72746293327402359783e-2 + (-0.48272489495730030780e-4 + (0.13661377309113939689e-5 + (-0.12302464447599382189e-7 + (0.16707760028737074907e-10 + (0.11672928324444444444e-11 - 0.20105801424709924499e-13 * t) * t) * t) * t) * t) * t) * t; 1711 } 1712 case 67: { 1713 double t = 2*y100 - 135; 1714 return 0.46662374675511439448e0 + (-0.74517177649528487002e-2 + (-0.40369318744279128718e-4 + (0.12685621118898535407e-5 + (-0.12070791463315156250e-7 + (0.29105507892605823871e-10 + (0.90653314645333333334e-12 - 0.17189503312102982646e-13 * t) * t) * t) * t) * t) * t) * t; 1715 } 1716 case 68: { 1717 double t = 2*y100 - 137; 1718 return 0.45156879030168268778e0 + (-0.75983560650033817497e-2 + (-0.33045110380705139759e-4 + (0.11732956732035040896e-5 + (-0.11729986947158201869e-7 + (0.38611905704166441308e-10 + (0.68468768305777777779e-12 - 0.14549134330396754575e-13 * t) * t) * t) * t) * t) * t) * t; 1719 } 1720 case 69: { 1721 double t = 2*y100 - 139; 1722 return 0.43624909769330896904e0 + (-0.77168291040309554679e-2 + (-0.26283612321339907756e-4 + (0.10811018836893550820e-5 + (-0.11306707563739851552e-7 + (0.45670446788529607380e-10 + (0.49782492549333333334e-12 - 0.12191983967561779442e-13 * t) * t) * t) * t) * t) * t) * t; 1723 } 1724 case 70: { 1725 double t = 2*y100 - 141; 1726 return 0.42071877443548481181e0 + (-0.78093484015052730097e-2 + (-0.20064596897224934705e-4 + (0.99254806680671890766e-6 + (-0.10823412088884741451e-7 + (0.50677203326904716247e-10 + (0.34200547594666666666e-12 - 0.10112698698356194618e-13 * t) * t) * t) * t) * t) * t) * t; 1727 } 1728 case 71: { 1729 double t = 2*y100 - 143; 1730 return 0.40502758809710844280e0 + (-0.78780384460872937555e-2 + (-0.14364940764532853112e-4 + (0.90803709228265217384e-6 + (-0.10298832847014466907e-7 + (0.53981671221969478551e-10 + (0.21342751381333333333e-12 - 0.82975901848387729274e-14 * t) * t) * t) * t) * t) * t) * t; 1731 } 1732 case 72: { 1733 double t = 2*y100 - 145; 1734 return 0.38922115269731446690e0 + (-0.79249269708242064120e-2 + (-0.91595258799106970453e-5 + (0.82783535102217576495e-6 + (-0.97484311059617744437e-8 + (0.55889029041660225629e-10 + (0.10851981336888888889e-12 - 0.67278553237853459757e-14 * t) * t) * t) * t) * t) * t) * t; 1735 } 1736 case 73: { 1737 double t = 2*y100 - 147; 1738 return 0.37334112915460307335e0 + (-0.79519385109223148791e-2 + (-0.44219833548840469752e-5 + (0.75209719038240314732e-6 + (-0.91848251458553190451e-8 + (0.56663266668051433844e-10 + (0.23995894257777777778e-13 - 0.53819475285389344313e-14 * t) * t) * t) * t) * t) * t) * t; 1739 } 1740 case 74: { 1741 double t = 2*y100 - 149; 1742 return 0.35742543583374223085e0 + (-0.79608906571527956177e-2 + (-0.12530071050975781198e-6 + (0.68088605744900552505e-6 + (-0.86181844090844164075e-8 + (0.56530784203816176153e-10 + (-0.43120012248888888890e-13 - 0.42372603392496813810e-14 * t) * t) * t) * t) * t) * t) * t; 1743 } 1744 case 75: { 1745 double t = 2*y100 - 151; 1746 return 0.34150846431979618536e0 + (-0.79534924968773806029e-2 + (0.37576885610891515813e-5 + (0.61419263633090524326e-6 + (-0.80565865409945960125e-8 + (0.55684175248749269411e-10 + (-0.95486860764444444445e-13 - 0.32712946432984510595e-14 * t) * t) * t) * t) * t) * t) * t; 1747 } 1748 case 76: { 1749 double t = 2*y100 - 153; 1750 return 0.32562129649136346824e0 + (-0.79313448067948884309e-2 + (0.72539159933545300034e-5 + (0.55195028297415503083e-6 + (-0.75063365335570475258e-8 + (0.54281686749699595941e-10 - 0.13545424295111111111e-12 * t) * t) * t) * t) * t) * t; 1751 } 1752 case 77: { 1753 double t = 2*y100 - 155; 1754 return 0.30979191977078391864e0 + (-0.78959416264207333695e-2 + (0.10389774377677210794e-4 + (0.49404804463196316464e-6 + (-0.69722488229411164685e-8 + (0.52469254655951393842e-10 - 0.16507860650666666667e-12 * t) * t) * t) * t) * t) * t; 1755 } 1756 case 78: { 1757 double t = 2*y100 - 157; 1758 return 0.29404543811214459904e0 + (-0.78486728990364155356e-2 + (0.13190885683106990459e-4 + (0.44034158861387909694e-6 + (-0.64578942561562616481e-8 + (0.50354306498006928984e-10 - 0.18614473550222222222e-12 * t) * t) * t) * t) * t) * t; 1759 } 1760 case 79: { 1761 double t = 2*y100 - 159; 1762 return 0.27840427686253660515e0 + (-0.77908279176252742013e-2 + (0.15681928798708548349e-4 + (0.39066226205099807573e-6 + (-0.59658144820660420814e-8 + (0.48030086420373141763e-10 - 0.20018995173333333333e-12 * t) * t) * t) * t) * t) * t; 1763 } 1764 case 80: { 1765 double t = 2*y100 - 161; 1766 return 0.26288838011163800908e0 + (-0.77235993576119469018e-2 + (0.17886516796198660969e-4 + (0.34482457073472497720e-6 + (-0.54977066551955420066e-8 + (0.45572749379147269213e-10 - 0.20852924954666666667e-12 * t) * t) * t) * t) * t) * t; 1767 } 1768 case 81: { 1769 double t = 2*y100 - 163; 1770 return 0.24751539954181029717e0 + (-0.76480877165290370975e-2 + (0.19827114835033977049e-4 + (0.30263228619976332110e-6 + (-0.50545814570120129947e-8 + (0.43043879374212005966e-10 - 0.21228012028444444444e-12 * t) * t) * t) * t) * t) * t; 1771 } 1772 case 82: { 1773 double t = 2*y100 - 165; 1774 return 0.23230087411688914593e0 + (-0.75653060136384041587e-2 + (0.21524991113020016415e-4 + (0.26388338542539382413e-6 + (-0.46368974069671446622e-8 + (0.40492715758206515307e-10 - 0.21238627815111111111e-12 * t) * t) * t) * t) * t) * t; 1775 } 1776 case 83: { 1777 double t = 2*y100 - 167; 1778 return 0.21725840021297341931e0 + (-0.74761846305979730439e-2 + (0.23000194404129495243e-4 + (0.22837400135642906796e-6 + (-0.42446743058417541277e-8 + (0.37958104071765923728e-10 - 0.20963978568888888889e-12 * t) * t) * t) * t) * t) * t; 1779 } 1780 case 84: { 1781 double t = 2*y100 - 169; 1782 return 0.20239979200788191491e0 + (-0.73815761980493466516e-2 + (0.24271552727631854013e-4 + (0.19590154043390012843e-6 + (-0.38775884642456551753e-8 + (0.35470192372162901168e-10 - 0.20470131678222222222e-12 * t) * t) * t) * t) * t) * t; 1783 } 1784 case 85: { 1785 double t = 2*y100 - 171; 1786 return 0.18773523211558098962e0 + (-0.72822604530339834448e-2 + (0.25356688567841293697e-4 + (0.16626710297744290016e-6 + (-0.35350521468015310830e-8 + (0.33051896213898864306e-10 - 0.19811844544000000000e-12 * t) * t) * t) * t) * t) * t; 1787 } 1788 case 86: { 1789 double t = 2*y100 - 173; 1790 return 0.17327341258479649442e0 + (-0.71789490089142761950e-2 + (0.26272046822383820476e-4 + (0.13927732375657362345e-6 + (-0.32162794266956859603e-8 + (0.30720156036105652035e-10 - 0.19034196304000000000e-12 * t) * t) * t) * t) * t) * t; 1791 } 1792 case 87: { 1793 double t = 2*y100 - 175; 1794 return 0.15902166648328672043e0 + (-0.70722899934245504034e-2 + (0.27032932310132226025e-4 + (0.11474573347816568279e-6 + (-0.29203404091754665063e-8 + (0.28487010262547971859e-10 - 0.18174029063111111111e-12 * t) * t) * t) * t) * t) * t; 1795 } 1796 case 88: { 1797 double t = 2*y100 - 177; 1798 return 0.14498609036610283865e0 + (-0.69628725220045029273e-2 + (0.27653554229160596221e-4 + (0.92493727167393036470e-7 + (-0.26462055548683583849e-8 + (0.26360506250989943739e-10 - 0.17261211260444444444e-12 * t) * t) * t) * t) * t) * t; 1799 } 1800 case 89: { 1801 double t = 2*y100 - 179; 1802 return 0.13117165798208050667e0 + (-0.68512309830281084723e-2 + (0.28147075431133863774e-4 + (0.72351212437979583441e-7 + (-0.23927816200314358570e-8 + (0.24345469651209833155e-10 - 0.16319736960000000000e-12 * t) * t) * t) * t) * t) * t; 1803 } 1804 case 90: { 1805 double t = 2*y100 - 181; 1806 return 0.11758232561160626306e0 + (-0.67378491192463392927e-2 + (0.28525664781722907847e-4 + (0.54156999310046790024e-7 + (-0.21589405340123827823e-8 + (0.22444150951727334619e-10 - 0.15368675584000000000e-12 * t) * t) * t) * t) * t) * t; 1807 } 1808 case 91: { 1809 double t = 2*y100 - 183; 1810 return 0.10422112945361673560e0 + (-0.66231638959845581564e-2 + (0.28800551216363918088e-4 + (0.37758983397952149613e-7 + (-0.19435423557038933431e-8 + (0.20656766125421362458e-10 - 0.14422990012444444444e-12 * t) * t) * t) * t) * t) * t; 1811 } 1812 case 92: { 1813 double t = 2*y100 - 185; 1814 return 0.91090275493541084785e-1 + (-0.65075691516115160062e-2 + (0.28982078385527224867e-4 + (0.23014165807643012781e-7 + (-0.17454532910249875958e-8 + (0.18981946442680092373e-10 - 0.13494234691555555556e-12 * t) * t) * t) * t) * t) * t; 1815 } 1816 case 93: { 1817 double t = 2*y100 - 187; 1818 return 0.78191222288771379358e-1 + (-0.63914190297303976434e-2 + (0.29079759021299682675e-4 + (0.97885458059415717014e-8 + (-0.15635596116134296819e-8 + (0.17417110744051331974e-10 - 0.12591151763555555556e-12 * t) * t) * t) * t) * t) * t; 1819 } 1820 case 94: { 1821 double t = 2*y100 - 189; 1822 return 0.65524757106147402224e-1 + (-0.62750311956082444159e-2 + (0.29102328354323449795e-4 + (-0.20430838882727954582e-8 + (-0.13967781903855367270e-8 + (0.15958771833747057569e-10 - 0.11720175765333333333e-12 * t) * t) * t) * t) * t) * t; 1823 } 1824 case 95: { 1825 double t = 2*y100 - 191; 1826 return 0.53091065838453612773e-1 + (-0.61586898417077043662e-2 + (0.29057796072960100710e-4 + (-0.12597414620517987536e-7 + (-0.12440642607426861943e-8 + (0.14602787128447932137e-10 - 0.10885859114666666667e-12 * t) * t) * t) * t) * t) * t; 1827 } 1828 case 96: { 1829 double t = 2*y100 - 193; 1830 return 0.40889797115352738582e-1 + (-0.60426484889413678200e-2 + (0.28953496450191694606e-4 + (-0.21982952021823718400e-7 + (-0.11044169117553026211e-8 + (0.13344562332430552171e-10 - 0.10091231402844444444e-12 * t) * t) * t) * t) * t) * t; 1831 } 1832 case 97: case 98: 1833 case 99: case 100: { // use Taylor expansion for small x (|x| <= 0.0309...) 1834 // (2/sqrt(pi)) * (x - 2/3 x^3 + 4/15 x^5 - 8/105 x^7 + 16/945 x^9) 1835 double x2 = x*x; 1836 return x * (1.1283791670955125739 1837 - x2 * (0.75225277806367504925 1838 - x2 * (0.30090111122547001970 1839 - x2 * (0.085971746064420005629 1840 - x2 * 0.016931216931216931217)))); 1841 } 1842 } 1843 /* Since 0 <= y100 < 101, this is only reached if x is NaN, 1844 in which case we should return NaN. */ 1845 return NaN; 1846 } 1847 1848 double FADDEEVA(w_im)(double x) 1849 { 1850 if (x >= 0) { 1851 if (x > 45) { // continued-fraction expansion is faster 1852 const double ispi = 0.56418958354775628694807945156; // 1 / sqrt(pi) 1853 if (x > 5e7) // 1-term expansion, important to avoid overflow 1854 return ispi / x; 1855 /* 5-term expansion (rely on compiler for CSE), simplified from: 1856 ispi / (x-0.5/(x-1/(x-1.5/(x-2/x)))) */ 1857 return ispi*((x*x) * (x*x-4.5) + 2) / (x * ((x*x) * (x*x-5) + 3.75)); 1858 } 1859 return w_im_y100(100/(1+x), x); 1860 } 1861 else { // = -FADDEEVA(w_im)(-x) 1862 if (x < -45) { // continued-fraction expansion is faster 1863 const double ispi = 0.56418958354775628694807945156; // 1 / sqrt(pi) 1864 if (x < -5e7) // 1-term expansion, important to avoid overflow 1865 return ispi / x; 1866 /* 5-term expansion (rely on compiler for CSE), simplified from: 1867 ispi / (x-0.5/(x-1/(x-1.5/(x-2/x)))) */ 1868 return ispi*((x*x) * (x*x-4.5) + 2) / (x * ((x*x) * (x*x-5) + 3.75)); 1869 } 1870 return -w_im_y100(100/(1-x), -x); 1871 } 1872 } 1873 1874 ///////////////////////////////////////////////////////////////////////// 1875 1876 // Compile with -DTEST_FADDEEVA to compile a little test program 1877 #ifdef TEST_FADDEEVA 1878 1879 #ifdef __cplusplus 1880 # include <cstdio> 1881 #else 1882 # include <stdio.h> 1883 #endif 1884 1885 // compute relative error |b-a|/|a|, handling case of NaN and Inf, 1886 static double relerr(double a, double b) { 1887 if (isnan(a) || isnan(b) || isinf(a) || isinf(b)) { 1888 if ((isnan(a) && !isnan(b)) || (!isnan(a) && isnan(b)) || 1889 (isinf(a) && !isinf(b)) || (!isinf(a) && isinf(b)) || 1890 (isinf(a) && isinf(b) && a*b < 0)) 1891 return Inf; // "infinite" error 1892 return 0; // matching infinity/nan results counted as zero error 1893 } 1894 if (a == 0) 1895 return b == 0 ? 0 : Inf; 1896 else 1897 return fabs((b-a) / a); 1898 } 1899 1900 int main(void) { 1901 double errmax_all = 0; 1902 { 1903 printf("############# w(z) tests #############\n"); 1904 #define NTST 57 // define instead of const for C compatibility 1905 cmplx z[NTST] = { 1906 C(624.2,-0.26123), 1907 C(-0.4,3.), 1908 C(0.6,2.), 1909 C(-1.,1.), 1910 C(-1.,-9.), 1911 C(-1.,9.), 1912 C(-0.0000000234545,1.1234), 1913 C(-3.,5.1), 1914 C(-53,30.1), 1915 C(0.0,0.12345), 1916 C(11,1), 1917 C(-22,-2), 1918 C(9,-28), 1919 C(21,-33), 1920 C(1e5,1e5), 1921 C(1e14,1e14), 1922 C(-3001,-1000), 1923 C(1e160,-1e159), 1924 C(-6.01,0.01), 1925 C(-0.7,-0.7), 1926 C(2.611780000000000e+01, 4.540909610972489e+03), 1927 C(0.8e7,0.3e7), 1928 C(-20,-19.8081), 1929 C(1e-16,-1.1e-16), 1930 C(2.3e-8,1.3e-8), 1931 C(6.3,-1e-13), 1932 C(6.3,1e-20), 1933 C(1e-20,6.3), 1934 C(1e-20,16.3), 1935 C(9,1e-300), 1936 C(6.01,0.11), 1937 C(8.01,1.01e-10), 1938 C(28.01,1e-300), 1939 C(10.01,1e-200), 1940 C(10.01,-1e-200), 1941 C(10.01,0.99e-10), 1942 C(10.01,-0.99e-10), 1943 C(1e-20,7.01), 1944 C(-1,7.01), 1945 C(5.99,7.01), 1946 C(1,0), 1947 C(55,0), 1948 C(-0.1,0), 1949 C(1e-20,0), 1950 C(0,5e-14), 1951 C(0,51), 1952 C(Inf,0), 1953 C(-Inf,0), 1954 C(0,Inf), 1955 C(0,-Inf), 1956 C(Inf,Inf), 1957 C(Inf,-Inf), 1958 C(NaN,NaN), 1959 C(NaN,0), 1960 C(0,NaN), 1961 C(NaN,Inf), 1962 C(Inf,NaN) 1963 }; 1964 cmplx w[NTST] = { /* w(z), computed with WolframAlpha 1965 ... note that WolframAlpha is problematic 1966 some of the above inputs, so I had to 1967 use the continued-fraction expansion 1968 in WolframAlpha in some cases, or switch 1969 to Maple */ 1970 C(-3.78270245518980507452677445620103199303131110e-7, 1971 0.000903861276433172057331093754199933411710053155), 1972 C(0.1764906227004816847297495349730234591778719532788, 1973 -0.02146550539468457616788719893991501311573031095617), 1974 C(0.2410250715772692146133539023007113781272362309451, 1975 0.06087579663428089745895459735240964093522265589350), 1976 C(0.30474420525691259245713884106959496013413834051768, 1977 -0.20821893820283162728743734725471561394145872072738), 1978 C(7.317131068972378096865595229600561710140617977e34, 1979 8.321873499714402777186848353320412813066170427e34), 1980 C(0.0615698507236323685519612934241429530190806818395, 1981 -0.00676005783716575013073036218018565206070072304635), 1982 C(0.3960793007699874918961319170187598400134746631, 1983 -5.593152259116644920546186222529802777409274656e-9), 1984 C(0.08217199226739447943295069917990417630675021771804, 1985 -0.04701291087643609891018366143118110965272615832184), 1986 C(0.00457246000350281640952328010227885008541748668738, 1987 -0.00804900791411691821818731763401840373998654987934), 1988 C(0.8746342859608052666092782112565360755791467973338452, 1989 0.), 1990 C(0.00468190164965444174367477874864366058339647648741, 1991 0.0510735563901306197993676329845149741675029197050), 1992 C(-0.0023193175200187620902125853834909543869428763219, 1993 -0.025460054739731556004902057663500272721780776336), 1994 C(9.11463368405637174660562096516414499772662584e304, 1995 3.97101807145263333769664875189354358563218932e305), 1996 C(-4.4927207857715598976165541011143706155432296e281, 1997 -2.8019591213423077494444700357168707775769028e281), 1998 C(2.820947917809305132678577516325951485807107151e-6, 1999 2.820947917668257736791638444590253942253354058e-6), 2000 C(2.82094791773878143474039725787438662716372268e-15, 2001 2.82094791773878143474039725773333923127678361e-15), 2002 C(-0.0000563851289696244350147899376081488003110150498, 2003 -0.000169211755126812174631861529808288295454992688), 2004 C(-5.586035480670854326218608431294778077663867e-162, 2005 5.586035480670854326218608431294778077663867e-161), 2006 C(0.00016318325137140451888255634399123461580248456, 2007 -0.095232456573009287370728788146686162555021209999), 2008 C(0.69504753678406939989115375989939096800793577783885, 2009 -1.8916411171103639136680830887017670616339912024317), 2010 C(0.0001242418269653279656612334210746733213167234822, 2011 7.145975826320186888508563111992099992116786763e-7), 2012 C(2.318587329648353318615800865959225429377529825e-8, 2013 6.182899545728857485721417893323317843200933380e-8), 2014 C(-0.0133426877243506022053521927604277115767311800303, 2015 -0.0148087097143220769493341484176979826888871576145), 2016 C(1.00000000000000012412170838050638522857747934, 2017 1.12837916709551279389615890312156495593616433e-16), 2018 C(0.9999999853310704677583504063775310832036830015, 2019 2.595272024519678881897196435157270184030360773e-8), 2020 C(-1.4731421795638279504242963027196663601154624e-15, 2021 0.090727659684127365236479098488823462473074709), 2022 C(5.79246077884410284575834156425396800754409308e-18, 2023 0.0907276596841273652364790985059772809093822374), 2024 C(0.0884658993528521953466533278764830881245144368, 2025 1.37088352495749125283269718778582613192166760e-22), 2026 C(0.0345480845419190424370085249304184266813447878, 2027 2.11161102895179044968099038990446187626075258e-23), 2028 C(6.63967719958073440070225527042829242391918213e-36, 2029 0.0630820900592582863713653132559743161572639353), 2030 C(0.00179435233208702644891092397579091030658500743634, 2031 0.0951983814805270647939647438459699953990788064762), 2032 C(9.09760377102097999924241322094863528771095448e-13, 2033 0.0709979210725138550986782242355007611074966717), 2034 C(7.2049510279742166460047102593255688682910274423e-304, 2035 0.0201552956479526953866611812593266285000876784321), 2036 C(3.04543604652250734193622967873276113872279682e-44, 2037 0.0566481651760675042930042117726713294607499165), 2038 C(3.04543604652250734193622967873276113872279682e-44, 2039 0.0566481651760675042930042117726713294607499165), 2040 C(0.5659928732065273429286988428080855057102069081e-12, 2041 0.056648165176067504292998527162143030538756683302), 2042 C(-0.56599287320652734292869884280802459698927645e-12, 2043 0.0566481651760675042929985271621430305387566833029), 2044 C(0.0796884251721652215687859778119964009569455462, 2045 1.11474461817561675017794941973556302717225126e-22), 2046 C(0.07817195821247357458545539935996687005781943386550, 2047 -0.01093913670103576690766705513142246633056714279654), 2048 C(0.04670032980990449912809326141164730850466208439937, 2049 0.03944038961933534137558064191650437353429669886545), 2050 C(0.36787944117144232159552377016146086744581113103176, 2051 0.60715770584139372911503823580074492116122092866515), 2052 C(0, 2053 0.010259688805536830986089913987516716056946786526145), 2054 C(0.99004983374916805357390597718003655777207908125383, 2055 -0.11208866436449538036721343053869621153527769495574), 2056 C(0.99999999999999999999999999999999999999990000, 2057 1.12837916709551257389615890312154517168802603e-20), 2058 C(0.999999999999943581041645226871305192054749891144158, 2059 0), 2060 C(0.0110604154853277201542582159216317923453996211744250, 2061 0), 2062 C(0,0), 2063 C(0,0), 2064 C(0,0), 2065 C(Inf,0), 2066 C(0,0), 2067 C(NaN,NaN), 2068 C(NaN,NaN), 2069 C(NaN,NaN), 2070 C(NaN,0), 2071 C(NaN,NaN), 2072 C(NaN,NaN) 2073 }; 2074 double errmax = 0; 2075 for (int i = 0; i < NTST; ++i) { 2076 cmplx fw = FADDEEVA(w)(z[i],0.); 2077 double re_err = relerr(creal(w[i]), creal(fw)); 2078 double im_err = relerr(cimag(w[i]), cimag(fw)); 2079 printf("w(%g%+gi) = %g%+gi (vs. %g%+gi), re/im rel. err. = %0.2g/%0.2g)\n", 2080 creal(z[i]),cimag(z[i]), creal(fw),cimag(fw), creal(w[i]),cimag(w[i]), 2081 re_err, im_err); 2082 if (re_err > errmax) errmax = re_err; 2083 if (im_err > errmax) errmax = im_err; 2084 } 2085 if (errmax > 1e-13) { 2086 printf("FAILURE -- relative error %g too large!\n", errmax); 2087 return 1; 2088 } 2089 printf("SUCCESS (max relative error = %g)\n", errmax); 2090 if (errmax > errmax_all) errmax_all = errmax; 2091 } 2092 { 2093 #undef NTST 2094 #define NTST 41 // define instead of const for C compatibility 2095 cmplx z[NTST] = { 2096 C(1,2), 2097 C(-1,2), 2098 C(1,-2), 2099 C(-1,-2), 2100 C(9,-28), 2101 C(21,-33), 2102 C(1e3,1e3), 2103 C(-3001,-1000), 2104 C(1e160,-1e159), 2105 C(5.1e-3, 1e-8), 2106 C(-4.9e-3, 4.95e-3), 2107 C(4.9e-3, 0.5), 2108 C(4.9e-4, -0.5e1), 2109 C(-4.9e-5, -0.5e2), 2110 C(5.1e-3, 0.5), 2111 C(5.1e-4, -0.5e1), 2112 C(-5.1e-5, -0.5e2), 2113 C(1e-6,2e-6), 2114 C(0,2e-6), 2115 C(0,2), 2116 C(0,20), 2117 C(0,200), 2118 C(Inf,0), 2119 C(-Inf,0), 2120 C(0,Inf), 2121 C(0,-Inf), 2122 C(Inf,Inf), 2123 C(Inf,-Inf), 2124 C(NaN,NaN), 2125 C(NaN,0), 2126 C(0,NaN), 2127 C(NaN,Inf), 2128 C(Inf,NaN), 2129 C(1e-3,NaN), 2130 C(7e-2,7e-2), 2131 C(7e-2,-7e-4), 2132 C(-9e-2,7e-4), 2133 C(-9e-2,9e-2), 2134 C(-7e-4,9e-2), 2135 C(7e-2,0.9e-2), 2136 C(7e-2,1.1e-2) 2137 }; 2138 cmplx w[NTST] = { // erf(z[i]), evaluated with Maple 2139 C(-0.5366435657785650339917955593141927494421, 2140 -5.049143703447034669543036958614140565553), 2141 C(0.5366435657785650339917955593141927494421, 2142 -5.049143703447034669543036958614140565553), 2143 C(-0.5366435657785650339917955593141927494421, 2144 5.049143703447034669543036958614140565553), 2145 C(0.5366435657785650339917955593141927494421, 2146 5.049143703447034669543036958614140565553), 2147 C(0.3359473673830576996788000505817956637777e304, 2148 -0.1999896139679880888755589794455069208455e304), 2149 C(0.3584459971462946066523939204836760283645e278, 2150 0.3818954885257184373734213077678011282505e280), 2151 C(0.9996020422657148639102150147542224526887, 2152 0.00002801044116908227889681753993542916894856), 2153 C(-1, 0), 2154 C(1, 0), 2155 C(0.005754683859034800134412990541076554934877, 2156 0.1128349818335058741511924929801267822634e-7), 2157 C(-0.005529149142341821193633460286828381876955, 2158 0.005585388387864706679609092447916333443570), 2159 C(0.007099365669981359632319829148438283865814, 2160 0.6149347012854211635026981277569074001219), 2161 C(0.3981176338702323417718189922039863062440e8, 2162 -0.8298176341665249121085423917575122140650e10), 2163 C(-Inf, 2164 -Inf), 2165 C(0.007389128308257135427153919483147229573895, 2166 0.6149332524601658796226417164791221815139), 2167 C(0.4143671923267934479245651547534414976991e8, 2168 -0.8298168216818314211557046346850921446950e10), 2169 C(-Inf, 2170 -Inf), 2171 C(0.1128379167099649964175513742247082845155e-5, 2172 0.2256758334191777400570377193451519478895e-5), 2173 C(0, 2174 0.2256758334194034158904576117253481476197e-5), 2175 C(0, 2176 18.56480241457555259870429191324101719886), 2177 C(0, 2178 0.1474797539628786202447733153131835124599e173), 2179 C(0, 2180 Inf), 2181 C(1,0), 2182 C(-1,0), 2183 C(0,Inf), 2184 C(0,-Inf), 2185 C(NaN,NaN), 2186 C(NaN,NaN), 2187 C(NaN,NaN), 2188 C(NaN,0), 2189 C(0,NaN), 2190 C(NaN,NaN), 2191 C(NaN,NaN), 2192 C(NaN,NaN), 2193 C(0.07924380404615782687930591956705225541145, 2194 0.07872776218046681145537914954027729115247), 2195 C(0.07885775828512276968931773651224684454495, 2196 -0.0007860046704118224342390725280161272277506), 2197 C(-0.1012806432747198859687963080684978759881, 2198 0.0007834934747022035607566216654982820299469), 2199 C(-0.1020998418798097910247132140051062512527, 2200 0.1010030778892310851309082083238896270340), 2201 C(-0.0007962891763147907785684591823889484764272, 2202 0.1018289385936278171741809237435404896152), 2203 C(0.07886408666470478681566329888615410479530, 2204 0.01010604288780868961492224347707949372245), 2205 C(0.07886723099940260286824654364807981336591, 2206 0.01235199327873258197931147306290916629654) 2207 }; 2208 #define TST(f,isc) \ 2209 printf("############# " #f "(z) tests #############\n"); \ 2210 double errmax = 0; \ 2211 for (int i = 0; i < NTST; ++i) { \ 2212 cmplx fw = FADDEEVA(f)(z[i],0.); \ 2213 double re_err = relerr(creal(w[i]), creal(fw)); \ 2214 double im_err = relerr(cimag(w[i]), cimag(fw)); \ 2215 printf(#f "(%g%+gi) = %g%+gi (vs. %g%+gi), re/im rel. err. = %0.2g/%0.2g)\n", \ 2216 creal(z[i]),cimag(z[i]), creal(fw),cimag(fw), creal(w[i]),cimag(w[i]), \ 2217 re_err, im_err); \ 2218 if (re_err > errmax) errmax = re_err; \ 2219 if (im_err > errmax) errmax = im_err; \ 2220 } \ 2221 if (errmax > 1e-13) { \ 2222 printf("FAILURE -- relative error %g too large!\n", errmax); \ 2223 return 1; \ 2224 } \ 2225 printf("Checking " #f "(x) special case...\n"); \ 2226 for (int i = 0; i < 10000; ++i) { \ 2227 double x = pow(10., -300. + i * 600. / (10000 - 1)); \ 2228 double re_err = relerr(FADDEEVA_RE(f)(x), \ 2229 creal(FADDEEVA(f)(C(x,x*isc),0.))); \ 2230 if (re_err > errmax) errmax = re_err; \ 2231 re_err = relerr(FADDEEVA_RE(f)(-x), \ 2232 creal(FADDEEVA(f)(C(-x,x*isc),0.))); \ 2233 if (re_err > errmax) errmax = re_err; \ 2234 } \ 2235 { \ 2236 double re_err = relerr(FADDEEVA_RE(f)(Inf), \ 2237 creal(FADDEEVA(f)(C(Inf,0.),0.))); \ 2238 if (re_err > errmax) errmax = re_err; \ 2239 re_err = relerr(FADDEEVA_RE(f)(-Inf), \ 2240 creal(FADDEEVA(f)(C(-Inf,0.),0.))); \ 2241 if (re_err > errmax) errmax = re_err; \ 2242 re_err = relerr(FADDEEVA_RE(f)(NaN), \ 2243 creal(FADDEEVA(f)(C(NaN,0.),0.))); \ 2244 if (re_err > errmax) errmax = re_err; \ 2245 } \ 2246 if (errmax > 1e-13) { \ 2247 printf("FAILURE -- relative error %g too large!\n", errmax); \ 2248 return 1; \ 2249 } \ 2250 printf("SUCCESS (max relative error = %g)\n", errmax); \ 2251 if (errmax > errmax_all) errmax_all = errmax 2252 2253 TST(erf, 1e-20); 2254 } 2255 { 2256 // since erfi just calls through to erf, just one test should 2257 // be sufficient to make sure I didn't screw up the signs or something 2258 #undef NTST 2259 #define NTST 1 // define instead of const for C compatibility 2260 cmplx z[NTST] = { C(1.234,0.5678) }; 2261 cmplx w[NTST] = { // erfi(z[i]), computed with Maple 2262 C(1.081032284405373149432716643834106923212, 2263 1.926775520840916645838949402886591180834) 2264 }; 2265 TST(erfi, 0); 2266 } 2267 { 2268 // since erfcx just calls through to w, just one test should 2269 // be sufficient to make sure I didn't screw up the signs or something 2270 #undef NTST 2271 #define NTST 1 // define instead of const for C compatibility 2272 cmplx z[NTST] = { C(1.234,0.5678) }; 2273 cmplx w[NTST] = { // erfcx(z[i]), computed with Maple 2274 C(0.3382187479799972294747793561190487832579, 2275 -0.1116077470811648467464927471872945833154) 2276 }; 2277 TST(erfcx, 0); 2278 } 2279 { 2280 #undef NTST 2281 #define NTST 30 // define instead of const for C compatibility 2282 cmplx z[NTST] = { 2283 C(1,2), 2284 C(-1,2), 2285 C(1,-2), 2286 C(-1,-2), 2287 C(9,-28), 2288 C(21,-33), 2289 C(1e3,1e3), 2290 C(-3001,-1000), 2291 C(1e160,-1e159), 2292 C(5.1e-3, 1e-8), 2293 C(0,2e-6), 2294 C(0,2), 2295 C(0,20), 2296 C(0,200), 2297 C(2e-6,0), 2298 C(2,0), 2299 C(20,0), 2300 C(200,0), 2301 C(Inf,0), 2302 C(-Inf,0), 2303 C(0,Inf), 2304 C(0,-Inf), 2305 C(Inf,Inf), 2306 C(Inf,-Inf), 2307 C(NaN,NaN), 2308 C(NaN,0), 2309 C(0,NaN), 2310 C(NaN,Inf), 2311 C(Inf,NaN), 2312 C(88,0) 2313 }; 2314 cmplx w[NTST] = { // erfc(z[i]), evaluated with Maple 2315 C(1.536643565778565033991795559314192749442, 2316 5.049143703447034669543036958614140565553), 2317 C(0.4633564342214349660082044406858072505579, 2318 5.049143703447034669543036958614140565553), 2319 C(1.536643565778565033991795559314192749442, 2320 -5.049143703447034669543036958614140565553), 2321 C(0.4633564342214349660082044406858072505579, 2322 -5.049143703447034669543036958614140565553), 2323 C(-0.3359473673830576996788000505817956637777e304, 2324 0.1999896139679880888755589794455069208455e304), 2325 C(-0.3584459971462946066523939204836760283645e278, 2326 -0.3818954885257184373734213077678011282505e280), 2327 C(0.0003979577342851360897849852457775473112748, 2328 -0.00002801044116908227889681753993542916894856), 2329 C(2, 0), 2330 C(0, 0), 2331 C(0.9942453161409651998655870094589234450651, 2332 -0.1128349818335058741511924929801267822634e-7), 2333 C(1, 2334 -0.2256758334194034158904576117253481476197e-5), 2335 C(1, 2336 -18.56480241457555259870429191324101719886), 2337 C(1, 2338 -0.1474797539628786202447733153131835124599e173), 2339 C(1, -Inf), 2340 C(0.9999977432416658119838633199332831406314, 2341 0), 2342 C(0.004677734981047265837930743632747071389108, 2343 0), 2344 C(0.5395865611607900928934999167905345604088e-175, 2345 0), 2346 C(0, 0), 2347 C(0, 0), 2348 C(2, 0), 2349 C(1, -Inf), 2350 C(1, Inf), 2351 C(NaN, NaN), 2352 C(NaN, NaN), 2353 C(NaN, NaN), 2354 C(NaN, 0), 2355 C(1, NaN), 2356 C(NaN, NaN), 2357 C(NaN, NaN), 2358 C(0,0) 2359 }; 2360 TST(erfc, 1e-20); 2361 } 2362 { 2363 #undef NTST 2364 #define NTST 48 // define instead of const for C compatibility 2365 cmplx z[NTST] = { 2366 C(2,1), 2367 C(-2,1), 2368 C(2,-1), 2369 C(-2,-1), 2370 C(-28,9), 2371 C(33,-21), 2372 C(1e3,1e3), 2373 C(-1000,-3001), 2374 C(1e-8, 5.1e-3), 2375 C(4.95e-3, -4.9e-3), 2376 C(5.1e-3, 5.1e-3), 2377 C(0.5, 4.9e-3), 2378 C(-0.5e1, 4.9e-4), 2379 C(-0.5e2, -4.9e-5), 2380 C(0.5e3, 4.9e-6), 2381 C(0.5, 5.1e-3), 2382 C(-0.5e1, 5.1e-4), 2383 C(-0.5e2, -5.1e-5), 2384 C(1e-6,2e-6), 2385 C(2e-6,0), 2386 C(2,0), 2387 C(20,0), 2388 C(200,0), 2389 C(0,4.9e-3), 2390 C(0,-5.1e-3), 2391 C(0,2e-6), 2392 C(0,-2), 2393 C(0,20), 2394 C(0,-200), 2395 C(Inf,0), 2396 C(-Inf,0), 2397 C(0,Inf), 2398 C(0,-Inf), 2399 C(Inf,Inf), 2400 C(Inf,-Inf), 2401 C(NaN,NaN), 2402 C(NaN,0), 2403 C(0,NaN), 2404 C(NaN,Inf), 2405 C(Inf,NaN), 2406 C(39, 6.4e-5), 2407 C(41, 6.09e-5), 2408 C(4.9e7, 5e-11), 2409 C(5.1e7, 4.8e-11), 2410 C(1e9, 2.4e-12), 2411 C(1e11, 2.4e-14), 2412 C(1e13, 2.4e-16), 2413 C(1e300, 2.4e-303) 2414 }; 2415 cmplx w[NTST] = { // dawson(z[i]), evaluated with Maple 2416 C(0.1635394094345355614904345232875688576839, 2417 -0.1531245755371229803585918112683241066853), 2418 C(-0.1635394094345355614904345232875688576839, 2419 -0.1531245755371229803585918112683241066853), 2420 C(0.1635394094345355614904345232875688576839, 2421 0.1531245755371229803585918112683241066853), 2422 C(-0.1635394094345355614904345232875688576839, 2423 0.1531245755371229803585918112683241066853), 2424 C(-0.01619082256681596362895875232699626384420, 2425 -0.005210224203359059109181555401330902819419), 2426 C(0.01078377080978103125464543240346760257008, 2427 0.006866888783433775382193630944275682670599), 2428 C(-0.5808616819196736225612296471081337245459, 2429 0.6688593905505562263387760667171706325749), 2430 C(Inf, 2431 -Inf), 2432 C(0.1000052020902036118082966385855563526705e-7, 2433 0.005100088434920073153418834680320146441685), 2434 C(0.004950156837581592745389973960217444687524, 2435 -0.004899838305155226382584756154100963570500), 2436 C(0.005100176864319675957314822982399286703798, 2437 0.005099823128319785355949825238269336481254), 2438 C(0.4244534840871830045021143490355372016428, 2439 0.002820278933186814021399602648373095266538), 2440 C(-0.1021340733271046543881236523269967674156, 2441 -0.00001045696456072005761498961861088944159916), 2442 C(-0.01000200120119206748855061636187197886859, 2443 0.9805885888237419500266621041508714123763e-8), 2444 C(0.001000002000012000023960527532953151819595, 2445 -0.9800058800588007290937355024646722133204e-11), 2446 C(0.4244549085628511778373438768121222815752, 2447 0.002935393851311701428647152230552122898291), 2448 C(-0.1021340732357117208743299813648493928105, 2449 -0.00001088377943049851799938998805451564893540), 2450 C(-0.01000200120119126652710792390331206563616, 2451 0.1020612612857282306892368985525393707486e-7), 2452 C(0.1000000000007333333333344266666666664457e-5, 2453 0.2000000000001333333333323199999999978819e-5), 2454 C(0.1999999999994666666666675199999999990248e-5, 2455 0), 2456 C(0.3013403889237919660346644392864226952119, 2457 0), 2458 C(0.02503136792640367194699495234782353186858, 2459 0), 2460 C(0.002500031251171948248596912483183760683918, 2461 0), 2462 C(0,0.004900078433419939164774792850907128053308), 2463 C(0,-0.005100088434920074173454208832365950009419), 2464 C(0,0.2000000000005333333333341866666666676419e-5), 2465 C(0,-48.16001211429122974789822893525016528191), 2466 C(0,0.4627407029504443513654142715903005954668e174), 2467 C(0,-Inf), 2468 C(0,0), 2469 C(-0,0), 2470 C(0, Inf), 2471 C(0, -Inf), 2472 C(NaN, NaN), 2473 C(NaN, NaN), 2474 C(NaN, NaN), 2475 C(NaN, 0), 2476 C(0, NaN), 2477 C(NaN, NaN), 2478 C(NaN, NaN), 2479 C(0.01282473148489433743567240624939698290584, 2480 -0.2105957276516618621447832572909153498104e-7), 2481 C(0.01219875253423634378984109995893708152885, 2482 -0.1813040560401824664088425926165834355953e-7), 2483 C(0.1020408163265306334945473399689037886997e-7, 2484 -0.1041232819658476285651490827866174985330e-25), 2485 C(0.9803921568627452865036825956835185367356e-8, 2486 -0.9227220299884665067601095648451913375754e-26), 2487 C(0.5000000000000000002500000000000000003750e-9, 2488 -0.1200000000000000001800000188712838420241e-29), 2489 C(5.00000000000000000000025000000000000000000003e-12, 2490 -1.20000000000000000000018000000000000000000004e-36), 2491 C(5.00000000000000000000000002500000000000000000e-14, 2492 -1.20000000000000000000000001800000000000000000e-42), 2493 C(5e-301, 0) 2494 }; 2495 TST(Dawson, 1e-20); 2496 } 2497 printf("#####################################\n"); 2498 printf("SUCCESS (max relative error = %g)\n", errmax_all); 2499 } 2500 2501 #endif