Debian Codegraph @

.cargo/vendor/pxfm/src/logs/log10p1.rs

raw
1 /*
2 * // Copyright (c) Radzivon Bartoshyk 7/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::common::*;
30 use crate::double_double::DoubleDouble;
31 use crate::dyadic_float::{DyadicFloat128, DyadicSign};
32 use crate::logs::log2p1::{log_fast, log_p_1a, log2_dyadic};
33 use crate::logs::log10p1_tables::{LOG10P1_EXACT_INT_S_TABLE, LOG10P1_EXACT_INT_TABLE};
34
35 const INV_LOG10_DD: DoubleDouble = DoubleDouble::new(
36 f64::from_bits(0x3c695355baaafad3),
37 f64::from_bits(0x3fdbcb7b1526e50e),
38 );
39
40 /* deal with |x| < 2^-900, then log10p1(x) ~ x/log(10) */
41 #[cold]
42 fn log10p1_accurate_tiny(x: f64) -> f64 {
43 /* first scale x to avoid truncation of l in the underflow region */
44 let sx = x * f64::from_bits(0x4690000000000000);
45 let mut px = DoubleDouble::quick_f64_mult(sx, INV_LOG10_DD);
46
47 let res = px.to_f64() * f64::from_bits(0x3950000000000000); // expected result
48 px.lo += dd_fmla(-res, f64::from_bits(0x4690000000000000), px.hi);
49 // the correction to apply to res is l*2^-106
50 /* For RNDN, we have underflow for |x| <= 0x1.26bb1bbb55515p-1021,
51 and for rounding away, for |x| < 0x1.26bb1bbb55515p-1021. */
52
53 dyad_fmla(px.lo, f64::from_bits(0x3950000000000000), res)
54 }
55
56 fn log10p1_accurate_small(x: f64) -> f64 {
57 /* the following is a degree-17 polynomial approximating log10p1(x) for
58 |x| <= 2^-5 with relative error < 2^-105.067*/
59
60 static P_ACC: [u64; 25] = [
61 0x3fdbcb7b1526e50e,
62 0x3c695355baaafad4,
63 0xbfcbcb7b1526e50e,
64 0xbc595355baaae078,
65 0x3fc287a7636f435f,
66 0xbc59c871838f83ac,
67 0xbfbbcb7b1526e50e,
68 0xbc495355e23285f2,
69 0x3fb63c62775250d8,
70 0x3c4442abd5831422,
71 0xbfb287a7636f435f,
72 0x3c49d116f225c4e4,
73 0x3fafc3fa615105c7,
74 0x3c24e1d7b4790510,
75 0xbfabcb7b1526e512,
76 0x3c49f884199ab0ce,
77 0x3fa8b4df2f3f0486,
78 0xbfa63c6277522391,
79 0x3fa436e526a79e5c,
80 0xbfa287a764c5a762,
81 0x3fa11ac1e784daec,
82 0xbf9fc3eedc920817,
83 0x3f9da5cac3522edb,
84 0xbf9be5ca1f9a97cd,
85 0x3f9a44b64ca06e9b,
86 ];
87
88 /* for degree 11 or more, ulp(c[d]*x^d) < 2^-105.7*|log10p1(x)|
89 where c[d] is the degree-d coefficient of Pacc, thus we can compute
90 with a double only, and even with degree 10 (this does not increase
91 the number of exceptional cases) */
92
93 let mut h = dd_fmla(f64::from_bits(P_ACC[24]), x, f64::from_bits(P_ACC[23])); // degree 16
94 for i in (10..=15).rev() {
95 h = dd_fmla(h, x, f64::from_bits(P_ACC[(i + 7) as usize])); // degree i
96 }
97
98 // degree 9
99 let px = DoubleDouble::from_exact_mult(x, h);
100 let hl = DoubleDouble::from_exact_add(f64::from_bits(P_ACC[9 + 7]), px.hi);
101 h = hl.hi;
102 let mut l = px.lo + hl.lo;
103
104 for i in (1..=8).rev() {
105 let mut p = DoubleDouble::quick_f64_mult(x, DoubleDouble::new(l, h));
106 l = p.lo;
107 p = DoubleDouble::from_exact_add(f64::from_bits(P_ACC[(2 * i - 2) as usize]), p.hi);
108 h = p.hi;
109 l += p.lo + f64::from_bits(P_ACC[(2 * i - 1) as usize]);
110 }
111 let pz = DoubleDouble::quick_f64_mult(x, DoubleDouble::new(l, h));
112 pz.to_f64()
113 }
114
115 #[cold]
116 fn log10p1_accurate(x: f64) -> f64 {
117 let ax = x.abs();
118
119 if ax < f64::from_bits(0x3fa0000000000000) {
120 return if ax < f64::from_bits(0x07b0000000000000) {
121 log10p1_accurate_tiny(x)
122 } else {
123 log10p1_accurate_small(x)
124 };
125 }
126 let dx = if x > 1.0 {
127 DoubleDouble::from_exact_add(x, 1.0)
128 } else {
129 DoubleDouble::from_exact_add(1.0, x)
130 };
131 let x_d = DyadicFloat128::new_from_f64(dx.hi);
132 let mut y = log2_dyadic(x_d, dx.hi);
133 let mut c = DyadicFloat128::from_div_f64(dx.lo, dx.hi);
134 let mut bx = c * c;
135 /* multiply X by -1/2 */
136 bx.exponent -= 1;
137 bx.sign = DyadicSign::Neg;
138 /* C <- C - C^2/2 */
139 c = c + bx;
140 /* |C-log(1+xl/xh)| ~ 2e-64 */
141 y = y + c;
142
143 // Sage Math:
144 // from sage.all import *
145 //
146 // def format_hex2(value):
147 // l = hex(value)[2:]
148 // n = 4
149 // x = [l[i:i + n] for i in range(0, len(l), n)]
150 // return "0x" + "_".join(x) + "_u128"
151 // (s, m, e) = (RealField(128)(1)/RealField(128)(10)).log().sign_mantissa_exponent();
152 // print(format_hex2(m));
153 const LOG10_INV: DyadicFloat128 = DyadicFloat128 {
154 sign: DyadicSign::Pos,
155 exponent: -129,
156 mantissa: 0xde5b_d8a9_3728_7195_355b_aaaf_ad33_dc32_u128,
157 };
158 y = y * LOG10_INV;
159 y.fast_as_f64()
160 }
161
162 #[inline]
163 fn log10p1_fast(x: f64, e: i32) -> (DoubleDouble, f64) {
164 if e < -5
165 /* e <= -6 thus |x| < 2^-5 */
166 {
167 if e <= -968 {
168 /* then |x| might be as small as 2^-968, thus h=x/log(10) might in the
169 binade [2^-970,2^-969), with ulp(h) = 2^-1022, and if |l| < ulp(h),
170 then l.ulp() might be smaller than 2^-1074. We defer that case to
171 the accurate path. */
172 let ax = x.abs();
173 let result = if ax < f64::from_bits(0x07b0000000000000) {
174 log10p1_accurate_tiny(x)
175 } else {
176 log10p1_accurate_small(x)
177 };
178 return (DoubleDouble::new(0.0, result), 0.0);
179 }
180 let mut p = log_p_1a(x);
181 let p_lo = p.lo;
182 p = DoubleDouble::from_exact_add(x, p.hi);
183 p.lo += p_lo;
184 p = DoubleDouble::quick_mult(p, INV_LOG10_DD);
185 return (p, f64::from_bits(0x3c1d400000000000) * p.hi); /* 2^-61.13 < 0x1.d4p-62 */
186 }
187
188 /* (xh,xl) <- 1+x */
189 let zx = DoubleDouble::from_full_exact_add(x, 1.0);
190
191 let mut v_u = zx.hi.to_bits();
192 let e = ((v_u >> 52) as i32).wrapping_sub(0x3ff);
193 v_u = (0x3ffu64 << 52) | (v_u & 0xfffffffffffff);
194 let mut p = log_fast(e, v_u);
195
196 /* log(xh+xl) = log(xh) + log(1+xl/xh) */
197 let c = if zx.hi <= f64::from_bits(0x7fd0000000000000) || zx.lo.abs() >= 4.0 {
198 zx.lo / zx.hi
199 } else {
200 0.
201 }; // avoid spurious underflow
202
203 /* Since |xl| < ulp(xh), we have |xl| < 2^-52 |xh|,
204 thus |c| < 2^-52, and since |log(1+x)-x| < x^2 for |x| < 0.5,
205 we have |log(1+c)-c)| < c^2 < 2^-104. */
206 p.lo += c;
207
208 /* now multiply h+l by 1/log(2) */
209 p = DoubleDouble::quick_mult(p, INV_LOG10_DD);
210 (p, f64::from_bits(0x3bb0a00000000000)) /* 2^-67.92 < 0x1.0ap-68 */
211 }
212
213 /// Computes log10(x+1)
214 ///
215 /// Max ULP 0.5
216 pub fn f_log10p1(x: f64) -> f64 {
217 let x_u = x.to_bits();
218 let e = (((x_u >> 52) & 0x7ff) as i32).wrapping_sub(0x3ff);
219 if e == 0x400 || x == 0. || x <= -1.0 {
220 /* case NaN/Inf, +/-0 or x <= -1 */
221 if e == 0x400 && x.to_bits() != 0xfffu64 << 52 {
222 /* NaN or + Inf*/
223 return x + x;
224 }
225 if x <= -1.0
226 /* we use the fact that NaN < -1 is false */
227 {
228 /* log2p(x<-1) is NaN, log2p(-1) is -Inf and raises DivByZero */
229 return if x < -1.0 {
230 f64::NAN
231 } else {
232 // x=-1
233 f64::NEG_INFINITY
234 };
235 }
236 return x + x; /* +/-0 */
237 }
238
239 /* check x=10^n-1 for 1 <= n <= 15, where log10p1(x) is exact,
240 and we shouldn't raise the inexact flag */
241 if 3 <= e && e <= 49 && x == f64::from_bits(LOG10P1_EXACT_INT_TABLE[e as usize]) {
242 return LOG10P1_EXACT_INT_S_TABLE[e as usize] as f64;
243 }
244
245 /* now x = m*2^e with 1 <= m < 2 (m = v.f) and -1074 <= e <= 1023 */
246 let (p, err) = log10p1_fast(x, e);
247 let left = p.hi + (p.lo - err);
248 let right = p.hi + (p.lo + err);
249 if left == right {
250 return left;
251 }
252
253 log10p1_accurate(x)
254 }
255
256 #[cfg(test)]
257 mod tests {
258 use super::*;
259
260 #[test]
261 fn test_log10p1() {
262 assert_eq!(f_log10p1(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013904929147106097),
263 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006038833999843867 );
264 assert!(f_log10p1(-2.0).is_nan());
265 assert_eq!(f_log10p1(9.0), 1.0);
266 assert_eq!(f_log10p1(2.0), 0.47712125471966244);
267 assert_eq!(f_log10p1(-0.5), -0.3010299956639812);
268 }
269 }