1#![doc(hidden)]
6#![unstable(
7    feature = "core_private_diy_float",
8    reason = "internal routines only exposed for testing",
9    issue = "none"
10)]
11
12#[derive(Copy, Clone, Debug)]
14#[doc(hidden)]
15pub struct Fp {
16    pub f: u64,
18    pub e: i16,
20}
21
22impl Fp {
23    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) ;
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    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    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}