Debian Codegraph @

.cargo/vendor/pxfm/src/err/erfcx.rs

raw
1 /*
2 * // Copyright (c) Radzivon Bartoshyk 9/2025. All rights reserved.
3 * //
4 * // Redistribution and use in source and binary forms, with or without modification,
5 * // are permitted provided that the following conditions are met:
6 * //
7 * // 1. Redistributions of source code must retain the above copyright notice, this
8 * // list of conditions and the following disclaimer.
9 * //
10 * // 2. Redistributions in binary form must reproduce the above copyright notice,
11 * // this list of conditions and the following disclaimer in the documentation
12 * // and/or other materials provided with the distribution.
13 * //
14 * // 3. Neither the name of the copyright holder nor the names of its
15 * // contributors may be used to endorse or promote products derived from
16 * // this software without specific prior written permission.
17 * //
18 * // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 * // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
22 * // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 * // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25 * // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26 * // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29 use crate::double_double::DoubleDouble;
30 use crate::pow_exec::exp_dd_fast;
31
32 #[inline]
33 fn core_erfcx(x: f64) -> DoubleDouble {
34 if x <= 8. {
35 // Rational approximant for erfcx generated by Wolfram Mathematica:
36 // <<FunctionApproximations`
37 // ClearAll["Global`*"]
38 // f[x_]:=Exp[x^2]Erfc[x]
39 // {err0,approx,err1}=MiniMaxApproximation[f[z],{z,{1, 8},11,11},WorkingPrecision->75,MaxIterations->100]
40 // num=Numerator[approx];
41 // den=Denominator[approx];
42 // coeffs=CoefficientList[num,z];
43 // TableForm[Table[Row[{"'",NumberForm[coeffs[[i+1]],{50,50},ExponentFunction->(Null&)],"',"}],{i,0,Length[coeffs]-1}]]
44 // coeffs=CoefficientList[den,z];
45 // TableForm[Table[Row[{"'",NumberForm[coeffs[[i+1]],{50,50},ExponentFunction->(Null&)],"',"}],{i,0,Length[coeffs]-1}]]
46 const P: [(u64, u64); 12] = [
47 (0xbc836faeb9a312bb, 0x3ff000000000ee8e),
48 (0x3c91842f891bec6a, 0x4002ca20a78aaf8f),
49 (0x3c7916e8a1c30681, 0x4005e955f70aed5b),
50 (0x3cabad150d828d82, 0x4000646f5807ad07),
51 (0xbc6f482680d66d9c, 0x3ff1449e03ed381c),
52 (0xbc7188796156ae19, 0x3fdaa7e997e3b034),
53 (0xbc5c8af0642761e3, 0x3fbe836282058d4a),
54 (0xbc372829be2d072f, 0x3f99a2b2adc2ec05),
55 (0x3c020cc8b96000ab, 0x3f6e6cc3d120a955),
56 (0x3bdd138e6c136806, 0x3f3743d6735eaf13),
57 (0xbb9fbd22f0675122, 0x3ef1c1d36ebe29a2),
58 (0xb89093cc981c934c, 0xbc43c18bc6385c74),
59 ];
60
61 let x2 = DoubleDouble::from_exact_mult(x, x);
62 let x4 = x2 * x2;
63 let x8 = x4 * x4;
64
65 let e0 = DoubleDouble::mul_f64_add(
66 DoubleDouble::from_bit_pair(P[1]),
67 x,
68 DoubleDouble::from_bit_pair(P[0]),
69 );
70 let e1 = DoubleDouble::mul_f64_add(
71 DoubleDouble::from_bit_pair(P[3]),
72 x,
73 DoubleDouble::from_bit_pair(P[2]),
74 );
75 let e2 = DoubleDouble::mul_f64_add(
76 DoubleDouble::from_bit_pair(P[5]),
77 x,
78 DoubleDouble::from_bit_pair(P[4]),
79 );
80 let e3 = DoubleDouble::mul_f64_add(
81 DoubleDouble::from_bit_pair(P[7]),
82 x,
83 DoubleDouble::from_bit_pair(P[6]),
84 );
85 let e4 = DoubleDouble::mul_f64_add(
86 DoubleDouble::from_bit_pair(P[9]),
87 x,
88 DoubleDouble::from_bit_pair(P[8]),
89 );
90 let e5 = DoubleDouble::mul_f64_add(
91 DoubleDouble::from_bit_pair(P[11]),
92 x,
93 DoubleDouble::from_bit_pair(P[10]),
94 );
95
96 let f0 = DoubleDouble::mul_add(x2, e1, e0);
97 let f1 = DoubleDouble::mul_add(x2, e3, e2);
98 let f2 = DoubleDouble::mul_add(x2, e5, e4);
99
100 let g0 = DoubleDouble::mul_add(x4, f1, f0);
101
102 let p_num = DoubleDouble::mul_add(x8, f2, g0);
103
104 const Q: [(u64, u64); 12] = [
105 (0x0000000000000000, 0x3ff0000000000000),
106 (0xbc95d65be031374e, 0x400bd10c4fb1dbe5),
107 (0x3cb2d8f661db08a0, 0x4016a649ff973199),
108 (0x3ca32cbcfdc0ea93, 0x4016daab399c1ffc),
109 (0xbca2982868536578, 0x400fd61ab892d14c),
110 (0xbca2e29199e17fd9, 0x40001f56c4d495a3),
111 (0x3c412ce623a1790a, 0x3fe852b582135164),
112 (0x3c61152eaf4b0dc5, 0x3fcb760564da7cde),
113 (0xbc1b57ff91d81959, 0x3fa6e146988df835),
114 (0x3c17183d8445f19a, 0x3f7b06599b5e912f),
115 (0xbbd0ada61b85ff98, 0x3f449e39467b73d0),
116 (0xbb658d84fc735e67, 0x3eff794442532b51),
117 ];
118
119 let e0 = DoubleDouble::mul_f64_add_f64(
120 DoubleDouble::from_bit_pair(Q[1]),
121 x,
122 f64::from_bits(0x3ff0000000000000),
123 );
124 let e1 = DoubleDouble::mul_f64_add(
125 DoubleDouble::from_bit_pair(Q[3]),
126 x,
127 DoubleDouble::from_bit_pair(Q[2]),
128 );
129 let e2 = DoubleDouble::mul_f64_add(
130 DoubleDouble::from_bit_pair(Q[5]),
131 x,
132 DoubleDouble::from_bit_pair(Q[4]),
133 );
134 let e3 = DoubleDouble::mul_f64_add(
135 DoubleDouble::from_bit_pair(Q[7]),
136 x,
137 DoubleDouble::from_bit_pair(Q[6]),
138 );
139 let e4 = DoubleDouble::mul_f64_add(
140 DoubleDouble::from_bit_pair(Q[9]),
141 x,
142 DoubleDouble::from_bit_pair(Q[8]),
143 );
144 let e5 = DoubleDouble::mul_f64_add(
145 DoubleDouble::from_bit_pair(Q[11]),
146 x,
147 DoubleDouble::from_bit_pair(Q[10]),
148 );
149
150 let f0 = DoubleDouble::mul_add(x2, e1, e0);
151 let f1 = DoubleDouble::mul_add(x2, e3, e2);
152 let f2 = DoubleDouble::mul_add(x2, e5, e4);
153
154 let g0 = DoubleDouble::mul_add(x4, f1, f0);
155
156 let p_den = DoubleDouble::mul_add(x8, f2, g0);
157 return DoubleDouble::div(p_num, p_den);
158 }
159
160 // for large x erfcx(x) ~ 1/sqrt(pi) / x * R(1/x)
161 const ONE_OVER_SQRT_PI: DoubleDouble =
162 DoubleDouble::from_bit_pair((0x3c61ae3a914fed80, 0x3fe20dd750429b6d));
163 let r = DoubleDouble::from_quick_recip(x);
164 // Rational approximant generated by Wolfram:
165 // <<FunctionApproximations`
166 // ClearAll["Global`*"]
167 // f[x_]:=Exp[1/x^2]Erfc[1/x]/x*Sqrt[Pi]
168 // {err0,approx}=MiniMaxApproximation[f[z],{z,{2^-23,1/8},8,8},WorkingPrecision->75,MaxIterations->100]
169 // num=Numerator[approx][[1]];
170 // den=Denominator[approx][[1]];
171 // coeffs=CoefficientList[num,z];
172 // TableForm[Table[Row[{"'",NumberForm[coeffs[[i+1]],{50,50},ExponentFunction->(Null&)],"',"}],{i,0,Length[coeffs]-1}]]
173 // coeffs=CoefficientList[den,z];
174 // TableForm[Table[Row[{"'",NumberForm[coeffs[[i+1]],{50,50},ExponentFunction->(Null&)],"',"}],{i,0,Length[coeffs]-1}]]
175 const P: [(u64, u64); 9] = [
176 (0xbb1d2ee37e46a4cd, 0x3ff0000000000000),
177 (0x3ca2e575a4ce3d30, 0x4001303ab00c8bac),
178 (0xbccf38381e5ee521, 0x4030a97aeed54c9f),
179 (0xbcc3a2842df0dd3d, 0x4036f7733c9fd2f9),
180 (0xbcfeaf46506f16ed, 0x4051c5f382750553),
181 (0x3ccbb9f5e11d176a, 0x404ac0081e0749e0),
182 (0xbcf374f8966ae2a5, 0x4052082526d99a5c),
183 (0x3cbb5530b924f224, 0x402feabbf6571c29),
184 (0xbcbcdd50a3ca4776, 0x40118726e1f2d204),
185 ];
186 const Q: [(u64, u64); 9] = [
187 (0x0000000000000000, 0x3ff0000000000000),
188 (0x3ca2e4613c9e0017, 0x4001303ab00c8bac),
189 (0xbcce5f17cf14e51d, 0x4031297aeed54c9f),
190 (0xbcdf7e0fed176f92, 0x40380a76e7a09bb2),
191 (0x3cfc57b67a2797af, 0x4053bb22e04faf3e),
192 (0xbcd3e63b7410b46b, 0x404ff46317ae9483),
193 (0xbce122c15db2653f, 0x405925ef8a428c36),
194 (0x3ce174ebe3e52c8e, 0x4040f49acfe692e1),
195 (0xbcda0e267ce6e2e6, 0x40351a07878bfbd3),
196 ];
197 let mut p_num = DoubleDouble::mul_add(
198 DoubleDouble::from_bit_pair(P[8]),
199 r,
200 DoubleDouble::from_bit_pair(P[7]),
201 );
202 p_num = DoubleDouble::mul_add(p_num, r, DoubleDouble::from_bit_pair(P[6]));
203 p_num = DoubleDouble::mul_add(p_num, r, DoubleDouble::from_bit_pair(P[5]));
204 p_num = DoubleDouble::mul_add(p_num, r, DoubleDouble::from_bit_pair(P[4]));
205 p_num = DoubleDouble::mul_add(p_num, r, DoubleDouble::from_bit_pair(P[3]));
206 p_num = DoubleDouble::mul_add(p_num, r, DoubleDouble::from_bit_pair(P[2]));
207 p_num = DoubleDouble::mul_add(p_num, r, DoubleDouble::from_bit_pair(P[1]));
208 p_num = DoubleDouble::mul_add(p_num, r, DoubleDouble::from_bit_pair(P[0]));
209
210 let mut p_den = DoubleDouble::mul_add(
211 DoubleDouble::from_bit_pair(Q[8]),
212 r,
213 DoubleDouble::from_bit_pair(Q[7]),
214 );
215 p_den = DoubleDouble::mul_add(p_den, r, DoubleDouble::from_bit_pair(Q[6]));
216 p_den = DoubleDouble::mul_add(p_den, r, DoubleDouble::from_bit_pair(Q[5]));
217 p_den = DoubleDouble::mul_add(p_den, r, DoubleDouble::from_bit_pair(Q[4]));
218 p_den = DoubleDouble::mul_add(p_den, r, DoubleDouble::from_bit_pair(Q[3]));
219 p_den = DoubleDouble::mul_add(p_den, r, DoubleDouble::from_bit_pair(Q[2]));
220 p_den = DoubleDouble::mul_add(p_den, r, DoubleDouble::from_bit_pair(Q[1]));
221 p_den = DoubleDouble::mul_add_f64(p_den, r, f64::from_bits(0x3ff0000000000000));
222
223 let v0 = DoubleDouble::quick_mult(ONE_OVER_SQRT_PI, r);
224 let v1 = DoubleDouble::div(p_num, p_den);
225 DoubleDouble::quick_mult(v0, v1)
226 }
227
228 /// Scaled complementary error function (exp(x^2)*erfc(x))
229 pub fn f_erfcx(x: f64) -> f64 {
230 let ux = x.to_bits().wrapping_shl(1);
231
232 if ux >= 0x7ffu64 << 53 || ux <= 0x7960000000000000u64 {
233 // x == NaN, x == inf, x == 0, |x| <= f64::EPSILON
234 if x.is_nan() {
235 return f64::NAN;
236 }
237 if x.to_bits().wrapping_shl(1) == 0 {
238 return 1.;
239 }
240 if x.is_infinite() {
241 return if x.is_sign_positive() {
242 0.
243 } else {
244 f64::INFINITY
245 };
246 }
247
248 if ux <= 0x7888f5c28f5c28f6u64 {
249 // |x| <= 2.2204460492503131e-18
250 return 1.;
251 }
252
253 // |x| <= f64::EPSILON
254 use crate::common::f_fmla;
255 const M_TWO_OVER_SQRT_PI: DoubleDouble =
256 DoubleDouble::from_bit_pair((0xbc71ae3a914fed80, 0xbff20dd750429b6d));
257 return f_fmla(
258 M_TWO_OVER_SQRT_PI.lo,
259 x,
260 f_fmla(M_TWO_OVER_SQRT_PI.hi, x, 1.),
261 );
262 }
263
264 if x.to_bits() >= 0xc03aa449ebc84dd6 {
265 // x <= -sqrt(709.783) ~ -26.6417
266 return f64::INFINITY;
267 }
268
269 let ax = x.to_bits() & 0x7fff_ffff_ffff_ffffu64;
270
271 if ax <= 0x3ff0000000000000u64 {
272 // |x| <= 1
273 // Rational approximant generated by Wolfram Mathematica:
274 // <<FunctionApproximations`
275 // ClearAll["Global`*"]
276 // f[x_]:=Exp[x^2]Erfc[x]
277 // {err0,approx}=MiniMaxApproximation[f[z],{z,{-1, 1},10,10},WorkingPrecision->75,MaxIterations->100]
278 // num=Numerator[approx][[1]];
279 // den=Denominator[approx][[1]];
280 // coeffs=CoefficientList[num,z];
281 // TableForm[Table[Row[{"'",NumberForm[coeffs[[i+1]],{50,50},ExponentFunction->(Null&)],"',"}],{i,0,Length[coeffs]-1}]]
282 // coeffs=CoefficientList[den,z];
283 // TableForm[Table[Row[{"'",NumberForm[coeffs[[i+1]],{50,50},ExponentFunction->(Null&)],"',"}],{i,0,Length[coeffs]-1}]]
284 const P: [(u64, u64); 11] = [
285 (0xbb488611350b1950, 0x3ff0000000000000),
286 (0xbc86ae482c7f2342, 0x3ff9c5d39e89602f),
287 (0x3c6702d70b807254, 0x3ff5a4c406d6468b),
288 (0x3c7fe41fc43cfed5, 0x3fe708e7f401bd0c),
289 (0x3c73a4a355172c6d, 0x3fd0d9a0c1a7126c),
290 (0x3c5f4c372faa270f, 0x3fb154722e30762e),
291 (0xbc04c0227976379e, 0x3f88ecebb62ce646),
292 (0xbbdc9ea151b9eb33, 0x3f580ea84143877b),
293 (0xbb6dae7001a91491, 0x3f1c3c5f95579b0a),
294 (0x3b6aca5e82c52897, 0x3ecea4db51968d9e),
295 (0x3a41c4edd175d2af, 0x3dbc0dccea7fc8ed),
296 ];
297
298 let x2 = DoubleDouble::from_exact_mult(x, x);
299 let x4 = x2 * x2;
300 let x8 = x4 * x4;
301
302 let q0 = DoubleDouble::mul_f64_add(
303 DoubleDouble::from_bit_pair(P[1]),
304 x,
305 DoubleDouble::from_bit_pair(P[0]),
306 );
307 let q1 = DoubleDouble::mul_f64_add(
308 DoubleDouble::from_bit_pair(P[3]),
309 x,
310 DoubleDouble::from_bit_pair(P[2]),
311 );
312 let q2 = DoubleDouble::mul_f64_add(
313 DoubleDouble::from_bit_pair(P[5]),
314 x,
315 DoubleDouble::from_bit_pair(P[4]),
316 );
317 let q3 = DoubleDouble::mul_f64_add(
318 DoubleDouble::from_bit_pair(P[7]),
319 x,
320 DoubleDouble::from_bit_pair(P[6]),
321 );
322 let q4 = DoubleDouble::mul_f64_add(
323 DoubleDouble::from_bit_pair(P[9]),
324 x,
325 DoubleDouble::from_bit_pair(P[8]),
326 );
327
328 let r0 = DoubleDouble::mul_add(x2, q1, q0);
329 let r1 = DoubleDouble::mul_add(x2, q3, q2);
330
331 let s0 = DoubleDouble::mul_add(x4, r1, r0);
332 let s1 = DoubleDouble::mul_add(x2, DoubleDouble::from_bit_pair(P[10]), q4);
333 let p_num = DoubleDouble::mul_add(x8, s1, s0);
334
335 const Q: [(u64, u64); 11] = [
336 (0x0000000000000000, 0x3ff0000000000000),
337 (0xbc7bae414cad99c8, 0x4005e9d57765fdce),
338 (0x3c8fa553bed15758, 0x400b8c670b3fbcda),
339 (0x3ca6c7ad610f1019, 0x4004f2ca59958153),
340 (0x3c87787f336cc4e6, 0x3ff55c267090315a),
341 (0xbc6ef55d4b2c4150, 0x3fde8b84b64b6f4e),
342 (0x3c570d63c94be3a3, 0x3fbf0d5e36017482),
343 (0x3c1882a745ef572e, 0x3f962f73633506c1),
344 (0xbc0850bb6fc82764, 0x3f65593e0dc46acd),
345 (0xbbb9dc0097d7d776, 0x3f290545603e2f94),
346 (0xbb776e5781e3889d, 0x3edb29c49d18cf89),
347 ];
348
349 let q0 = DoubleDouble::mul_f64_add_f64(
350 DoubleDouble::from_bit_pair(Q[1]),
351 x,
352 f64::from_bits(0x3ff0000000000000),
353 );
354 let q1 = DoubleDouble::mul_f64_add(
355 DoubleDouble::from_bit_pair(Q[3]),
356 x,
357 DoubleDouble::from_bit_pair(Q[2]),
358 );
359 let q2 = DoubleDouble::mul_f64_add(
360 DoubleDouble::from_bit_pair(Q[5]),
361 x,
362 DoubleDouble::from_bit_pair(Q[4]),
363 );
364 let q3 = DoubleDouble::mul_f64_add(
365 DoubleDouble::from_bit_pair(Q[7]),
366 x,
367 DoubleDouble::from_bit_pair(Q[6]),
368 );
369 let q4 = DoubleDouble::mul_f64_add(
370 DoubleDouble::from_bit_pair(Q[9]),
371 x,
372 DoubleDouble::from_bit_pair(Q[8]),
373 );
374
375 let r0 = DoubleDouble::mul_add(x2, q1, q0);
376 let r1 = DoubleDouble::mul_add(x2, q3, q2);
377
378 let s0 = DoubleDouble::mul_add(x4, r1, r0);
379 let s1 = DoubleDouble::mul_add(x2, DoubleDouble::from_bit_pair(Q[10]), q4);
380 let p_den = DoubleDouble::mul_add(x8, s1, s0);
381
382 let v = DoubleDouble::div(p_num, p_den);
383 return v.to_f64();
384 }
385
386 let mut erfcx_abs_x = core_erfcx(f64::from_bits(ax));
387 if x < 0. {
388 // exp(x^2)erfc(-x) = 2*exp(x^2) - erfcx(|x|)
389 erfcx_abs_x = DoubleDouble::from_exact_add(erfcx_abs_x.hi, erfcx_abs_x.lo);
390 let d2x = DoubleDouble::from_exact_mult(x, x);
391 let expd2x = exp_dd_fast(d2x);
392 return DoubleDouble::mul_f64_add(expd2x, 2., -erfcx_abs_x).to_f64();
393 }
394 erfcx_abs_x.to_f64()
395 }
396
397 #[cfg(test)]
398 mod tests {
399 use crate::f_erfcx;
400
401 #[test]
402 fn test_erfcx() {
403 assert_eq!(f_erfcx(2.2204460492503131e-18), 1.0);
404 assert_eq!(f_erfcx(-2.2204460492503131e-18), 1.0);
405 assert_eq!(f_erfcx(-f64::EPSILON), 1.0000000000000002);
406 assert_eq!(f_erfcx(f64::EPSILON), 0.9999999999999998);
407 assert_eq!(f_erfcx(-173.), f64::INFINITY);
408 assert_eq!(f_erfcx(-9.4324165432), 8.718049147018359e38);
409 assert_eq!(f_erfcx(9.4324165432), 0.059483265496416374);
410 assert_eq!(f_erfcx(-1.32432512125), 11.200579112797806);
411 assert_eq!(f_erfcx(1.32432512125), 0.3528722004785406);
412 assert_eq!(f_erfcx(-0.532431235), 2.0560589406595384);
413 assert_eq!(f_erfcx(0.532431235), 0.5994337293294584);
414 assert_eq!(f_erfcx(1e-26), 1.0);
415 assert_eq!(f_erfcx(-0.500000000023073), 1.952360489253639);
416 assert_eq!(f_erfcx(-175.), f64::INFINITY);
417 assert_eq!(f_erfcx(f64::INFINITY), 0.);
418 assert_eq!(f_erfcx(f64::NEG_INFINITY), f64::INFINITY);
419 assert!(f_erfcx(f64::NAN).is_nan());
420 }
421 }