computable_real/

traits.rs

use crate::{Primitive, Real};

use std::convert::From;
use std::ops::{Add, Div, Mul, Neg, Sub};
use std::str::FromStr;

use num::bigint::ParseBigIntError;
use num::{BigInt, BigRational, Num, ToPrimitive};

impl Add for Real {
    type Output = Self;

    /// Adds two real numbers by consuming them and returning a new real number.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    ///
    /// assert_eq!((Real::from(1) + Real::from(2)).render(0), "3");
    /// assert_eq!((Real::from(1) + Real::from(-1)).render(0), "0");
    /// assert_eq!((Real::pi() + Real::from(1).exp()).render(5), "5.85987");
    /// ```
    fn add(self, rhs: Self) -> Self {
        Self::new(Primitive::Add(self, rhs))
    }
}

impl Neg for Real {
    type Output = Self;

    /// Negates a real number by consuming it and returning a new real number.
    fn neg(self) -> Self {
        Self::new(Primitive::Neg(self))
    }
}

impl Sub for Real {
    type Output = Self;

    /// Subtracts two real numbers by consuming them and returning a new real
    /// number.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    ///
    /// assert_eq!((Real::from(1) - Real::from(2)).render(0), "-1");
    /// assert_eq!((Real::from(1) - Real::from(-1)).render(0), "2");
    /// assert_eq!((Real::from(1) - Real::from(1)).render(0), "0");
    /// assert_eq!((Real::pi() - Real::from(1).exp()).render(5), "0.42331");
    /// ```
    fn sub(self, rhs: Self) -> Self {
        self + -rhs
    }
}

impl Mul for Real {
    type Output = Self;

    /// Multiplies two real numbers by consuming them and returning a new real
    /// number.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    ///
    /// assert_eq!((Real::from(1) * Real::from(2)).render(0), "2");
    /// assert_eq!((Real::from(1) * Real::from(-1)).render(0), "-1");
    /// assert_eq!((Real::pi() * Real::from(-1)).render(5), "-3.14159");
    /// assert_eq!((Real::pi() * Real::from(0)).render(5), "0.00000");
    /// ```
    fn mul(self, rhs: Self) -> Self {
        Self::new(Primitive::Mul(self, rhs))
    }
}

impl Div for Real {
    type Output = Self;

    /// Divides two real numbers by consuming them and returning a new real
    /// number.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    ///
    /// assert_eq!((Real::from(1) / Real::from(2)).render(5), "0.50000");
    /// assert_eq!((Real::from(1) / Real::from(-1)).render(5), "-1.00000");
    /// assert_eq!((Real::pi() / Real::from(1).exp()).render(5), "1.15573");
    /// ```
    fn div(self, rhs: Self) -> Self {
        self.mul(Real::new(Primitive::Inv(rhs)))
    }
}

impl From<BigInt> for Real {
    /// Converts a `BigInt` into a real number.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    /// use num::BigInt;
    ///
    /// let n: BigInt = "-123456789012345678901234567890".parse().unwrap();
    /// let r: Real = n.into();
    /// assert_eq!(r.render(0), "-123456789012345678901234567890");
    /// ```
    fn from(value: BigInt) -> Self {
        Real::int(value)
    }
}

impl From<i32> for Real {
    /// Converts an `i32` into a real number.
    ///
    /// Equivalent to `Real::int(BigInt::from(value))`.
    fn from(value: i32) -> Self {
        Real::int(value.into())
    }
}

impl From<BigRational> for Real {
    /// Converts a `BigRational` into a real number.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    /// use num::{BigInt, BigRational};
    ///
    /// let a = BigRational::new(BigInt::from(1), BigInt::from(2));
    /// assert_eq!(Real::from(a).render(5), "0.50000");
    ///
    /// let b = BigRational::new(BigInt::from(-1), BigInt::from(3));
    /// assert_eq!(Real::from(b).render(5), "-0.33333");
    /// ```
    fn from(value: BigRational) -> Self {
        let (num, denom) = value.into_raw();
        Real::int(num) / Real::int(denom)
    }
}

