Debian Codegraph @

third-party/boost-math/include/boost/math/special_functions/erf.hpp

raw
1 // (C) Copyright John Maddock 2006.
2 // (C) Copyright Matt Borland 2024.
3 // Use, modification and distribution are subject to the
4 // Boost Software License, Version 1.0. (See accompanying file
5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6
7 #ifndef BOOST_MATH_SPECIAL_ERF_HPP
8 #define BOOST_MATH_SPECIAL_ERF_HPP
9
10 #ifdef _MSC_VER
11 #pragma once
12 #endif
13
14 #include <boost/math/tools/config.hpp>
15
16 #ifndef BOOST_MATH_HAS_NVRTC
17
18 #include <boost/math/special_functions/math_fwd.hpp>
19 #include <boost/math/special_functions/gamma.hpp>
20 #include <boost/math/tools/roots.hpp>
21 #include <boost/math/policies/error_handling.hpp>
22 #include <boost/math/tools/big_constant.hpp>
23
24 #if defined(__GNUC__) && defined(BOOST_MATH_USE_FLOAT128)
25 //
26 // This is the only way we can avoid
27 // warning: non-standard suffix on floating constant [-Wpedantic]
28 // when building with -Wall -pedantic. Neither __extension__
29 // nor #pragma diagnostic ignored work :(
30 //
31 #pragma GCC system_header
32 #endif
33
34 namespace boost{ namespace math{
35
36 namespace detail
37 {
38
39 //
40 // Asymptotic series for large z:
41 //
42 template <class T>
43 struct erf_asympt_series_t
44 {
45 // LCOV_EXCL_START multiprecision case only, excluded from coverage analysis
46 BOOST_MATH_GPU_ENABLED erf_asympt_series_t(T z) : xx(2 * -z * z), tk(1)
47 {
48 BOOST_MATH_STD_USING
49 result = -exp(-z * z) / sqrt(boost::math::constants::pi<T>());
50 result /= z;
51 }
52
53 typedef T result_type;
54
55 BOOST_MATH_GPU_ENABLED T operator()()
56 {
57 BOOST_MATH_STD_USING
58 T r = result;
59 result *= tk / xx;
60 tk += 2;
61 if( fabs(r) < fabs(result))
62 result = 0;
63 return r;
64 }
65 // LCOV_EXCL_STOP
66 private:
67 T result;
68 T xx;
69 int tk;
70 };
71 //
72 // How large z has to be in order to ensure that the series converges:
73 //
74 template <class T>
75 BOOST_MATH_GPU_ENABLED inline float erf_asymptotic_limit_N(const T&)
76 {
77 return (std::numeric_limits<float>::max)();
78 }
79 BOOST_MATH_GPU_ENABLED inline float erf_asymptotic_limit_N(const std::integral_constant<int, 24>&)
80 {
81 return 2.8F;
82 }
83 BOOST_MATH_GPU_ENABLED inline float erf_asymptotic_limit_N(const std::integral_constant<int, 53>&)
84 {
85 return 4.3F;
86 }
87 BOOST_MATH_GPU_ENABLED inline float erf_asymptotic_limit_N(const std::integral_constant<int, 64>&)
88 {
89 return 4.8F;
90 }
91 BOOST_MATH_GPU_ENABLED inline float erf_asymptotic_limit_N(const std::integral_constant<int, 106>&)
92 {
93 return 6.5F;
94 }
95 BOOST_MATH_GPU_ENABLED inline float erf_asymptotic_limit_N(const std::integral_constant<int, 113>&)
96 {
97 return 6.8F;
98 }
99
100 template <class T, class Policy>
101 BOOST_MATH_GPU_ENABLED inline T erf_asymptotic_limit()
102 {
103 typedef typename policies::precision<T, Policy>::type precision_type;
104 typedef std::integral_constant<int,
105 precision_type::value <= 0 ? 0 :
106 precision_type::value <= 24 ? 24 :
107 precision_type::value <= 53 ? 53 :
108 precision_type::value <= 64 ? 64 :
109 precision_type::value <= 113 ? 113 : 0
110 > tag_type;
111 return erf_asymptotic_limit_N(tag_type());
112 }
113
114 // LCOV_EXCL_START multiprecision case only, excluded from coverage analysis
115 template <class T>
116 struct erf_series_near_zero
117 {
118 typedef T result_type;
119 T term;
120 T zz;
121 int k;
122 erf_series_near_zero(const T& z) : term(z), zz(-z * z), k(0) {}
123
124 T operator()()
125 {
126 T result = term / (2 * k + 1);
127 term *= zz / ++k;
128 return result;
129 }
130 };
131
132 template <class T, class Policy>
133 T erf_series_near_zero_sum(const T& x, const Policy& pol)
134 {
135 //
136 // We need Kahan summation here, otherwise the errors grow fairly quickly.
137 // This method is *much* faster than the alternatives even so.
138 //
139 erf_series_near_zero<T> sum(x);
140 std::uintmax_t max_iter = policies::get_max_series_iterations<Policy>();
141 T result = constants::two_div_root_pi<T>() * tools::kahan_sum_series(sum, tools::digits<T>(), max_iter);
142 policies::check_series_iterations<T>("boost::math::erf<%1%>(%1%, %1%)", max_iter, pol);
143 return result;
144 }
145
146 template <class T, class Policy, class Tag>
147 T erf_imp(T z, bool invert, const Policy& pol, const Tag& t)
148 {
149 BOOST_MATH_STD_USING
150
151 BOOST_MATH_INSTRUMENT_CODE("Generic erf_imp called");
152
153 if ((boost::math::isnan)(z))
154 return policies::raise_domain_error("boost::math::erf<%1%>(%1%)", "Expected a finite argument but got %1%", z, pol);
155
156 if(z < 0)
157 {
158 if(!invert)
159 return -erf_imp(T(-z), invert, pol, t);
160 else
161 return 1 + erf_imp(T(-z), false, pol, t);
162 }
163
164 T result;
165
166 if(!invert && (z > detail::erf_asymptotic_limit<T, Policy>()))
167 {
168 detail::erf_asympt_series_t<T> s(z);
169 std::uintmax_t max_iter = policies::get_max_series_iterations<Policy>();
170 result = boost::math::tools::sum_series(s, policies::get_epsilon<T, Policy>(), max_iter, 1);
171 policies::check_series_iterations<T>("boost::math::erf<%1%>(%1%, %1%)", max_iter, pol);
172 }
173 else
174 {
175 T x = z * z;
176 if(z < 1.3f)
177 {
178 // Compute P:
179 // This is actually good for z p to 2 or so, but the cutoff given seems
180 // to be the best compromise. Performance wise, this is way quicker than anything else...
181 result = erf_series_near_zero_sum(z, pol);
182 }
183 else if(x > 1 / tools::epsilon<T>())
184 {
185 // http://functions.wolfram.com/06.27.06.0006.02
186 invert = !invert;
187 result = exp(-x) / (constants::root_pi<T>() * z);
188 }
189 else
190 {
191 // Compute Q:
192 invert = !invert;
193 result = z * exp(-x);
194 result /= boost::math::constants::root_pi<T>();
195 result *= upper_gamma_fraction(T(0.5f), x, policies::get_epsilon<T, Policy>());
196 }
197 }
198 if(invert)
199 result = 1 - result;
200 return result;
201 }
202 // LCOV_EXCL_STOP
203
204 template <class T, class Policy>
205 BOOST_MATH_GPU_ENABLED T erf_imp(T z, bool invert, const Policy& pol, const std::integral_constant<int, 53>&)
206 {
207 BOOST_MATH_STD_USING
208
209 BOOST_MATH_INSTRUMENT_CODE("53-bit precision erf_imp called");
210
211 if ((boost::math::isnan)(z))
212 return policies::raise_domain_error("boost::math::erf<%1%>(%1%)", "Expected a finite argument but got %1%", z, pol);
213
214 int prefix_multiplier = 1;
215 int prefix_adder = 0;
216
217 if(z < 0)
218 {
219 // Recursion is logically simpler here, but confuses static analyzers that need to be
220 // able to calculate the maximimum program stack size at compile time (ie CUDA).
221 z = -z;
222 if(!invert)
223 {
224 prefix_multiplier = -1;
225 // return -erf_imp(T(-z), invert, pol, t);
226 }
227 else if (z > T(0.5))
228 {
229 prefix_adder = 2;
230 prefix_multiplier = -1;
231 // return 2 - erf_imp(T(-z), invert, pol, t);
232 }
233 else
234 {
235 invert = false;
236 prefix_adder = 1;
237 // return 1 + erf_imp(T(-z), false, pol, t);
238 }
239 }
240
241 T result;
242
243 //
244 // Big bunch of selection statements now to pick
245 // which implementation to use,
246 // try to put most likely options first:
247 //
248 if(z < T(0.5))
249 {
250 //
251 // We're going to calculate erf:
252 //
253 if(z < T(1e-10))
254 {
255 if(z == 0)
256 {
257 result = T(0);
258 }
259 else
260 {
261 BOOST_MATH_STATIC_LOCAL_VARIABLE const T c = BOOST_MATH_BIG_CONSTANT(T, 53, 0.003379167095512573896158903121545171688); // LCOV_EXCL_LINE
262 result = static_cast<T>(z * 1.125f + z * c);
263 }
264 }
265 else
266 {
267 // Maximum Deviation Found: 1.561e-17
268 // Expected Error Term: 1.561e-17
269 // Maximum Relative Change in Control Points: 1.155e-04
270 // Max Error found at double precision = 2.961182e-17
271 // LCOV_EXCL_START
272 BOOST_MATH_STATIC_LOCAL_VARIABLE const T Y = 1.044948577880859375f;
273 BOOST_MATH_STATIC const T P[] = {
274 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0834305892146531832907),
275 BOOST_MATH_BIG_CONSTANT(T, 53, -0.338165134459360935041),
276 BOOST_MATH_BIG_CONSTANT(T, 53, -0.0509990735146777432841),
277 BOOST_MATH_BIG_CONSTANT(T, 53, -0.00772758345802133288487),
278 BOOST_MATH_BIG_CONSTANT(T, 53, -0.000322780120964605683831),
279 };
280 BOOST_MATH_STATIC const T Q[] = {
281 BOOST_MATH_BIG_CONSTANT(T, 53, 1.0),
282 BOOST_MATH_BIG_CONSTANT(T, 53, 0.455004033050794024546),
283 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0875222600142252549554),
284 BOOST_MATH_BIG_CONSTANT(T, 53, 0.00858571925074406212772),
285 BOOST_MATH_BIG_CONSTANT(T, 53, 0.000370900071787748000569),
286 };
287 // LCOV_EXCL_STOP
288 T zz = z * z;
289 result = z * (Y + tools::evaluate_polynomial(P, zz) / tools::evaluate_polynomial(Q, zz));
290 }
291 }
292 else if(invert ? (z < 28) : (z < 5.93f))
293 {
294 //
295 // We'll be calculating erfc:
296 //
297 invert = !invert;
298 if(z < 1.5f)
299 {
300 // Maximum Deviation Found: 3.702e-17
301 // Expected Error Term: 3.702e-17
302 // Maximum Relative Change in Control Points: 2.845e-04
303 // Max Error found at double precision = 4.841816e-17
304 // LCOV_EXCL_START
305 BOOST_MATH_STATIC_LOCAL_VARIABLE const T Y = 0.405935764312744140625f;
306 BOOST_MATH_STATIC const T P[] = {
307 BOOST_MATH_BIG_CONSTANT(T, 53, -0.098090592216281240205),
308 BOOST_MATH_BIG_CONSTANT(T, 53, 0.178114665841120341155),
309 BOOST_MATH_BIG_CONSTANT(T, 53, 0.191003695796775433986),
310 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0888900368967884466578),
311 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0195049001251218801359),
312 BOOST_MATH_BIG_CONSTANT(T, 53, 0.00180424538297014223957),
313 };
314 BOOST_MATH_STATIC const T Q[] = {
315 BOOST_MATH_BIG_CONSTANT(T, 53, 1.0),
316 BOOST_MATH_BIG_CONSTANT(T, 53, 1.84759070983002217845),
317 BOOST_MATH_BIG_CONSTANT(T, 53, 1.42628004845511324508),
318 BOOST_MATH_BIG_CONSTANT(T, 53, 0.578052804889902404909),
319 BOOST_MATH_BIG_CONSTANT(T, 53, 0.12385097467900864233),
320 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0113385233577001411017),
321 BOOST_MATH_BIG_CONSTANT(T, 53, 0.337511472483094676155e-5),
322 };
323 // LCOV_EXCL_STOP
324 BOOST_MATH_INSTRUMENT_VARIABLE(Y);
325 BOOST_MATH_INSTRUMENT_VARIABLE(P[0]);
326 BOOST_MATH_INSTRUMENT_VARIABLE(Q[0]);
327 BOOST_MATH_INSTRUMENT_VARIABLE(z);
328 result = Y + tools::evaluate_polynomial(P, T(z - T(0.5))) / tools::evaluate_polynomial(Q, T(z - T(0.5)));
329 BOOST_MATH_INSTRUMENT_VARIABLE(result);
330 result *= exp(-z * z) / z;
331 BOOST_MATH_INSTRUMENT_VARIABLE(result);
332 }
333 else if(z < 2.5f)
334 {
335 // Max Error found at double precision = 6.599585e-18
336 // Maximum Deviation Found: 3.909e-18
337 // Expected Error Term: 3.909e-18
338 // Maximum Relative Change in Control Points: 9.886e-05
339 // LCOV_EXCL_START
340 BOOST_MATH_STATIC_LOCAL_VARIABLE const T Y = 0.50672817230224609375f;
341 BOOST_MATH_STATIC const T P[] = {
342 BOOST_MATH_BIG_CONSTANT(T, 53, -0.0243500476207698441272),
343 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0386540375035707201728),
344 BOOST_MATH_BIG_CONSTANT(T, 53, 0.04394818964209516296),
345 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0175679436311802092299),
346 BOOST_MATH_BIG_CONSTANT(T, 53, 0.00323962406290842133584),
347 BOOST_MATH_BIG_CONSTANT(T, 53, 0.000235839115596880717416),
348 };
349 BOOST_MATH_STATIC const T Q[] = {
350 BOOST_MATH_BIG_CONSTANT(T, 53, 1.0),
351 BOOST_MATH_BIG_CONSTANT(T, 53, 1.53991494948552447182),
352 BOOST_MATH_BIG_CONSTANT(T, 53, 0.982403709157920235114),
353 BOOST_MATH_BIG_CONSTANT(T, 53, 0.325732924782444448493),
354 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0563921837420478160373),
355 BOOST_MATH_BIG_CONSTANT(T, 53, 0.00410369723978904575884),
356 };
357 // LCOV_EXCL_STOP
358 result = Y + tools::evaluate_polynomial(P, T(z - T(1.5))) / tools::evaluate_polynomial(Q, z - T(1.5));
359 T hi, lo;
360 int expon;
361 hi = floor(ldexp(frexp(z, &expon), 26));
362 hi = ldexp(hi, expon - 26);
363 lo = z - hi;
364 T sq = z * z;
365 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
366 result *= exp(-sq) * exp(-err_sqr) / z;
367 }
368 else if(z < 4.5f)
369 {
370 // Maximum Deviation Found: 1.512e-17
371 // Expected Error Term: 1.512e-17
372 // Maximum Relative Change in Control Points: 2.222e-04
373 // Max Error found at double precision = 2.062515e-17
374 // LCOV_EXCL_START
375 BOOST_MATH_STATIC_LOCAL_VARIABLE const T Y = 0.5405750274658203125f;
376 BOOST_MATH_STATIC const T P[] = {
377 BOOST_MATH_BIG_CONSTANT(T, 53, 0.00295276716530971662634),
378 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0137384425896355332126),
379 BOOST_MATH_BIG_CONSTANT(T, 53, 0.00840807615555585383007),
380 BOOST_MATH_BIG_CONSTANT(T, 53, 0.00212825620914618649141),
381 BOOST_MATH_BIG_CONSTANT(T, 53, 0.000250269961544794627958),
382 BOOST_MATH_BIG_CONSTANT(T, 53, 0.113212406648847561139e-4),
383 };
384 BOOST_MATH_STATIC const T Q[] = {
385 BOOST_MATH_BIG_CONSTANT(T, 53, 1.0),
386 BOOST_MATH_BIG_CONSTANT(T, 53, 1.04217814166938418171),
387 BOOST_MATH_BIG_CONSTANT(T, 53, 0.442597659481563127003),
388 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0958492726301061423444),
389 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0105982906484876531489),
390 BOOST_MATH_BIG_CONSTANT(T, 53, 0.000479411269521714493907),
391 };
392 // LCOV_EXCL_STOP
393 result = Y + tools::evaluate_polynomial(P, T(z - T(3.5))) / tools::evaluate_polynomial(Q, z - T(3.5));
394 T hi, lo;
395 int expon;
396 hi = floor(ldexp(frexp(z, &expon), 26));
397 hi = ldexp(hi, expon - 26);
398 lo = z - hi;
399 T sq = z * z;
400 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
401 result *= exp(-sq) * exp(-err_sqr) / z;
402 }
403 else
404 {
405 // Max Error found at double precision = 2.997958e-17
406 // Maximum Deviation Found: 2.860e-17
407 // Expected Error Term: 2.859e-17
408 // Maximum Relative Change in Control Points: 1.357e-05
409 // LCOV_EXCL_START
410 BOOST_MATH_STATIC_LOCAL_VARIABLE const T Y = 0.5579090118408203125f;
411 BOOST_MATH_STATIC const T P[] = {
412 BOOST_MATH_BIG_CONSTANT(T, 53, 0.00628057170626964891937),
413 BOOST_MATH_BIG_CONSTANT(T, 53, 0.0175389834052493308818),
414 BOOST_MATH_BIG_CONSTANT(T, 53, -0.212652252872804219852),
415 BOOST_MATH_BIG_CONSTANT(T, 53, -0.687717681153649930619),
416 BOOST_MATH_BIG_CONSTANT(T, 53, -2.5518551727311523996),
417 BOOST_MATH_BIG_CONSTANT(T, 53, -3.22729451764143718517),
418 BOOST_MATH_BIG_CONSTANT(T, 53, -2.8175401114513378771),
419 };
420 BOOST_MATH_STATIC const T Q[] = {
421 BOOST_MATH_BIG_CONSTANT(T, 53, 1.0),
422 BOOST_MATH_BIG_CONSTANT(T, 53, 2.79257750980575282228),
423 BOOST_MATH_BIG_CONSTANT(T, 53, 11.0567237927800161565),
424 BOOST_MATH_BIG_CONSTANT(T, 53, 15.930646027911794143),
425 BOOST_MATH_BIG_CONSTANT(T, 53, 22.9367376522880577224),
426 BOOST_MATH_BIG_CONSTANT(T, 53, 13.5064170191802889145),
427 BOOST_MATH_BIG_CONSTANT(T, 53, 5.48409182238641741584),
428 };
429 // LCOV_EXCL_STOP
430 result = Y + tools::evaluate_polynomial(P, T(1 / z)) / tools::evaluate_polynomial(Q, T(1 / z));
431 T hi, lo;
432 int expon;
433 hi = floor(ldexp(frexp(z, &expon), 26));
434 hi = ldexp(hi, expon - 26);
435 lo = z - hi;
436 T sq = z * z;
437 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
438 result *= exp(-sq) * exp(-err_sqr) / z;
439 }
440 }
441 else
442 {
443 //
444 // Any value of z larger than 28 will underflow to zero:
445 //
446 result = 0;
447 invert = !invert;
448 }
449
450 if(invert)
451 {
452 prefix_adder += prefix_multiplier * 1;
453 prefix_multiplier = -prefix_multiplier;
454 }
455
456 return prefix_adder + prefix_multiplier * result;
457 } // template <class T, class Lanczos>T erf_imp(T z, bool invert, const Lanczos& l, const std::integral_constant<int, 53>& t)
458
459
460 template <class T, class Policy>
461 T erf_imp(T z, bool invert, const Policy& pol, const std::integral_constant<int, 64>& t)
462 {
463 BOOST_MATH_STD_USING
464
465 BOOST_MATH_INSTRUMENT_CODE("64-bit precision erf_imp called");
466
467 if ((boost::math::isnan)(z))
468 return policies::raise_domain_error("boost::math::erf<%1%>(%1%)", "Expected a finite argument but got %1%", z, pol);
469
470 if(z < 0)
471 {
472 if(!invert)
473 return -erf_imp(T(-z), invert, pol, t);
474 else if(z < -0.5)
475 return 2 - erf_imp(T(-z), invert, pol, t);
476 else
477 return 1 + erf_imp(T(-z), false, pol, t);
478 }
479
480 T result;
481
482 //
483 // Big bunch of selection statements now to pick which
484 // implementation to use, try to put most likely options
485 // first:
486 //
487 if(z < 0.5)
488 {
489 //
490 // We're going to calculate erf:
491 //
492 if(z == 0)
493 {
494 result = 0;
495 }
496 else if(z < 1e-10)
497 {
498 static const T c = BOOST_MATH_BIG_CONSTANT(T, 64, 0.003379167095512573896158903121545171688); // LCOV_EXCL_LINE
499 result = z * 1.125 + z * c;
500 }
501 else
502 {
503 // Max Error found at long double precision = 1.623299e-20
504 // Maximum Deviation Found: 4.326e-22
505 // Expected Error Term: -4.326e-22
506 // Maximum Relative Change in Control Points: 1.474e-04
507 // LCOV_EXCL_START
508 static const T Y = 1.044948577880859375f;
509 static const T P[] = {
510 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0834305892146531988966),
511 BOOST_MATH_BIG_CONSTANT(T, 64, -0.338097283075565413695),
512 BOOST_MATH_BIG_CONSTANT(T, 64, -0.0509602734406067204596),
513 BOOST_MATH_BIG_CONSTANT(T, 64, -0.00904906346158537794396),
514 BOOST_MATH_BIG_CONSTANT(T, 64, -0.000489468651464798669181),
515 BOOST_MATH_BIG_CONSTANT(T, 64, -0.200305626366151877759e-4),
516 };
517 static const T Q[] = {
518 BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
519 BOOST_MATH_BIG_CONSTANT(T, 64, 0.455817300515875172439),
520 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0916537354356241792007),
521 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0102722652675910031202),
522 BOOST_MATH_BIG_CONSTANT(T, 64, 0.000650511752687851548735),
523 BOOST_MATH_BIG_CONSTANT(T, 64, 0.189532519105655496778e-4),
524 };
525 // LCOV_EXCL_STOP
526 result = z * (Y + tools::evaluate_polynomial(P, T(z * z)) / tools::evaluate_polynomial(Q, T(z * z)));
527 }
528 }
529 else if(invert ? (z < 110) : (z < 6.6f))
530 {
531 //
532 // We'll be calculating erfc:
533 //
534 invert = !invert;
535 if(z < 1.5)
536 {
537 // Max Error found at long double precision = 3.239590e-20
538 // Maximum Deviation Found: 2.241e-20
539 // Expected Error Term: -2.241e-20
540 // Maximum Relative Change in Control Points: 5.110e-03
541 // LCOV_EXCL_START
542 static const T Y = 0.405935764312744140625f;
543 static const T P[] = {
544 BOOST_MATH_BIG_CONSTANT(T, 64, -0.0980905922162812031672),
545 BOOST_MATH_BIG_CONSTANT(T, 64, 0.159989089922969141329),
546 BOOST_MATH_BIG_CONSTANT(T, 64, 0.222359821619935712378),
547 BOOST_MATH_BIG_CONSTANT(T, 64, 0.127303921703577362312),
548 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0384057530342762400273),
549 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00628431160851156719325),
550 BOOST_MATH_BIG_CONSTANT(T, 64, 0.000441266654514391746428),
551 BOOST_MATH_BIG_CONSTANT(T, 64, 0.266689068336295642561e-7),
552 };
553 static const T Q[] = {
554 BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
555 BOOST_MATH_BIG_CONSTANT(T, 64, 2.03237474985469469291),
556 BOOST_MATH_BIG_CONSTANT(T, 64, 1.78355454954969405222),
557 BOOST_MATH_BIG_CONSTANT(T, 64, 0.867940326293760578231),
558 BOOST_MATH_BIG_CONSTANT(T, 64, 0.248025606990021698392),
559 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0396649631833002269861),
560 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00279220237309449026796),
561 };
562 // LCOV_EXCL_STOP
563 result = Y + tools::evaluate_polynomial(P, T(z - 0.5f)) / tools::evaluate_polynomial(Q, T(z - 0.5f));
564 T hi, lo;
565 int expon;
566 hi = floor(ldexp(frexp(z, &expon), 32));
567 hi = ldexp(hi, expon - 32);
568 lo = z - hi;
569 T sq = z * z;
570 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
571 result *= exp(-sq) * exp(-err_sqr) / z;
572 }
573 else if(z < 2.5)
574 {
575 // Max Error found at long double precision = 3.686211e-21
576 // Maximum Deviation Found: 1.495e-21
577 // Expected Error Term: -1.494e-21
578 // Maximum Relative Change in Control Points: 1.793e-04
579 // LCOV_EXCL_START
580 static const T Y = 0.50672817230224609375f;
581 static const T P[] = {
582 BOOST_MATH_BIG_CONSTANT(T, 64, -0.024350047620769840217),
583 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0343522687935671451309),
584 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0505420824305544949541),
585 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0257479325917757388209),
586 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00669349844190354356118),
587 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00090807914416099524444),
588 BOOST_MATH_BIG_CONSTANT(T, 64, 0.515917266698050027934e-4),
589 };
590 static const T Q[] = {
591 BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
592 BOOST_MATH_BIG_CONSTANT(T, 64, 1.71657861671930336344),
593 BOOST_MATH_BIG_CONSTANT(T, 64, 1.26409634824280366218),
594 BOOST_MATH_BIG_CONSTANT(T, 64, 0.512371437838969015941),
595 BOOST_MATH_BIG_CONSTANT(T, 64, 0.120902623051120950935),
596 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0158027197831887485261),
597 BOOST_MATH_BIG_CONSTANT(T, 64, 0.000897871370778031611439),
598 };
599 // LCOV_EXCL_STOP
600 result = Y + tools::evaluate_polynomial(P, T(z - 1.5f)) / tools::evaluate_polynomial(Q, T(z - 1.5f));
601 T hi, lo;
602 int expon;
603 hi = floor(ldexp(frexp(z, &expon), 32));
604 hi = ldexp(hi, expon - 32);
605 lo = z - hi;
606 T sq = z * z;
607 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
608 result *= exp(-sq) * exp(-err_sqr) / z;
609 }
610 else if(z < 4.5)
611 {
612 // Maximum Deviation Found: 1.107e-20
613 // Expected Error Term: -1.106e-20
614 // Maximum Relative Change in Control Points: 1.709e-04
615 // Max Error found at long double precision = 1.446908e-20
616 // LCOV_EXCL_START
617 static const T Y = 0.5405750274658203125f;
618 static const T P[] = {
619 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0029527671653097284033),
620 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0141853245895495604051),
621 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0104959584626432293901),
622 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00343963795976100077626),
623 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00059065441194877637899),
624 BOOST_MATH_BIG_CONSTANT(T, 64, 0.523435380636174008685e-4),
625 BOOST_MATH_BIG_CONSTANT(T, 64, 0.189896043050331257262e-5),
626 };
627 static const T Q[] = {
628 BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
629 BOOST_MATH_BIG_CONSTANT(T, 64, 1.19352160185285642574),
630 BOOST_MATH_BIG_CONSTANT(T, 64, 0.603256964363454392857),
631 BOOST_MATH_BIG_CONSTANT(T, 64, 0.165411142458540585835),
632 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0259729870946203166468),
633 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00221657568292893699158),
634 BOOST_MATH_BIG_CONSTANT(T, 64, 0.804149464190309799804e-4),
635 };
636 // LCOV_EXCL_STOP
637 result = Y + tools::evaluate_polynomial(P, T(z - 3.5f)) / tools::evaluate_polynomial(Q, T(z - 3.5f));
638 T hi, lo;
639 int expon;
640 hi = floor(ldexp(frexp(z, &expon), 32));
641 hi = ldexp(hi, expon - 32);
642 lo = z - hi;
643 T sq = z * z;
644 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
645 result *= exp(-sq) * exp(-err_sqr) / z;
646 }
647 else
648 {
649 // Max Error found at long double precision = 7.961166e-21
650 // Maximum Deviation Found: 6.677e-21
651 // Expected Error Term: 6.676e-21
652 // Maximum Relative Change in Control Points: 2.319e-05
653 // LCOV_EXCL_START
654 static const T Y = 0.55825519561767578125f;
655 static const T P[] = {
656 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00593438793008050214106),
657 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0280666231009089713937),
658 BOOST_MATH_BIG_CONSTANT(T, 64, -0.141597835204583050043),
659 BOOST_MATH_BIG_CONSTANT(T, 64, -0.978088201154300548842),
660 BOOST_MATH_BIG_CONSTANT(T, 64, -5.47351527796012049443),
661 BOOST_MATH_BIG_CONSTANT(T, 64, -13.8677304660245326627),
662 BOOST_MATH_BIG_CONSTANT(T, 64, -27.1274948720539821722),
663 BOOST_MATH_BIG_CONSTANT(T, 64, -29.2545152747009461519),
664 BOOST_MATH_BIG_CONSTANT(T, 64, -16.8865774499799676937),
665 };
666 static const T Q[] = {
667 BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
668 BOOST_MATH_BIG_CONSTANT(T, 64, 4.72948911186645394541),
669 BOOST_MATH_BIG_CONSTANT(T, 64, 23.6750543147695749212),
670 BOOST_MATH_BIG_CONSTANT(T, 64, 60.0021517335693186785),
671 BOOST_MATH_BIG_CONSTANT(T, 64, 131.766251645149522868),
672 BOOST_MATH_BIG_CONSTANT(T, 64, 178.167924971283482513),
673 BOOST_MATH_BIG_CONSTANT(T, 64, 182.499390505915222699),
674 BOOST_MATH_BIG_CONSTANT(T, 64, 104.365251479578577989),
675 BOOST_MATH_BIG_CONSTANT(T, 64, 30.8365511891224291717),
676 };
677 // LCOV_EXCL_STOP
678 result = Y + tools::evaluate_polynomial(P, T(1 / z)) / tools::evaluate_polynomial(Q, T(1 / z));
679 T hi, lo;
680 int expon;
681 hi = floor(ldexp(frexp(z, &expon), 32));
682 hi = ldexp(hi, expon - 32);
683 lo = z - hi;
684 T sq = z * z;
685 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
686 result *= exp(-sq) * exp(-err_sqr) / z;
687 }
688 }
689 else
690 {
691 //
692 // Any value of z larger than 110 will underflow to zero:
693 //
694 result = 0;
695 invert = !invert;
696 }
697
698 if(invert)
699 {
700 result = 1 - result;
701 }
702
703 return result;
704 } // template <class T, class Lanczos>T erf_imp(T z, bool invert, const Lanczos& l, const std::integral_constant<int, 64>& t)
705
706
707 // LCOV_EXCL_START multiprecision case only, excluded from coverage analysis
708 template <class T, class Policy>
709 T erf_imp(T z, bool invert, const Policy& pol, const std::integral_constant<int, 113>& t)
710 {
711 BOOST_MATH_STD_USING
712
713 BOOST_MATH_INSTRUMENT_CODE("113-bit precision erf_imp called");
714
715 if ((boost::math::isnan)(z))
716 return policies::raise_domain_error("boost::math::erf<%1%>(%1%)", "Expected a finite argument but got %1%", z, pol);
717
718 if(z < 0)
719 {
720 if (!invert)
721 return -erf_imp(T(-z), invert, pol, t);
722 else if(z < -0.5)
723 return 2 - erf_imp(T(-z), invert, pol, t);
724 else
725 return 1 + erf_imp(T(-z), false, pol, t);
726 }
727
728 T result;
729
730 //
731 // Big bunch of selection statements now to pick which
732 // implementation to use, try to put most likely options
733 // first:
734 //
735 if(z < 0.5)
736 {
737 //
738 // We're going to calculate erf:
739 //
740 if(z == 0)
741 {
742 result = 0;
743 }
744 else if(z < 1e-20)
745 {
746 static const T c = BOOST_MATH_BIG_CONSTANT(T, 113, 0.003379167095512573896158903121545171688);
747 result = z * 1.125 + z * c;
748 }
749 else
750 {
751 // Max Error found at long double precision = 2.342380e-35
752 // Maximum Deviation Found: 6.124e-36
753 // Expected Error Term: -6.124e-36
754 // Maximum Relative Change in Control Points: 3.492e-10
755 static const T Y = 1.0841522216796875f;
756 static const T P[] = {
757 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0442269454158250738961589031215451778),
758 BOOST_MATH_BIG_CONSTANT(T, 113, -0.35549265736002144875335323556961233),
759 BOOST_MATH_BIG_CONSTANT(T, 113, -0.0582179564566667896225454670863270393),
760 BOOST_MATH_BIG_CONSTANT(T, 113, -0.0112694696904802304229950538453123925),
761 BOOST_MATH_BIG_CONSTANT(T, 113, -0.000805730648981801146251825329609079099),
762 BOOST_MATH_BIG_CONSTANT(T, 113, -0.566304966591936566229702842075966273e-4),
763 BOOST_MATH_BIG_CONSTANT(T, 113, -0.169655010425186987820201021510002265e-5),
764 BOOST_MATH_BIG_CONSTANT(T, 113, -0.344448249920445916714548295433198544e-7),
765 };
766 static const T Q[] = {
767 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
768 BOOST_MATH_BIG_CONSTANT(T, 113, 0.466542092785657604666906909196052522),
769 BOOST_MATH_BIG_CONSTANT(T, 113, 0.100005087012526447295176964142107611),
770 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0128341535890117646540050072234142603),
771 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00107150448466867929159660677016658186),
772 BOOST_MATH_BIG_CONSTANT(T, 113, 0.586168368028999183607733369248338474e-4),
773 BOOST_MATH_BIG_CONSTANT(T, 113, 0.196230608502104324965623171516808796e-5),
774 BOOST_MATH_BIG_CONSTANT(T, 113, 0.313388521582925207734229967907890146e-7),
775 };
776 result = z * (Y + tools::evaluate_polynomial(P, T(z * z)) / tools::evaluate_polynomial(Q, T(z * z)));
777 }
778 }
779 else if(invert ? (z < 110) : (z < 8.65f))
780 {
781 //
782 // We'll be calculating erfc:
783 //
784 invert = !invert;
785 if(z < 1)
786 {
787 // Max Error found at long double precision = 3.246278e-35
788 // Maximum Deviation Found: 1.388e-35
789 // Expected Error Term: 1.387e-35
790 // Maximum Relative Change in Control Points: 6.127e-05
791 static const T Y = 0.371877193450927734375f;
792 static const T P[] = {
793 BOOST_MATH_BIG_CONSTANT(T, 113, -0.0640320213544647969396032886581290455),
794 BOOST_MATH_BIG_CONSTANT(T, 113, 0.200769874440155895637857443946706731),
795 BOOST_MATH_BIG_CONSTANT(T, 113, 0.378447199873537170666487408805779826),
796 BOOST_MATH_BIG_CONSTANT(T, 113, 0.30521399466465939450398642044975127),
797 BOOST_MATH_BIG_CONSTANT(T, 113, 0.146890026406815277906781824723458196),
798 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0464837937749539978247589252732769567),
799 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00987895759019540115099100165904822903),
800 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00137507575429025512038051025154301132),
801 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0001144764551085935580772512359680516),
802 BOOST_MATH_BIG_CONSTANT(T, 113, 0.436544865032836914773944382339900079e-5),
803 };
804 static const T Q[] = {
805 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
806 BOOST_MATH_BIG_CONSTANT(T, 113, 2.47651182872457465043733800302427977),
807 BOOST_MATH_BIG_CONSTANT(T, 113, 2.78706486002517996428836400245547955),
808 BOOST_MATH_BIG_CONSTANT(T, 113, 1.87295924621659627926365005293130693),
809 BOOST_MATH_BIG_CONSTANT(T, 113, 0.829375825174365625428280908787261065),
810 BOOST_MATH_BIG_CONSTANT(T, 113, 0.251334771307848291593780143950311514),
811 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0522110268876176186719436765734722473),
812 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00718332151250963182233267040106902368),
813 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000595279058621482041084986219276392459),
814 BOOST_MATH_BIG_CONSTANT(T, 113, 0.226988669466501655990637599399326874e-4),
815 BOOST_MATH_BIG_CONSTANT(T, 113, 0.270666232259029102353426738909226413e-10),
816 };
817 result = Y + tools::evaluate_polynomial(P, T(z - 0.5f)) / tools::evaluate_polynomial(Q, T(z - 0.5f));
818 T hi, lo;
819 int expon;
820 hi = floor(ldexp(frexp(z, &expon), 56));
821 hi = ldexp(hi, expon - 56);
822 lo = z - hi;
823 T sq = z * z;
824 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
825 result *= exp(-sq) * exp(-err_sqr) / z;
826 }
827 else if(z < 1.5)
828 {
829 // Max Error found at long double precision = 2.215785e-35
830 // Maximum Deviation Found: 1.539e-35
831 // Expected Error Term: 1.538e-35
832 // Maximum Relative Change in Control Points: 6.104e-05
833 static const T Y = 0.45658016204833984375f;
834 static const T P[] = {
835 BOOST_MATH_BIG_CONSTANT(T, 113, -0.0289965858925328393392496555094848345),
836 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0868181194868601184627743162571779226),
837 BOOST_MATH_BIG_CONSTANT(T, 113, 0.169373435121178901746317404936356745),
838 BOOST_MATH_BIG_CONSTANT(T, 113, 0.13350446515949251201104889028133486),
839 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0617447837290183627136837688446313313),
840 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0185618495228251406703152962489700468),
841 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00371949406491883508764162050169531013),
842 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000485121708792921297742105775823900772),
843 BOOST_MATH_BIG_CONSTANT(T, 113, 0.376494706741453489892108068231400061e-4),
844 BOOST_MATH_BIG_CONSTANT(T, 113, 0.133166058052466262415271732172490045e-5),
845 };
846 static const T Q[] = {
847 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
848 BOOST_MATH_BIG_CONSTANT(T, 113, 2.32970330146503867261275580968135126),
849 BOOST_MATH_BIG_CONSTANT(T, 113, 2.46325715420422771961250513514928746),
850 BOOST_MATH_BIG_CONSTANT(T, 113, 1.55307882560757679068505047390857842),
851 BOOST_MATH_BIG_CONSTANT(T, 113, 0.644274289865972449441174485441409076),
852 BOOST_MATH_BIG_CONSTANT(T, 113, 0.182609091063258208068606847453955649),
853 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0354171651271241474946129665801606795),
854 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00454060370165285246451879969534083997),
855 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000349871943711566546821198612518656486),
856 BOOST_MATH_BIG_CONSTANT(T, 113, 0.123749319840299552925421880481085392e-4),
857 };
858 result = Y + tools::evaluate_polynomial(P, T(z - 1.0f)) / tools::evaluate_polynomial(Q, T(z - 1.0f));
859 T hi, lo;
860 int expon;
861 hi = floor(ldexp(frexp(z, &expon), 56));
862 hi = ldexp(hi, expon - 56);
863 lo = z - hi;
864 T sq = z * z;
865 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
866 result *= exp(-sq) * exp(-err_sqr) / z;
867 }
868 else if(z < 2.25)
869 {
870 // Maximum Deviation Found: 1.418e-35
871 // Expected Error Term: 1.418e-35
872 // Maximum Relative Change in Control Points: 1.316e-04
873 // Max Error found at long double precision = 1.998462e-35
874 static const T Y = 0.50250148773193359375f;
875 static const T P[] = {
876 BOOST_MATH_BIG_CONSTANT(T, 113, -0.0201233630504573402185161184151016606),
877 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0331864357574860196516686996302305002),
878 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0716562720864787193337475444413405461),
879 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0545835322082103985114927569724880658),
880 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0236692635189696678976549720784989593),
881 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00656970902163248872837262539337601845),
882 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00120282643299089441390490459256235021),
883 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000142123229065182650020762792081622986),
884 BOOST_MATH_BIG_CONSTANT(T, 113, 0.991531438367015135346716277792989347e-5),
885 BOOST_MATH_BIG_CONSTANT(T, 113, 0.312857043762117596999398067153076051e-6),
886 };
887 static const T Q[] = {
888 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
889 BOOST_MATH_BIG_CONSTANT(T, 113, 2.13506082409097783827103424943508554),
890 BOOST_MATH_BIG_CONSTANT(T, 113, 2.06399257267556230937723190496806215),
891 BOOST_MATH_BIG_CONSTANT(T, 113, 1.18678481279932541314830499880691109),
892 BOOST_MATH_BIG_CONSTANT(T, 113, 0.447733186643051752513538142316799562),
893 BOOST_MATH_BIG_CONSTANT(T, 113, 0.11505680005657879437196953047542148),
894 BOOST_MATH_BIG_CONSTANT(T, 113, 0.020163993632192726170219663831914034),
895 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00232708971840141388847728782209730585),
896 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000160733201627963528519726484608224112),
897 BOOST_MATH_BIG_CONSTANT(T, 113, 0.507158721790721802724402992033269266e-5),
898 BOOST_MATH_BIG_CONSTANT(T, 113, 0.18647774409821470950544212696270639e-12),
899 };
900 result = Y + tools::evaluate_polynomial(P, T(z - 1.5f)) / tools::evaluate_polynomial(Q, T(z - 1.5f));
901 T hi, lo;
902 int expon;
903 hi = floor(ldexp(frexp(z, &expon), 56));
904 hi = ldexp(hi, expon - 56);
905 lo = z - hi;
906 T sq = z * z;
907 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
908 result *= exp(-sq) * exp(-err_sqr) / z;
909 }
910 else if (z < 3)
911 {
912 // Maximum Deviation Found: 3.575e-36
913 // Expected Error Term: 3.575e-36
914 // Maximum Relative Change in Control Points: 7.103e-05
915 // Max Error found at long double precision = 5.794737e-36
916 static const T Y = 0.52896785736083984375f;
917 static const T P[] = {
918 BOOST_MATH_BIG_CONSTANT(T, 113, -0.00902152521745813634562524098263360074),
919 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0145207142776691539346923710537580927),
920 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0301681239582193983824211995978678571),
921 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0215548540823305814379020678660434461),
922 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00864683476267958365678294164340749949),
923 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00219693096885585491739823283511049902),
924 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000364961639163319762492184502159894371),
925 BOOST_MATH_BIG_CONSTANT(T, 113, 0.388174251026723752769264051548703059e-4),
926 BOOST_MATH_BIG_CONSTANT(T, 113, 0.241918026931789436000532513553594321e-5),
927 BOOST_MATH_BIG_CONSTANT(T, 113, 0.676586625472423508158937481943649258e-7),
928 };
929 static const T Q[] = {
930 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
931 BOOST_MATH_BIG_CONSTANT(T, 113, 1.93669171363907292305550231764920001),
932 BOOST_MATH_BIG_CONSTANT(T, 113, 1.69468476144051356810672506101377494),
933 BOOST_MATH_BIG_CONSTANT(T, 113, 0.880023580986436640372794392579985511),
934 BOOST_MATH_BIG_CONSTANT(T, 113, 0.299099106711315090710836273697708402),
935 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0690593962363545715997445583603382337),
936 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0108427016361318921960863149875360222),
937 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00111747247208044534520499324234317695),
938 BOOST_MATH_BIG_CONSTANT(T, 113, 0.686843205749767250666787987163701209e-4),
939 BOOST_MATH_BIG_CONSTANT(T, 113, 0.192093541425429248675532015101904262e-5),
940 };
941 result = Y + tools::evaluate_polynomial(P, T(z - 2.25f)) / tools::evaluate_polynomial(Q, T(z - 2.25f));
942 T hi, lo;
943 int expon;
944 hi = floor(ldexp(frexp(z, &expon), 56));
945 hi = ldexp(hi, expon - 56);
946 lo = z - hi;
947 T sq = z * z;
948 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
949 result *= exp(-sq) * exp(-err_sqr) / z;
950 }
951 else if(z < 3.5)
952 {
953 // Maximum Deviation Found: 8.126e-37
954 // Expected Error Term: -8.126e-37
955 // Maximum Relative Change in Control Points: 1.363e-04
956 // Max Error found at long double precision = 1.747062e-36
957 static const T Y = 0.54037380218505859375f;
958 static const T P[] = {
959 BOOST_MATH_BIG_CONSTANT(T, 113, -0.0033703486408887424921155540591370375),
960 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0104948043110005245215286678898115811),
961 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0148530118504000311502310457390417795),
962 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00816693029245443090102738825536188916),
963 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00249716579989140882491939681805594585),
964 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0004655591010047353023978045800916647),
965 BOOST_MATH_BIG_CONSTANT(T, 113, 0.531129557920045295895085236636025323e-4),
966 BOOST_MATH_BIG_CONSTANT(T, 113, 0.343526765122727069515775194111741049e-5),
967 BOOST_MATH_BIG_CONSTANT(T, 113, 0.971120407556888763695313774578711839e-7),
968 };
969 static const T Q[] = {
970 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
971 BOOST_MATH_BIG_CONSTANT(T, 113, 1.59911256167540354915906501335919317),
972 BOOST_MATH_BIG_CONSTANT(T, 113, 1.136006830764025173864831382946934),
973 BOOST_MATH_BIG_CONSTANT(T, 113, 0.468565867990030871678574840738423023),
974 BOOST_MATH_BIG_CONSTANT(T, 113, 0.122821824954470343413956476900662236),
975 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0209670914950115943338996513330141633),
976 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00227845718243186165620199012883547257),
977 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000144243326443913171313947613547085553),
978 BOOST_MATH_BIG_CONSTANT(T, 113, 0.407763415954267700941230249989140046e-5),
979 };
980 result = Y + tools::evaluate_polynomial(P, T(z - 3.0f)) / tools::evaluate_polynomial(Q, T(z - 3.0f));
981 T hi, lo;
982 int expon;
983 hi = floor(ldexp(frexp(z, &expon), 56));
984 hi = ldexp(hi, expon - 56);
985 lo = z - hi;
986 T sq = z * z;
987 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
988 result *= exp(-sq) * exp(-err_sqr) / z;
989 }
990 else if(z < 5.5)
991 {
992 // Maximum Deviation Found: 5.804e-36
993 // Expected Error Term: -5.803e-36
994 // Maximum Relative Change in Control Points: 2.475e-05
995 // Max Error found at long double precision = 1.349545e-35
996 static const T Y = 0.55000019073486328125f;
997 static const T P[] = {
998 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00118142849742309772151454518093813615),
999 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0072201822885703318172366893469382745),
1000 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0078782276276860110721875733778481505),
1001 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00418229166204362376187593976656261146),
1002 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00134198400587769200074194304298642705),
1003 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000283210387078004063264777611497435572),
1004 BOOST_MATH_BIG_CONSTANT(T, 113, 0.405687064094911866569295610914844928e-4),
1005 BOOST_MATH_BIG_CONSTANT(T, 113, 0.39348283801568113807887364414008292e-5),
1006 BOOST_MATH_BIG_CONSTANT(T, 113, 0.248798540917787001526976889284624449e-6),
1007 BOOST_MATH_BIG_CONSTANT(T, 113, 0.929502490223452372919607105387474751e-8),
1008 BOOST_MATH_BIG_CONSTANT(T, 113, 0.156161469668275442569286723236274457e-9),
1009 };
1010 static const T Q[] = {
1011 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
1012 BOOST_MATH_BIG_CONSTANT(T, 113, 1.52955245103668419479878456656709381),
1013 BOOST_MATH_BIG_CONSTANT(T, 113, 1.06263944820093830054635017117417064),
1014 BOOST_MATH_BIG_CONSTANT(T, 113, 0.441684612681607364321013134378316463),
1015 BOOST_MATH_BIG_CONSTANT(T, 113, 0.121665258426166960049773715928906382),
1016 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0232134512374747691424978642874321434),
1017 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00310778180686296328582860464875562636),
1018 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000288361770756174705123674838640161693),
1019 BOOST_MATH_BIG_CONSTANT(T, 113, 0.177529187194133944622193191942300132e-4),
1020 BOOST_MATH_BIG_CONSTANT(T, 113, 0.655068544833064069223029299070876623e-6),
1021 BOOST_MATH_BIG_CONSTANT(T, 113, 0.11005507545746069573608988651927452e-7),
1022 };
1023 result = Y + tools::evaluate_polynomial(P, T(z - 4.5f)) / tools::evaluate_polynomial(Q, T(z - 4.5f));
1024 T hi, lo;
1025 int expon;
1026 hi = floor(ldexp(frexp(z, &expon), 56));
1027 hi = ldexp(hi, expon - 56);
1028 lo = z - hi;
1029 T sq = z * z;
1030 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
1031 result *= exp(-sq) * exp(-err_sqr) / z;
1032 }
1033 else if(z < 7.5)
1034 {
1035 // Maximum Deviation Found: 1.007e-36
1036 // Expected Error Term: 1.007e-36
1037 // Maximum Relative Change in Control Points: 1.027e-03
1038 // Max Error found at long double precision = 2.646420e-36
1039 static const T Y = 0.5574436187744140625f;
1040 static const T P[] = {
1041 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000293236907400849056269309713064107674),
1042 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00225110719535060642692275221961480162),
1043 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00190984458121502831421717207849429799),
1044 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000747757733460111743833929141001680706),
1045 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000170663175280949889583158597373928096),
1046 BOOST_MATH_BIG_CONSTANT(T, 113, 0.246441188958013822253071608197514058e-4),
1047 BOOST_MATH_BIG_CONSTANT(T, 113, 0.229818000860544644974205957895688106e-5),
1048 BOOST_MATH_BIG_CONSTANT(T, 113, 0.134886977703388748488480980637704864e-6),
1049 BOOST_MATH_BIG_CONSTANT(T, 113, 0.454764611880548962757125070106650958e-8),
1050 BOOST_MATH_BIG_CONSTANT(T, 113, 0.673002744115866600294723141176820155e-10),
1051 };
1052 static const T Q[] = {
1053 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
1054 BOOST_MATH_BIG_CONSTANT(T, 113, 1.12843690320861239631195353379313367),
1055 BOOST_MATH_BIG_CONSTANT(T, 113, 0.569900657061622955362493442186537259),
1056 BOOST_MATH_BIG_CONSTANT(T, 113, 0.169094404206844928112348730277514273),
1057 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0324887449084220415058158657252147063),
1058 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00419252877436825753042680842608219552),
1059 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00036344133176118603523976748563178578),
1060 BOOST_MATH_BIG_CONSTANT(T, 113, 0.204123895931375107397698245752850347e-4),
1061 BOOST_MATH_BIG_CONSTANT(T, 113, 0.674128352521481412232785122943508729e-6),
1062 BOOST_MATH_BIG_CONSTANT(T, 113, 0.997637501418963696542159244436245077e-8),
1063 };
1064 result = Y + tools::evaluate_polynomial(P, T(z - 6.5f)) / tools::evaluate_polynomial(Q, T(z - 6.5f));
1065 T hi, lo;
1066 int expon;
1067 hi = floor(ldexp(frexp(z, &expon), 56));
1068 hi = ldexp(hi, expon - 56);
1069 lo = z - hi;
1070 T sq = z * z;
1071 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
1072 result *= exp(-sq) * exp(-err_sqr) / z;
1073 }
1074 else if(z < 11.5)
1075 {
1076 // Maximum Deviation Found: 8.380e-36
1077 // Expected Error Term: 8.380e-36
1078 // Maximum Relative Change in Control Points: 2.632e-06
1079 // Max Error found at long double precision = 9.849522e-36
1080 static const T Y = 0.56083202362060546875f;
1081 static const T P[] = {
1082 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000282420728751494363613829834891390121),
1083 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00175387065018002823433704079355125161),
1084 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0021344978564889819420775336322920375),
1085 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00124151356560137532655039683963075661),
1086 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000423600733566948018555157026862139644),
1087 BOOST_MATH_BIG_CONSTANT(T, 113, 0.914030340865175237133613697319509698e-4),
1088 BOOST_MATH_BIG_CONSTANT(T, 113, 0.126999927156823363353809747017945494e-4),
1089 BOOST_MATH_BIG_CONSTANT(T, 113, 0.110610959842869849776179749369376402e-5),
1090 BOOST_MATH_BIG_CONSTANT(T, 113, 0.55075079477173482096725348704634529e-7),
1091 BOOST_MATH_BIG_CONSTANT(T, 113, 0.119735694018906705225870691331543806e-8),
1092 };
1093 static const T Q[] = {
1094 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
1095 BOOST_MATH_BIG_CONSTANT(T, 113, 1.69889613396167354566098060039549882),
1096 BOOST_MATH_BIG_CONSTANT(T, 113, 1.28824647372749624464956031163282674),
1097 BOOST_MATH_BIG_CONSTANT(T, 113, 0.572297795434934493541628008224078717),
1098 BOOST_MATH_BIG_CONSTANT(T, 113, 0.164157697425571712377043857240773164),
1099 BOOST_MATH_BIG_CONSTANT(T, 113, 0.0315311145224594430281219516531649562),
1100 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00405588922155632380812945849777127458),
1101 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000336929033691445666232029762868642417),
1102 BOOST_MATH_BIG_CONSTANT(T, 113, 0.164033049810404773469413526427932109e-4),
1103 BOOST_MATH_BIG_CONSTANT(T, 113, 0.356615210500531410114914617294694857e-6),
1104 };
1105 result = Y + tools::evaluate_polynomial(P, T(z / 2 - 4.75f)) / tools::evaluate_polynomial(Q, T(z / 2 - 4.75f));
1106 T hi, lo;
1107 int expon;
1108 hi = floor(ldexp(frexp(z, &expon), 56));
1109 hi = ldexp(hi, expon - 56);
1110 lo = z - hi;
1111 T sq = z * z;
1112 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
1113 result *= exp(-sq) * exp(-err_sqr) / z;
1114 }
1115 else
1116 {
1117 // Maximum Deviation Found: 1.132e-35
1118 // Expected Error Term: -1.132e-35
1119 // Maximum Relative Change in Control Points: 4.674e-04
1120 // Max Error found at long double precision = 1.162590e-35
1121 static const T Y = 0.5632686614990234375f;
1122 static const T P[] = {
1123 BOOST_MATH_BIG_CONSTANT(T, 113, 0.000920922048732849448079451574171836943),
1124 BOOST_MATH_BIG_CONSTANT(T, 113, 0.00321439044532288750501700028748922439),
1125 BOOST_MATH_BIG_CONSTANT(T, 113, -0.250455263029390118657884864261823431),
1126 BOOST_MATH_BIG_CONSTANT(T, 113, -0.906807635364090342031792404764598142),
1127 BOOST_MATH_BIG_CONSTANT(T, 113, -8.92233572835991735876688745989985565),
1128 BOOST_MATH_BIG_CONSTANT(T, 113, -21.7797433494422564811782116907878495),
1129 BOOST_MATH_BIG_CONSTANT(T, 113, -91.1451915251976354349734589601171659),
1130 BOOST_MATH_BIG_CONSTANT(T, 113, -144.1279109655993927069052125017673),
1131 BOOST_MATH_BIG_CONSTANT(T, 113, -313.845076581796338665519022313775589),
1132 BOOST_MATH_BIG_CONSTANT(T, 113, -273.11378811923343424081101235736475),
1133 BOOST_MATH_BIG_CONSTANT(T, 113, -271.651566205951067025696102600443452),
1134 BOOST_MATH_BIG_CONSTANT(T, 113, -60.0530577077238079968843307523245547),
1135 };
1136 static const T Q[] = {
1137 BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
1138 BOOST_MATH_BIG_CONSTANT(T, 113, 3.49040448075464744191022350947892036),
1139 BOOST_MATH_BIG_CONSTANT(T, 113, 34.3563592467165971295915749548313227),
1140 BOOST_MATH_BIG_CONSTANT(T, 113, 84.4993232033879023178285731843850461),
1141 BOOST_MATH_BIG_CONSTANT(T, 113, 376.005865281206894120659401340373818),
1142 BOOST_MATH_BIG_CONSTANT(T, 113, 629.95369438888946233003926191755125),
1143 BOOST_MATH_BIG_CONSTANT(T, 113, 1568.35771983533158591604513304269098),
1144 BOOST_MATH_BIG_CONSTANT(T, 113, 1646.02452040831961063640827116581021),
1145 BOOST_MATH_BIG_CONSTANT(T, 113, 2299.96860633240298708910425594484895),
1146 BOOST_MATH_BIG_CONSTANT(T, 113, 1222.73204392037452750381340219906374),
1147 BOOST_MATH_BIG_CONSTANT(T, 113, 799.359797306084372350264298361110448),
1148 BOOST_MATH_BIG_CONSTANT(T, 113, 72.7415265778588087243442792401576737),
1149 };
1150 result = Y + tools::evaluate_polynomial(P, T(1 / z)) / tools::evaluate_polynomial(Q, T(1 / z));
1151 T hi, lo;
1152 int expon;
1153 hi = floor(ldexp(frexp(z, &expon), 56));
1154 hi = ldexp(hi, expon - 56);
1155 lo = z - hi;
1156 T sq = z * z;
1157 T err_sqr = ((hi * hi - sq) + 2 * hi * lo) + lo * lo;
1158 result *= exp(-sq) * exp(-err_sqr) / z;
1159 }
1160 }
1161 else
1162 {
1163 //
1164 // Any value of z larger than 110 will underflow to zero:
1165 //
1166 result = 0;
1167 invert = !invert;
1168 }
1169
1170 if(invert)
1171 {
1172 result = 1 - result;
1173 }
1174
1175 return result;
1176 } // template <class T, class Lanczos>T erf_imp(T z, bool invert, const Lanczos& l, const std::integral_constant<int, 113>& t)
1177 // LCOV_EXCL_STOP
1178
1179 } // namespace detail
1180
1181 template <class T, class Policy>
1182 BOOST_MATH_GPU_ENABLED inline typename tools::promote_args<T>::type erf(T z, const Policy& /* pol */)
1183 {
1184 typedef typename tools::promote_args<T>::type result_type;
1185 typedef typename policies::evaluation<result_type, Policy>::type value_type;
1186 typedef typename policies::precision<result_type, Policy>::type precision_type;
1187 typedef typename policies::normalise<
1188 Policy,
1189 policies::promote_float<false>,
1190 policies::promote_double<false>,
1191 policies::discrete_quantile<>,
1192 policies::assert_undefined<> >::type forwarding_policy;
1193
1194 BOOST_MATH_INSTRUMENT_CODE("result_type = " << typeid(result_type).name());
1195 BOOST_MATH_INSTRUMENT_CODE("value_type = " << typeid(value_type).name());
1196 BOOST_MATH_INSTRUMENT_CODE("precision_type = " << typeid(precision_type).name());
1197
1198 typedef std::integral_constant<int,
1199 precision_type::value <= 0 ? 0 :
1200 precision_type::value <= 53 ? 53 :
1201 precision_type::value <= 64 ? 64 :
1202 precision_type::value <= 113 ? 113 : 0
1203 > tag_type;
1204
1205 BOOST_MATH_INSTRUMENT_CODE("tag_type = " << typeid(tag_type).name());
1206
1207 return policies::checked_narrowing_cast<result_type, forwarding_policy>(detail::erf_imp(
1208 static_cast<value_type>(z),
1209 false,
1210 forwarding_policy(),
1211 tag_type()), "boost::math::erf<%1%>(%1%, %1%)");
1212 }
1213
1214 template <class T, class Policy>
1215 BOOST_MATH_GPU_ENABLED inline typename tools::promote_args<T>::type erfc(T z, const Policy& /* pol */)
1216 {
1217 typedef typename tools::promote_args<T>::type result_type;
1218 typedef typename policies::evaluation<result_type, Policy>::type value_type;
1219 typedef typename policies::precision<result_type, Policy>::type precision_type;
1220 typedef typename policies::normalise<
1221 Policy,
1222 policies::promote_float<false>,
1223 policies::promote_double<false>,
1224 policies::discrete_quantile<>,
1225 policies::assert_undefined<> >::type forwarding_policy;
1226
1227 BOOST_MATH_INSTRUMENT_CODE("result_type = " << typeid(result_type).name());
1228 BOOST_MATH_INSTRUMENT_CODE("value_type = " << typeid(value_type).name());
1229 BOOST_MATH_INSTRUMENT_CODE("precision_type = " << typeid(precision_type).name());
1230
1231 typedef std::integral_constant<int,
1232 precision_type::value <= 0 ? 0 :
1233 precision_type::value <= 53 ? 53 :
1234 precision_type::value <= 64 ? 64 :
1235 precision_type::value <= 113 ? 113 : 0
1236 > tag_type;
1237
1238 BOOST_MATH_INSTRUMENT_CODE("tag_type = " << typeid(tag_type).name());
1239
1240 return policies::checked_narrowing_cast<result_type, forwarding_policy>(detail::erf_imp(
1241 static_cast<value_type>(z),
1242 true,
1243 forwarding_policy(),
1244 tag_type()), "boost::math::erfc<%1%>(%1%, %1%)");
1245 }
1246
1247 template <class T>
1248 BOOST_MATH_GPU_ENABLED inline typename tools::promote_args<T>::type erf(T z)
1249 {
1250 return boost::math::erf(z, policies::policy<>());
1251 }
1252
1253 template <class T>
1254 BOOST_MATH_GPU_ENABLED inline typename tools::promote_args<T>::type erfc(T z)
1255 {
1256 return boost::math::erfc(z, policies::policy<>());
1257 }
1258
1259 } // namespace math
1260 } // namespace boost
1261
1262 #else // Special handling for NVRTC platform
1263
1264 namespace boost {
1265 namespace math {
1266
1267 template <typename T>
1268 BOOST_MATH_GPU_ENABLED auto erf(T x)
1269 {
1270 return ::erf(x);
1271 }
1272
1273 template <>
1274 BOOST_MATH_GPU_ENABLED auto erf(float x)
1275 {
1276 return ::erff(x);
1277 }
1278
1279 template <typename T, typename Policy>
1280 BOOST_MATH_GPU_ENABLED auto erf(T x, const Policy&)
1281 {
1282 return ::erf(x);
1283 }
1284
1285 template <typename Policy>
1286 BOOST_MATH_GPU_ENABLED auto erf(float x, const Policy&)
1287 {
1288 return ::erff(x);
1289 }
1290
1291 template <typename T>
1292 BOOST_MATH_GPU_ENABLED auto erfc(T x)
1293 {
1294 return ::erfc(x);
1295 }
1296
1297 template <>
1298 BOOST_MATH_GPU_ENABLED auto erfc(float x)
1299 {
1300 return ::erfcf(x);
1301 }
1302
1303 template <typename T, typename Policy>
1304 BOOST_MATH_GPU_ENABLED auto erfc(T x, const Policy&)
1305 {
1306 return ::erfc(x);
1307 }
1308
1309 template <typename Policy>
1310 BOOST_MATH_GPU_ENABLED auto erfc(float x, const Policy&)
1311 {
1312 return ::erfcf(x);
1313 }
1314
1315 } // namespace math
1316 } // namespace boost
1317
1318 #endif // BOOST_MATH_HAS_NVRTC
1319
1320 #include <boost/math/special_functions/detail/erf_inv.hpp>
1321
1322 #endif // BOOST_MATH_SPECIAL_ERF_HPP