use std::fmt;
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct LongDouble(u128);
const FRAC_BITS: u32 = 112;
const EXP_MAX: u128 = 0x7fff;
const BIAS: i32 = 16383;
const FRAC_MASK: u128 = (1 << FRAC_BITS) - 1;
const SIGN: u128 = 1 << 127;
impl LongDouble {
pub const ZERO: LongDouble = LongDouble(0);
pub const fn from_bits(bits: u128) -> LongDouble {
LongDouble(bits)
}
pub const fn to_bits(self) -> u128 {
self.0
}
pub const fn from_f64(v: f64) -> LongDouble {
let bits = v.to_bits();
let sign = ((bits >> 63) as u128) << 127;
let exp = ((bits >> 52) & 0x7ff) as i32;
let frac = (bits & ((1 << 52) - 1)) as u128;
LongDouble(
sign | match exp {
0x7ff => (EXP_MAX << FRAC_BITS) | (frac << (FRAC_BITS - 52)),
0 if frac == 0 => 0,
0 => {
let top = 127 - frac.leading_zeros(); let e = top as i32 - 1074 + BIAS;
((e as u128) << FRAC_BITS) | ((frac << (FRAC_BITS - top)) & FRAC_MASK)
}
_ => (((exp - 1023 + BIAS) as u128) << FRAC_BITS) | (frac << (FRAC_BITS - 52)),
},
)
}
pub fn to_f64(self) -> f64 {
let sign = ((self.0 >> 127) as u64) << 63;
let exp = ((self.0 >> FRAC_BITS) & EXP_MAX) as i32;
let frac = self.0 & FRAC_MASK;
if exp == EXP_MAX as i32 {
return f64::from_bits(if frac == 0 {
sign | 0x7ff0_0000_0000_0000
} else {
sign | 0x7ff8_0000_0000_0000 | (frac >> (FRAC_BITS - 52)) as u64
});
}
if exp == 0 && frac == 0 {
return f64::from_bits(sign);
}
let (m, e) = if exp == 0 {
(frac, 1 - BIAS)
} else {
(frac | (1 << FRAC_BITS), exp - BIAS)
};
let bits = if e >= -1022 {
let r = round_shift(m, FRAC_BITS - 52);
let biased = (e + 1023) as u64;
if r >> 53 != 0 {
if biased + 1 >= 0x7ff {
0x7ff0_0000_0000_0000
} else {
((biased + 1) << 52) | ((r >> 1) as u64 & ((1 << 52) - 1))
}
} else if biased >= 0x7ff {
0x7ff0_0000_0000_0000
} else {
(biased << 52) | (r as u64 & ((1 << 52) - 1))
}
} else {
let shift = (FRAC_BITS - 52) as i32 + (-1022 - e);
round_shift(m, shift.min(127) as u32) as u64
};
f64::from_bits(sign | bits)
}
pub fn is_nan(self) -> bool {
(self.0 >> FRAC_BITS) & EXP_MAX == EXP_MAX && self.0 & FRAC_MASK != 0
}
pub fn is_sign_negative(self) -> bool {
self.0 & SIGN != 0
}
pub fn to_be_bytes(self) -> [u8; 16] {
self.0.to_be_bytes()
}
pub fn from_be_bytes(bytes: [u8; 16]) -> LongDouble {
LongDouble(u128::from_be_bytes(bytes))
}
}
fn round_shift(m: u128, shift: u32) -> u128 {
if shift == 0 {
return m;
}
let q = m >> shift;
let rest = m & ((1 << shift) - 1);
let half = 1 << (shift - 1);
if rest > half || (rest == half && q & 1 == 1) {
q + 1
} else {
q
}
}
impl From<f64> for LongDouble {
fn from(v: f64) -> LongDouble {
LongDouble::from_f64(v)
}
}
impl From<f32> for LongDouble {
fn from(v: f32) -> LongDouble {
LongDouble::from_f64(f64::from(v))
}
}
impl From<LongDouble> for f64 {
fn from(v: LongDouble) -> f64 {
v.to_f64()
}
}
impl fmt::Debug for LongDouble {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "LongDouble({:?} / {:#034x})", self.to_f64(), self.0)
}
}
impl fmt::Display for LongDouble {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.to_f64(), f)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn round_trip(v: f64) {
let ld = LongDouble::from_f64(v);
assert_eq!(ld.to_f64().to_bits(), v.to_bits(), "{v:e}");
}
#[test]
fn known_bits() {
assert_eq!(LongDouble::from_f64(1.0).to_bits(), 0x3fff << 112);
assert_eq!(LongDouble::from_f64(-2.0).to_bits(), SIGN | (0x4000 << 112));
assert_eq!(
LongDouble::from_f64(1.5).to_bits(),
(0x3fff << 112) | (1 << 111)
);
assert_eq!(LongDouble::from_f64(f64::INFINITY).to_bits(), 0x7fff << 112);
assert_eq!(LongDouble::from_f64(-0.0).to_bits(), SIGN);
assert_eq!(
LongDouble::from_f64(f64::from_bits(1)).to_bits(),
((16383 - 1074) as u128) << 112
);
}
#[test]
fn doubles_round_trip() {
for v in [
0.0,
-0.0,
1.0,
-1.0,
0.1,
std::f64::consts::PI,
f64::MAX,
f64::MIN_POSITIVE,
f64::from_bits(1),
f64::from_bits(0x000f_ffff_ffff_ffff),
f64::from_bits(0x0008_0000_0000_0001),
f64::INFINITY,
f64::NEG_INFINITY,
1e300,
-1e-310,
] {
round_trip(v);
}
assert!(LongDouble::from_f64(f64::NAN).is_nan());
assert!(LongDouble::from_f64(f64::NAN).to_f64().is_nan());
}
#[test]
fn rounding() {
let one = 0x3fffu128 << 112;
assert_eq!(LongDouble::from_bits(one | (1 << 59)).to_f64(), 1.0);
assert_eq!(
LongDouble::from_bits(one | (1 << 59) | 1).to_f64(),
1.0 + f64::EPSILON
);
assert_eq!(
LongDouble::from_bits(one | (3 << 59)).to_f64(),
1.0 + 2.0 * f64::EPSILON
);
assert_eq!(LongDouble::from_bits(one | FRAC_MASK).to_f64(), 2.0);
assert_eq!(LongDouble::from_bits(0x43ff << 112).to_f64(), f64::INFINITY);
assert_eq!(
LongDouble::from_bits((0x43fe << 112) | FRAC_MASK).to_f64(),
f64::INFINITY
);
let tiny = LongDouble::from_bits(SIGN | (1 << 112));
assert_eq!(tiny.to_f64().to_bits(), (-0.0f64).to_bits());
let half = LongDouble::from_bits(((16383 - 1075) as u128) << 112);
assert_eq!(half.to_f64(), 0.0);
let more = LongDouble::from_bits((((16383 - 1075) as u128) << 112) | 1);
assert_eq!(more.to_f64(), f64::from_bits(1));
let edge = LongDouble::from_bits((((16383 - 1023) as u128) << 112) | FRAC_MASK);
assert_eq!(edge.to_f64(), f64::MIN_POSITIVE);
assert_eq!(LongDouble::from_bits(1).to_f64(), 0.0);
}
}