Struct DoubleDouble

Source

pub struct DoubleDouble(f64, f64);

Tuple Fields§

§0: f64§1: f64

Implementations§

Source §

impl DoubleDouble

Source

fn renormalize(a0: f64, a1: f64, a2: f64) -> Self

Examples found in repository ?

crates/competitive/src/num/double_double.rs (line 74)

71    fn add(self, rhs: f64) -> Self::Output {
72        let (t0, e) = two_sum(self.0, rhs);
73        let (t1, t2) = two_sum(self.1, e);
74        Self::renormalize(t0, t1, t2)
75    }
76}
77
78impl Add<DoubleDouble> for DoubleDouble {
79    type Output = Self;
80    fn add(self, rhs: Self) -> Self::Output {
81        let (t0, e) = two_sum(self.0, rhs.0);
82        let (t1, t2) = three_two_sum(self.1, rhs.1, e);
83        Self::renormalize(t0, t1, t2)
84    }
85}
86
87impl Sub for DoubleDouble {
88    type Output = Self;
89    fn sub(self, rhs: Self) -> Self::Output {
90        self + -rhs
91    }
92}
93
94impl Neg for DoubleDouble {
95    type Output = Self;
96    fn neg(self) -> Self::Output {
97        Self(-self.0, -self.1)
98    }
99}
100
101impl Mul<f64> for DoubleDouble {
102    type Output = Self;
103    fn mul(self, rhs: f64) -> Self::Output {
104        let (t0, e0) = two_prod(self.0, rhs);
105        let p1 = self.1 * rhs;
106        let (t1, t2) = two_sum(p1, e0);
107        Self::renormalize(t0, t1, t2)
108    }
109}
110
111impl Mul<DoubleDouble> for DoubleDouble {
112    type Output = Self;
113    fn mul(self, rhs: Self) -> Self::Output {
114        let (t0, q00) = two_prod(self.0, rhs.0);
115        let (p01, q01) = two_prod(self.0, rhs.1);
116        let (p10, q10) = two_prod(self.1, rhs.0);
117        let p11 = self.1 * rhs.1;
118        let (t1, e1) = three_two_sum(q00, p01, p10);
119        let t2 = e1 + q01 + q10 + p11;
120        Self::renormalize(t0, t1, t2)
121    }
122}
123
124impl Div<DoubleDouble> for DoubleDouble {
125    type Output = Self;
126    fn div(self, rhs: Self) -> Self::Output {
127        let q0 = self.0 / rhs.0;
128        let r = self - rhs * q0;
129        let q1 = r.0 / rhs.0;
130        let r = r - rhs * q1;
131        let q2 = r.0 / rhs.0;
132        Self::renormalize(q0, q1, q2)
133    }
134}
135
136impl From<DoubleDouble> for f64 {
137    fn from(x: DoubleDouble) -> f64 {
138        x.1 + x.0
139    }
140}
141
142impl From<DoubleDouble> for i64 {
143    fn from(mut x: DoubleDouble) -> i64 {
144        let is_neg = x.0.is_sign_negative();
145        if is_neg {
146            x = -x;
147        }
148        let mut i = 0i64;
149        for k in (1..64).rev() {
150            let t = (k as f64).exp2();
151            if x.0 >= t {
152                x = x + -t;
153                i += 1 << k;
154            }
155        }
156        i += x.0.round() as i64;
157        if is_neg {
158            i = -i;
159        }
160        i
161    }
162}
163
164impl From<f64> for DoubleDouble {
165    fn from(x: f64) -> Self {
166        Self(x, 0.)
167    }
168}
169
170impl Display for DoubleDouble {
171    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
172        write!(f, "{}", Decimal::from(self.0) + Decimal::from(self.1))
173    }
174}
175
176#[derive(Debug, Clone)]
177pub enum ParseDoubleDoubleError {
178    ParseFloatError(ParseFloatError),
179    ParseDecimalError(super::decimal::convert::ParseDecimalError),
180}
181
182impl From<ParseFloatError> for ParseDoubleDoubleError {
183    fn from(e: ParseFloatError) -> Self {
184        Self::ParseFloatError(e)
185    }
186}
187
188impl From<super::decimal::convert::ParseDecimalError> for ParseDoubleDoubleError {
189    fn from(e: super::decimal::convert::ParseDecimalError) -> Self {
190        Self::ParseDecimalError(e)
191    }
192}
193
194impl FromStr for DoubleDouble {
195    type Err = ParseDoubleDoubleError;
196    fn from_str(s: &str) -> Result<Self, Self::Err> {
197        let f0: f64 = s.parse()?;
198        let d1 = Decimal::from_str(s)? - Decimal::from(f0);
199        let f1: f64 = d1.to_string().parse()?;
200        Ok(Self::renormalize(f0, f1, 0.))
201    }

Source §

fn div2(self, rhs: f64) -> Self

Examples found in repository ?

crates/competitive/src/num/double_double.rs (line 268)

263    pub fn sqrt(self) -> Self {
264        if self.is_zero() {
265            return Self::from(0.);
266        }
267        let x = Self::from(1. / self.0.sqrt());
268        let x = x + x * (Self::from(1.) - self * x * x).div2(2.);
269        let x = x + x * (Self::from(1.) - self * x * x).div2(2.);
270        let x = x + x * (Self::from(1.) - self * x * x).div2(2.);
271        x * self
272    }