impl From<f64> for Real {
    /// Converts an `f64` into a real number.
    ///
    /// Note that due to the inherent imprecision of floating point numbers,
    /// the conversion may not be exact.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    ///
    /// let r: Real = 3.14.into();
    /// assert_eq!(r.render(2), "3.14");
    /// assert_eq!(r.render(20), "3.14000000000000012434");
    ///
    /// let s: Real = (-0.0003).into();
    /// assert_eq!(s.render(5), "-0.00030");
    /// ```
    fn from(value: f64) -> Self {
        let bits = value.abs().to_bits() as i64;
        let mut mantissa = bits & ((1 << 52) - 1);
        let biased_exponent = (bits >> 52) as i32;
        // Instead of 1023, we adjust by an additional 52 to compensate for
        //  the fact that our mantissa is an integer.
        let exponent = biased_exponent - 1075;
        match biased_exponent {
            0 => {
                mantissa <<= 1;
            }
            _ => {
                mantissa += 1 << 52;
            }
        }
        let res = Real::int(mantissa.into()).shifted(exponent);
        if value < 0.0 {
            -res
        } else {
            res
        }
    }
}

impl From<Real> for f64 {
    /// Converts a real number into an `f64`.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    ///
    /// let pi = Real::pi();
    /// let f: f64 = pi.into();
    /// assert_eq!(f, std::f64::consts::PI);
    /// ```
    fn from(mut value: Real) -> f64 {
        // Slightly beyond -1023 - 52 = -1075
        let msd = value.iter_msd_n(-1080);
        if msd.is_none() {
            // The number is close enoug to zero so we just return zero
            return 0.0;
        }
        let prec = msd.unwrap() - 60;
        let value = value.appr(prec).value.to_f64().unwrap();
        let may_underflow = prec < -1000;
        let mut bits = value.to_bits() as i64;
        let exp_adj = (if may_underflow { prec + 96 } else { prec }) as i64;
        let exp = (bits >> 52) & 0x7ff;

        if exp + exp_adj >= 0x7ff {
            return if value.is_sign_positive() {
                f64::INFINITY
            } else {
                f64::NEG_INFINITY
            };
        }

        bits += exp_adj << 52;
        let res = f64::from_bits(bits as u64);

        if may_underflow {
            // Compensate for the extra 96 in exponent
            // Dividing by 2^48 twice instead of 2^96 for gradual underflow
            let two_48 = (1_u64 << 48) as f64;
            res / two_48 / two_48
        } else {
            res
        }
    }
}

impl From<Real> for BigInt {
    /// Converts a real number into a `BigInt`.
    ///
    /// It is guaranteed that the difference is less than 1.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    /// use num::BigInt;
    ///
    /// let a = Real::from(-42);
    /// assert_eq!(BigInt::from(a).to_string(), "-42");
    ///
    /// let b = Real::from(0.999);
    /// assert!(BigInt::from(b) <= 1.into());
    /// ```
    fn from(mut value: Real) -> BigInt {
        value.appr(0).value
    }
}

impl FromStr for Real {
    type Err = ParseBigIntError;

    /// Parses a decimal string into a real number.
    ///
    /// # Examples
    /// ```
    /// use computable_real::Real;
    /// use std::str::FromStr;
    ///
    /// let a: Real = "3.14".parse().unwrap();
    /// assert_eq!(a.render(2), "3.14");
    ///
    /// let b: Real = "-0.0000000000000000042".parse().unwrap();
    /// assert_eq!(b.render(20), "-0.00000000000000000420");
    ///
    /// let c: Real = "42".parse().unwrap();
    /// assert_eq!(c.render(0), "42");
    /// ```
    fn from_str(str: &str) -> Result<Self, Self::Err> {
        let len = str.trim().len();
        let frac_len = match str.find('.') {
            Some(i) => len - i - 1,
            None => 0,
        };
        let removed_dot = str.replace(".", "");
        let int = BigInt::from_str_radix(&removed_dot, 10)?;
        let div = BigInt::from(10).pow(frac_len as u32);
        Ok(Real::int(int) / Real::int(div))
    }
}