1 | //! Extended precision "soft float", for internal use only. |
2 | |
3 | // This module is only for dec2flt and flt2dec, and only public because of coretests. |
4 | // It is not intended to ever be stabilized. |
5 | #![doc (hidden)] |
6 | #![unstable ( |
7 | feature = "core_private_diy_float" , |
8 | reason = "internal routines only exposed for testing" , |
9 | issue = "none" |
10 | )] |
11 | |
12 | /// A custom 64-bit floating point type, representing `f * 2^e`. |
13 | #[derive (Copy, Clone, Debug)] |
14 | #[doc (hidden)] |
15 | pub struct Fp { |
16 | /// The integer mantissa. |
17 | pub f: u64, |
18 | /// The exponent in base 2. |
19 | pub e: i16, |
20 | } |
21 | |
22 | impl Fp { |
23 | /// Returns a correctly rounded product of itself and `other`. |
24 | pub fn mul(&self, other: &Fp) -> Fp { |
25 | const MASK: u64 = 0xffffffff; |
26 | let a = self.f >> 32; |
27 | let b = self.f & MASK; |
28 | let c = other.f >> 32; |
29 | let d = other.f & MASK; |
30 | let ac = a * c; |
31 | let bc = b * c; |
32 | let ad = a * d; |
33 | let bd = b * d; |
34 | let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */; |
35 | let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32); |
36 | let e = self.e + other.e + 64; |
37 | Fp { f, e } |
38 | } |
39 | |
40 | /// Normalizes itself so that the resulting mantissa is at least `2^63`. |
41 | pub fn normalize(&self) -> Fp { |
42 | let mut f = self.f; |
43 | let mut e = self.e; |
44 | if f >> (64 - 32) == 0 { |
45 | f <<= 32; |
46 | e -= 32; |
47 | } |
48 | if f >> (64 - 16) == 0 { |
49 | f <<= 16; |
50 | e -= 16; |
51 | } |
52 | if f >> (64 - 8) == 0 { |
53 | f <<= 8; |
54 | e -= 8; |
55 | } |
56 | if f >> (64 - 4) == 0 { |
57 | f <<= 4; |
58 | e -= 4; |
59 | } |
60 | if f >> (64 - 2) == 0 { |
61 | f <<= 2; |
62 | e -= 2; |
63 | } |
64 | if f >> (64 - 1) == 0 { |
65 | f <<= 1; |
66 | e -= 1; |
67 | } |
68 | debug_assert!(f >= (1 << 63)); |
69 | Fp { f, e } |
70 | } |
71 | |
72 | /// Normalizes itself to have the shared exponent. |
73 | /// It can only decrease the exponent (and thus increase the mantissa). |
74 | pub fn normalize_to(&self, e: i16) -> Fp { |
75 | let edelta = self.e - e; |
76 | assert!(edelta >= 0); |
77 | let edelta = edelta as usize; |
78 | assert_eq!(self.f << edelta >> edelta, self.f); |
79 | Fp { f: self.f << edelta, e } |
80 | } |
81 | } |
82 | |