1const LN2_HI: f64 = 6.931_471_803_691_238e-1;
4const LN2_LO: f64 = 1.908_214_929_270_587_7e-10;
5const INV_LN2: f64 = core::f64::consts::LOG2_E;
6
7const LG1: f64 = 6.666_666_666_666_735e-1;
8const LG2: f64 = 3.999_999_999_940_942e-1;
9const LG3: f64 = 2.857_142_874_366_239e-1;
10const LG4: f64 = 2.222_219_843_214_978_4e-1;
11const LG5: f64 = 1.818_357_216_161_805e-1;
12const LG6: f64 = 1.531_383_769_920_937_3e-1;
13const LG7: f64 = 1.479_819_860_511_658_6e-1;
14
15const EXP_P1: f64 = 1.666_666_666_666_660_2e-1;
16const EXP_P2: f64 = -2.777_777_777_701_559_3e-3;
17const EXP_P3: f64 = 6.613_756_321_437_934e-5;
18const EXP_P4: f64 = -1.653_390_220_546_525_2e-6;
19const EXP_P5: f64 = 4.138_136_797_057_238_5e-8;
20
21#[must_use]
23#[inline]
24pub fn floor(x: f64) -> f64 {
25 if x.is_nan() || x.is_infinite() || x == 0.0 {
26 return x;
27 }
28 let t = trunc(x);
29 if x < t { t - 1.0 } else { t }
30}
31
32#[must_use]
34#[inline]
35pub fn ceil(x: f64) -> f64 {
36 if x.is_nan() || x.is_infinite() || x == 0.0 {
37 return x;
38 }
39 let t = trunc(x);
40 if x > t { t + 1.0 } else { t }
41}
42
43#[must_use]
45#[inline]
46pub fn trunc(x: f64) -> f64 {
47 let bits = x.to_bits();
48 let exp = ((bits >> 52) & 0x7ff) as i32 - 1023;
49 if exp < 0 {
50 return f64::from_bits(bits & (1u64 << 63));
51 }
52 if exp >= 52 {
53 return x;
54 }
55 let mask = (1u64 << (52 - exp)) - 1;
56 f64::from_bits(bits & !mask)
57}
58
59#[must_use]
61pub fn ln(x: f64) -> f64 {
62 if x.is_nan() || x < 0.0 {
63 return f64::NAN;
64 }
65 if x == 0.0 {
66 return f64::NEG_INFINITY;
67 }
68 if x == f64::INFINITY {
69 return f64::INFINITY;
70 }
71 if x == 1.0 {
72 return 0.0;
73 }
74
75 let mut ux = x.to_bits();
76 let mut k = 0i32;
77 if (ux >> 52) == 0 {
78 ux = (x * ((1u64 << 52) as f64)).to_bits();
80 k -= 52;
81 }
82
83 k += ((ux >> 52) as i32) - 1023;
84 let mant_hi = ((ux >> 32) as u32) & 0x000f_ffff;
85 let offset = (mant_hi + 0x95f64) & 0x0010_0000;
87 let m_bits = (ux & 0x000f_ffff_ffff_ffff) | (((offset ^ 0x3ff0_0000) as u64) << 32);
88 k += (offset >> 20) as i32;
89
90 let f = f64::from_bits(m_bits) - 1.0;
91 let s = f / (2.0 + f);
92 let z = s * s;
93 let w = z * z;
94 let t1 = w * (LG2 + w * (LG4 + w * LG6));
95 let t2 = z * (LG1 + w * (LG3 + w * (LG5 + w * LG7)));
96 let r = t2 + t1;
97 let hfsq = 0.5 * f * f;
98 let dk = k as f64;
99
100 dk * LN2_HI - ((hfsq - (s * (hfsq + r) + dk * LN2_LO)) - f)
101}
102
103fn exp(x: f64) -> f64 {
105 if x.is_nan() {
106 return f64::NAN;
107 }
108 if x > 709.782_712_893_384 {
109 return f64::INFINITY;
110 }
111 if x < -745.133_219_101_941_1 {
112 return 0.0;
113 }
114 if x == 0.0 {
115 return 1.0;
116 }
117
118 let k = if x >= 0.0 {
119 floor(x * INV_LN2 + 0.5) as i32
120 } else {
121 ceil(x * INV_LN2 - 0.5) as i32
122 };
123 let dk = k as f64;
124 let hi = x - dk * LN2_HI;
125 let lo = dk * LN2_LO;
126 let r = hi - lo;
127 let z = r * r;
128 let c = r - z * (EXP_P1 + z * (EXP_P2 + z * (EXP_P3 + z * (EXP_P4 + z * EXP_P5))));
129 let y = 1.0 - ((lo - (r * c) / (2.0 - c)) - hi);
130
131 scale_pow2(y, k)
132}
133
134#[inline]
135fn scale_pow2(y: f64, k: i32) -> f64 {
136 if (-1021..=1023).contains(&k) {
137 return y * f64::from_bits(((k + 1023) as u64) << 52);
138 }
139 if k == 1024 {
140 return (y * f64::from_bits(2046u64 << 52)) * 2.0;
141 }
142 let k1 = -1022;
144 let k2 = k - k1;
145 (y * f64::from_bits(((k1 + 1023) as u64) << 52)) * f64::from_bits(((k2 + 1023) as u64) << 52)
146}
147
148#[inline]
150fn classify_integer(y: f64) -> u8 {
151 let ay = if y < 0.0 { -y } else { y };
152 if ay >= 9_007_199_254_740_992.0 {
153 return 2;
155 }
156 let t = trunc(ay);
157 if t != ay {
158 return 0;
159 }
160 let n = t as u64;
161 if (n & 1) == 1 { 1 } else { 2 }
162}
163
164#[inline]
165fn powi_small(mut base: f64, exp_val: i32) -> f64 {
166 let mut e = if exp_val < 0 {
167 base = 1.0 / base;
168 (-exp_val) as u32
169 } else {
170 exp_val as u32
171 };
172 let mut acc = 1.0;
173 while e != 0 {
174 if (e & 1) != 0 {
175 acc *= base;
176 }
177 e >>= 1;
178 if e != 0 {
179 base *= base;
180 }
181 }
182 acc
183}
184
185#[must_use]
187pub fn powf(x: f64, y: f64) -> f64 {
188 if y == 0.0 || x == 1.0 {
189 return 1.0;
190 }
191 if x.is_nan() || y.is_nan() {
192 return f64::NAN;
193 }
194
195 if y.is_infinite() {
196 let ax = if x < 0.0 { -x } else { x };
197 if ax == 1.0 {
198 return 1.0;
199 }
200 return if (ax > 1.0) == (y > 0.0) {
201 f64::INFINITY
202 } else {
203 0.0
204 };
205 }
206
207 let y_int = classify_integer(y);
208
209 if x.is_infinite() {
210 if x > 0.0 {
211 return if y > 0.0 { f64::INFINITY } else { 0.0 };
212 }
213 return if y > 0.0 {
214 if y_int == 1 {
215 f64::NEG_INFINITY
216 } else {
217 f64::INFINITY
218 }
219 } else if y_int == 1 {
220 -0.0
221 } else {
222 0.0
223 };
224 }
225
226 if x == 0.0 {
227 let neg_zero = (x.to_bits() >> 63) != 0;
228 return if y > 0.0 {
229 if neg_zero && y_int == 1 { -0.0 } else { 0.0 }
230 } else if neg_zero && y_int == 1 {
231 f64::NEG_INFINITY
232 } else {
233 f64::INFINITY
234 };
235 }
236
237 let mut sign = 1.0;
238 let ax = if x < 0.0 {
239 if y_int == 0 {
240 return f64::NAN;
241 }
242 if y_int == 1 {
243 sign = -1.0;
244 }
245 -x
246 } else {
247 x
248 };
249
250 if y_int != 0 && (-64.0..=64.0).contains(&y) {
251 return sign * powi_small(ax, y as i32);
252 }
253
254 sign * exp(y * ln(ax))
255}
256
257#[cfg(test)]
258mod tests {
259 use super::*;
260
261 fn rel_err(actual: f64, expected: f64) -> f64 {
262 let diff = if actual >= expected {
263 actual - expected
264 } else {
265 expected - actual
266 };
267 diff / (if expected >= 0.0 { expected } else { -expected })
268 }
269
270 #[test]
271 fn rounding_and_sqrt_exact_and_edge_cases() {
272 assert_eq!(floor(2.7), 2.0);
273 assert_eq!(floor(-2.7), -3.0);
274 assert_eq!(floor(3.0), 3.0);
275 assert_eq!(floor(-3.0), -3.0);
276 assert_eq!(floor(0.0).to_bits(), 0.0f64.to_bits());
277 assert_eq!(floor(-0.0).to_bits(), (-0.0f64).to_bits());
278 assert!(floor(f64::NAN).is_nan());
279 assert_eq!(floor(f64::INFINITY), f64::INFINITY);
280 assert_eq!(floor(f64::NEG_INFINITY), f64::NEG_INFINITY);
281
282 assert_eq!(ceil(2.3), 3.0);
283 assert_eq!(ceil(-2.3), -2.0);
284 assert_eq!(ceil(4.0), 4.0);
285 assert_eq!(ceil(-4.0), -4.0);
286 assert_eq!(ceil(-0.0).to_bits(), (-0.0f64).to_bits());
287 assert!(ceil(f64::NAN).is_nan());
288
289 assert_eq!(trunc(2.9), 2.0);
290 assert_eq!(trunc(-2.9), -2.0);
291 assert_eq!(trunc(-0.5).to_bits(), (-0.0f64).to_bits());
292 assert!(trunc(f64::NAN).is_nan());
293 }
294
295 #[test]
296 fn ln_exp_powf_accuracy_and_ieee_special_cases() {
297 assert_eq!(ln(1.0), 0.0);
298 assert_eq!(ln(0.0), f64::NEG_INFINITY);
299 assert_eq!(ln(-0.0), f64::NEG_INFINITY);
300 assert!(ln(-1.0).is_nan());
301 assert!(ln(f64::NAN).is_nan());
302 assert_eq!(ln(f64::INFINITY), f64::INFINITY);
303
304 assert!(rel_err(ln(core::f64::consts::E), 1.0) < 1e-15);
305 assert!(rel_err(ln(2.0), core::f64::consts::LN_2) < 1e-15);
306 assert!(rel_err(ln(10.0), core::f64::consts::LN_10) < 1e-15);
307 assert!(rel_err(ln(0.5), -core::f64::consts::LN_2) < 1e-15);
308
309 assert_eq!(exp(0.0), 1.0);
310 assert_eq!(exp(800.0), f64::INFINITY);
311 assert_eq!(exp(-800.0), 0.0);
312 assert!(exp(f64::NAN).is_nan());
313 assert!(rel_err(exp(1.0), core::f64::consts::E) < 1e-15);
314 assert!(rel_err(exp(core::f64::consts::LN_2 * 10.0), 1024.0) < 1e-14);
315
316 assert_eq!(powf(2.0, 10.0), 1024.0);
317 assert_eq!(powf(-2.0, 3.0), -8.0);
318 assert_eq!(powf(-2.0, 4.0), 16.0);
319 assert!(powf(-2.0, 0.5).is_nan());
320 assert_eq!(powf(f64::NAN, 0.0), 1.0);
321 assert_eq!(powf(1.0, f64::NAN), 1.0);
322 assert_eq!(powf(1.0, f64::INFINITY), 1.0);
323 assert_eq!(powf(-1.0, f64::INFINITY), 1.0);
324 assert_eq!(powf(0.0, 3.0).to_bits(), 0.0f64.to_bits());
325 assert_eq!(powf(-0.0, 3.0).to_bits(), (-0.0f64).to_bits());
326 assert_eq!(powf(-0.0, 4.0).to_bits(), 0.0f64.to_bits());
327 assert_eq!(powf(0.0, -2.0), f64::INFINITY);
328 assert_eq!(powf(-0.0, -3.0), f64::NEG_INFINITY);
329 assert!(rel_err(powf(9.0, 0.5), 3.0) < 1e-14);
330 assert!(rel_err(powf(core::f64::consts::E, 2.5), exp(2.5)) < 1e-14);
331 }
332}