From 2a67a5b86e3dc34193a3c414d95f00accf580e3d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Jan=20Niemier?= Date: Fri, 11 Mar 2016 00:42:46 +0100 Subject: [PATCH] Extract num-rational --- src/rational.rs | 1013 ----------------------------------------------- 1 file changed, 1013 deletions(-) delete mode 100644 src/rational.rs diff --git a/src/rational.rs b/src/rational.rs deleted file mode 100644 index 5778839..0000000 --- a/src/rational.rs +++ /dev/null @@ -1,1013 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Rational numbers - -use Integer; - -use std::cmp; -use std::error::Error; -use std::fmt; -use std::ops::{Add, Div, Mul, Neg, Rem, Sub}; -use std::str::FromStr; - -#[cfg(feature = "serde")] -use serde; - -#[cfg(feature = "bigint")] -use bigint::{BigInt, BigUint, Sign}; -use traits::{FromPrimitive, Float, PrimInt}; -use {Num, Signed, Zero, One}; - -/// Represents the ratio between 2 numbers. -#[derive(Copy, Clone, Hash, Debug)] -#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] -#[allow(missing_docs)] -pub struct Ratio { - numer: T, - denom: T -} - -/// Alias for a `Ratio` of machine-sized integers. -pub type Rational = Ratio; -pub type Rational32 = Ratio; -pub type Rational64 = Ratio; - -#[cfg(feature = "bigint")] -/// Alias for arbitrary precision rationals. -pub type BigRational = Ratio; - -impl Ratio { - /// Creates a ratio representing the integer `t`. - #[inline] - pub fn from_integer(t: T) -> Ratio { - Ratio::new_raw(t, One::one()) - } - - /// Creates a ratio without checking for `denom == 0` or reducing. - #[inline] - pub fn new_raw(numer: T, denom: T) -> Ratio { - Ratio { numer: numer, denom: denom } - } - - /// Create a new Ratio. Fails if `denom == 0`. - #[inline] - pub fn new(numer: T, denom: T) -> Ratio { - if denom == Zero::zero() { - panic!("denominator == 0"); - } - let mut ret = Ratio::new_raw(numer, denom); - ret.reduce(); - ret - } - - /// Converts to an integer. - #[inline] - pub fn to_integer(&self) -> T { - self.trunc().numer - } - - /// Gets an immutable reference to the numerator. - #[inline] - pub fn numer<'a>(&'a self) -> &'a T { - &self.numer - } - - /// Gets an immutable reference to the denominator. - #[inline] - pub fn denom<'a>(&'a self) -> &'a T { - &self.denom - } - - /// Returns true if the rational number is an integer (denominator is 1). - #[inline] - pub fn is_integer(&self) -> bool { - self.denom == One::one() - } - - /// Put self into lowest terms, with denom > 0. - fn reduce(&mut self) { - let g : T = self.numer.gcd(&self.denom); - - // FIXME(#5992): assignment operator overloads - // self.numer /= g; - self.numer = self.numer.clone() / g.clone(); - // FIXME(#5992): assignment operator overloads - // self.denom /= g; - self.denom = self.denom.clone() / g; - - // keep denom positive! - if self.denom < T::zero() { - self.numer = T::zero() - self.numer.clone(); - self.denom = T::zero() - self.denom.clone(); - } - } - - /// Returns a `reduce`d copy of self. - pub fn reduced(&self) -> Ratio { - let mut ret = self.clone(); - ret.reduce(); - ret - } - - /// Returns the reciprocal. - #[inline] - pub fn recip(&self) -> Ratio { - Ratio::new_raw(self.denom.clone(), self.numer.clone()) - } - - /// Rounds towards minus infinity. - #[inline] - pub fn floor(&self) -> Ratio { - if *self < Zero::zero() { - let one: T = One::one(); - Ratio::from_integer((self.numer.clone() - self.denom.clone() + one) / self.denom.clone()) - } else { - Ratio::from_integer(self.numer.clone() / self.denom.clone()) - } - } - - /// Rounds towards plus infinity. - #[inline] - pub fn ceil(&self) -> Ratio { - if *self < Zero::zero() { - Ratio::from_integer(self.numer.clone() / self.denom.clone()) - } else { - let one: T = One::one(); - Ratio::from_integer((self.numer.clone() + self.denom.clone() - one) / self.denom.clone()) - } - } - - /// Rounds to the nearest integer. Rounds half-way cases away from zero. - #[inline] - pub fn round(&self) -> Ratio { - let zero: Ratio = Zero::zero(); - let one: T = One::one(); - let two: T = one.clone() + one.clone(); - - // Find unsigned fractional part of rational number - let mut fractional = self.fract(); - if fractional < zero { fractional = zero - fractional }; - - // The algorithm compares the unsigned fractional part with 1/2, that - // is, a/b >= 1/2, or a >= b/2. For odd denominators, we use - // a >= (b/2)+1. This avoids overflow issues. - let half_or_larger = if fractional.denom().is_even() { - *fractional.numer() >= fractional.denom().clone() / two.clone() - } else { - *fractional.numer() >= (fractional.denom().clone() / two.clone()) + one.clone() - }; - - if half_or_larger { - let one: Ratio = One::one(); - if *self >= Zero::zero() { - self.trunc() + one - } else { - self.trunc() - one - } - } else { - self.trunc() - } - } - - /// Rounds towards zero. - #[inline] - pub fn trunc(&self) -> Ratio { - Ratio::from_integer(self.numer.clone() / self.denom.clone()) - } - - /// Returns the fractional part of a number. - #[inline] - pub fn fract(&self) -> Ratio { - Ratio::new_raw(self.numer.clone() % self.denom.clone(), self.denom.clone()) - } -} - -impl Ratio { - /// Raises the ratio to the power of an exponent - #[inline] - pub fn pow(&self, expon: i32) -> Ratio { - match expon.cmp(&0) { - cmp::Ordering::Equal => One::one(), - cmp::Ordering::Less => self.recip().pow(-expon), - cmp::Ordering::Greater => Ratio::new_raw(self.numer.pow(expon as u32), - self.denom.pow(expon as u32)), - } - } -} - -#[cfg(feature = "bigint")] -impl Ratio { - /// Converts a float into a rational number. - pub fn from_float(f: T) -> Option { - if !f.is_finite() { - return None; - } - let (mantissa, exponent, sign) = f.integer_decode(); - let bigint_sign = if sign == 1 { Sign::Plus } else { Sign::Minus }; - if exponent < 0 { - let one: BigInt = One::one(); - let denom: BigInt = one << ((-exponent) as usize); - let numer: BigUint = FromPrimitive::from_u64(mantissa).unwrap(); - Some(Ratio::new(BigInt::from_biguint(bigint_sign, numer), denom)) - } else { - let mut numer: BigUint = FromPrimitive::from_u64(mantissa).unwrap(); - numer = numer << (exponent as usize); - Some(Ratio::from_integer(BigInt::from_biguint(bigint_sign, numer))) - } - } -} - -/* Comparisons */ - -// Mathematically, comparing a/b and c/d is the same as comparing a*d and b*c, but it's very easy -// for those multiplications to overflow fixed-size integers, so we need to take care. - -impl Ord for Ratio { - #[inline] - fn cmp(&self, other: &Self) -> cmp::Ordering { - // With equal denominators, the numerators can be directly compared - if self.denom == other.denom { - let ord = self.numer.cmp(&other.numer); - return if self.denom < T::zero() { ord.reverse() } else { ord }; - } - - // With equal numerators, the denominators can be inversely compared - if self.numer == other.numer { - let ord = self.denom.cmp(&other.denom); - return if self.numer < T::zero() { ord } else { ord.reverse() }; - } - - // Unfortunately, we don't have CheckedMul to try. That could sometimes avoid all the - // division below, or even always avoid it for BigInt and BigUint. - // FIXME- future breaking change to add Checked* to Integer? - - // Compare as floored integers and remainders - let (self_int, self_rem) = self.numer.div_mod_floor(&self.denom); - let (other_int, other_rem) = other.numer.div_mod_floor(&other.denom); - match self_int.cmp(&other_int) { - cmp::Ordering::Greater => cmp::Ordering::Greater, - cmp::Ordering::Less => cmp::Ordering::Less, - cmp::Ordering::Equal => { - match (self_rem.is_zero(), other_rem.is_zero()) { - (true, true) => cmp::Ordering::Equal, - (true, false) => cmp::Ordering::Less, - (false, true) => cmp::Ordering::Greater, - (false, false) => { - // Compare the reciprocals of the remaining fractions in reverse - let self_recip = Ratio::new_raw(self.denom.clone(), self_rem); - let other_recip = Ratio::new_raw(other.denom.clone(), other_rem); - self_recip.cmp(&other_recip).reverse() - } - } - }, - } - } -} - -impl PartialOrd for Ratio { - #[inline] - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } -} - -impl PartialEq for Ratio { - #[inline] - fn eq(&self, other: &Self) -> bool { - self.cmp(other) == cmp::Ordering::Equal - } -} - -impl Eq for Ratio {} - - -macro_rules! forward_val_val_binop { - (impl $imp:ident, $method:ident) => { - impl $imp> for Ratio { - type Output = Ratio; - - #[inline] - fn $method(self, other: Ratio) -> Ratio { - (&self).$method(&other) - } - } - } -} - -macro_rules! forward_ref_val_binop { - (impl $imp:ident, $method:ident) => { - impl<'a, T> $imp> for &'a Ratio where - T: Clone + Integer - { - type Output = Ratio; - - #[inline] - fn $method(self, other: Ratio) -> Ratio { - self.$method(&other) - } - } - } -} - -macro_rules! forward_val_ref_binop { - (impl $imp:ident, $method:ident) => { - impl<'a, T> $imp<&'a Ratio> for Ratio where - T: Clone + Integer - { - type Output = Ratio; - - #[inline] - fn $method(self, other: &Ratio) -> Ratio { - (&self).$method(other) - } - } - } -} - -macro_rules! forward_all_binop { - (impl $imp:ident, $method:ident) => { - forward_val_val_binop!(impl $imp, $method); - forward_ref_val_binop!(impl $imp, $method); - forward_val_ref_binop!(impl $imp, $method); - }; -} - -/* Arithmetic */ -forward_all_binop!(impl Mul, mul); -// a/b * c/d = (a*c)/(b*d) -impl<'a, 'b, T> Mul<&'b Ratio> for &'a Ratio - where T: Clone + Integer -{ - - type Output = Ratio; - #[inline] - fn mul(self, rhs: &Ratio) -> Ratio { - Ratio::new(self.numer.clone() * rhs.numer.clone(), self.denom.clone() * rhs.denom.clone()) - } -} - -forward_all_binop!(impl Div, div); -// (a/b) / (c/d) = (a*d)/(b*c) -impl<'a, 'b, T> Div<&'b Ratio> for &'a Ratio - where T: Clone + Integer -{ - type Output = Ratio; - - #[inline] - fn div(self, rhs: &Ratio) -> Ratio { - Ratio::new(self.numer.clone() * rhs.denom.clone(), self.denom.clone() * rhs.numer.clone()) - } -} - -// Abstracts the a/b `op` c/d = (a*d `op` b*d) / (b*d) pattern -macro_rules! arith_impl { - (impl $imp:ident, $method:ident) => { - forward_all_binop!(impl $imp, $method); - impl<'a, 'b, T: Clone + Integer> - $imp<&'b Ratio> for &'a Ratio { - type Output = Ratio; - #[inline] - fn $method(self, rhs: &Ratio) -> Ratio { - Ratio::new((self.numer.clone() * rhs.denom.clone()).$method(self.denom.clone() * rhs.numer.clone()), - self.denom.clone() * rhs.denom.clone()) - } - } - } -} - -// a/b + c/d = (a*d + b*c)/(b*d) -arith_impl!(impl Add, add); - -// a/b - c/d = (a*d - b*c)/(b*d) -arith_impl!(impl Sub, sub); - -// a/b % c/d = (a*d % b*c)/(b*d) -arith_impl!(impl Rem, rem); - -impl Neg for Ratio - where T: Clone + Integer + Neg -{ - type Output = Ratio; - - #[inline] - fn neg(self) -> Ratio { - Ratio::new_raw(-self.numer, self.denom) - } -} - -impl<'a, T> Neg for &'a Ratio - where T: Clone + Integer + Neg -{ - type Output = Ratio; - - #[inline] - fn neg(self) -> Ratio { - -self.clone() - } -} - -/* Constants */ -impl - Zero for Ratio { - #[inline] - fn zero() -> Ratio { - Ratio::new_raw(Zero::zero(), One::one()) - } - - #[inline] - fn is_zero(&self) -> bool { - self.numer.is_zero() - } -} - -impl - One for Ratio { - #[inline] - fn one() -> Ratio { - Ratio::new_raw(One::one(), One::one()) - } -} - -impl Num for Ratio { - type FromStrRadixErr = ParseRatioError; - - /// Parses `numer/denom` where the numbers are in base `radix`. - fn from_str_radix(s: &str, radix: u32) -> Result, ParseRatioError> { - let split: Vec<&str> = s.splitn(2, '/').collect(); - if split.len() < 2 { - Err(ParseRatioError{kind: RatioErrorKind::ParseError}) - } else { - let a_result: Result = T::from_str_radix( - split[0], - radix).map_err(|_| ParseRatioError{kind: RatioErrorKind::ParseError}); - a_result.and_then(|a| { - let b_result: Result = - T::from_str_radix(split[1], radix).map_err( - |_| ParseRatioError{kind: RatioErrorKind::ParseError}); - b_result.and_then(|b| if b.is_zero() { - Err(ParseRatioError{kind: RatioErrorKind::ZeroDenominator}) - } else { - Ok(Ratio::new(a.clone(), b.clone())) - }) - }) - } - } -} - -impl Signed for Ratio { - #[inline] - fn abs(&self) -> Ratio { - if self.is_negative() { -self.clone() } else { self.clone() } - } - - #[inline] - fn abs_sub(&self, other: &Ratio) -> Ratio { - if *self <= *other { Zero::zero() } else { self - other } - } - - #[inline] - fn signum(&self) -> Ratio { - if self.is_positive() { - Self::one() - } else if self.is_zero() { - Self::zero() - } else { - - Self::one() - } - } - - #[inline] - fn is_positive(&self) -> bool { !self.is_negative() } - - #[inline] - fn is_negative(&self) -> bool { - self.numer.is_negative() ^ self.denom.is_negative() - } -} - -/* String conversions */ -impl fmt::Display for Ratio where - T: fmt::Display + Eq + One -{ - /// Renders as `numer/denom`. If denom=1, renders as numer. - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - if self.denom == One::one() { - write!(f, "{}", self.numer) - } else { - write!(f, "{}/{}", self.numer, self.denom) - } - } -} - -impl FromStr for Ratio { - type Err = ParseRatioError; - - /// Parses `numer/denom` or just `numer`. - fn from_str(s: &str) -> Result, ParseRatioError> { - let mut split = s.splitn(2, '/'); - - let n = try!(split.next().ok_or( - ParseRatioError{kind: RatioErrorKind::ParseError})); - let num = try!(FromStr::from_str(n).map_err( - |_| ParseRatioError{kind: RatioErrorKind::ParseError})); - - let d = split.next().unwrap_or("1"); - let den = try!(FromStr::from_str(d).map_err( - |_| ParseRatioError{kind: RatioErrorKind::ParseError})); - - if Zero::is_zero(&den) { - Err(ParseRatioError{kind: RatioErrorKind::ZeroDenominator}) - } else { - Ok(Ratio::new(num, den)) - } - } -} - -#[cfg(feature = "serde")] -impl serde::Serialize for Ratio - where T: serde::Serialize + Clone + Integer + PartialOrd -{ - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where - S: serde::Serializer - { - (self.numer(), self.denom()).serialize(serializer) - } -} - -#[cfg(feature = "serde")] -impl serde::Deserialize for Ratio - where T: serde::Deserialize + Clone + Integer + PartialOrd -{ - fn deserialize(deserializer: &mut D) -> Result where - D: serde::Deserializer, - { - let (numer, denom) = try!(serde::Deserialize::deserialize(deserializer)); - if denom == Zero::zero() { - Err(serde::de::Error::invalid_value("denominator is zero")) - } else { - Ok(Ratio::new_raw(numer, denom)) - } - } -} - -// FIXME: Bubble up specific errors -#[derive(Copy, Clone, Debug, PartialEq)] -pub struct ParseRatioError { kind: RatioErrorKind } - -#[derive(Copy, Clone, Debug, PartialEq)] -enum RatioErrorKind { - ParseError, - ZeroDenominator, -} - -impl fmt::Display for ParseRatioError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.description().fmt(f) - } -} - -impl Error for ParseRatioError { - fn description(&self) -> &str { self.kind.description() } -} - -impl RatioErrorKind { - fn description(&self) -> &'static str { - match *self { - RatioErrorKind::ParseError => "failed to parse integer", - RatioErrorKind::ZeroDenominator => "zero value denominator", - } - } -} - -#[cfg(test)] -mod test { - - use super::{Ratio, Rational}; - #[cfg(feature = "bigint")] - use super::BigRational; - use std::str::FromStr; - use std::i32; - use {Zero, One, Signed, FromPrimitive, Float}; - - pub const _0 : Rational = Ratio { numer: 0, denom: 1}; - pub const _1 : Rational = Ratio { numer: 1, denom: 1}; - pub const _2: Rational = Ratio { numer: 2, denom: 1}; - pub const _1_2: Rational = Ratio { numer: 1, denom: 2}; - pub const _3_2: Rational = Ratio { numer: 3, denom: 2}; - pub const _NEG1_2: Rational = Ratio { numer: -1, denom: 2}; - pub const _1_3: Rational = Ratio { numer: 1, denom: 3}; - pub const _NEG1_3: Rational = Ratio { numer: -1, denom: 3}; - pub const _2_3: Rational = Ratio { numer: 2, denom: 3}; - pub const _NEG2_3: Rational = Ratio { numer: -2, denom: 3}; - - #[cfg(feature = "bigint")] - pub fn to_big(n: Rational) -> BigRational { - Ratio::new( - FromPrimitive::from_isize(n.numer).unwrap(), - FromPrimitive::from_isize(n.denom).unwrap() - ) - } - #[cfg(not(feature = "bigint"))] - pub fn to_big(n: Rational) -> Rational { - Ratio::new( - FromPrimitive::from_isize(n.numer).unwrap(), - FromPrimitive::from_isize(n.denom).unwrap() - ) - } - - #[test] - fn test_test_constants() { - // check our constants are what Ratio::new etc. would make. - assert_eq!(_0, Zero::zero()); - assert_eq!(_1, One::one()); - assert_eq!(_2, Ratio::from_integer(2)); - assert_eq!(_1_2, Ratio::new(1,2)); - assert_eq!(_3_2, Ratio::new(3,2)); - assert_eq!(_NEG1_2, Ratio::new(-1,2)); - } - - #[test] - fn test_new_reduce() { - let one22 = Ratio::new(2,2); - - assert_eq!(one22, One::one()); - } - #[test] - #[should_panic] - fn test_new_zero() { - let _a = Ratio::new(1,0); - } - - - #[test] - fn test_cmp() { - assert!(_0 == _0 && _1 == _1); - assert!(_0 != _1 && _1 != _0); - assert!(_0 < _1 && !(_1 < _0)); - assert!(_1 > _0 && !(_0 > _1)); - - assert!(_0 <= _0 && _1 <= _1); - assert!(_0 <= _1 && !(_1 <= _0)); - - assert!(_0 >= _0 && _1 >= _1); - assert!(_1 >= _0 && !(_0 >= _1)); - } - - #[test] - fn test_cmp_overflow() { - use std::cmp::Ordering; - - // issue #7 example: - let big = Ratio::new(128u8, 1); - let small = big.recip(); - assert!(big > small); - - // try a few that are closer together - // (some matching numer, some matching denom, some neither) - let ratios = vec![ - Ratio::new(125_i8, 127_i8), - Ratio::new(63_i8, 64_i8), - Ratio::new(124_i8, 125_i8), - Ratio::new(125_i8, 126_i8), - Ratio::new(126_i8, 127_i8), - Ratio::new(127_i8, 126_i8), - ]; - - fn check_cmp(a: Ratio, b: Ratio, ord: Ordering) { - println!("comparing {} and {}", a, b); - assert_eq!(a.cmp(&b), ord); - assert_eq!(b.cmp(&a), ord.reverse()); - } - - for (i, &a) in ratios.iter().enumerate() { - check_cmp(a, a, Ordering::Equal); - check_cmp(-a, a, Ordering::Less); - for &b in &ratios[i+1..] { - check_cmp(a, b, Ordering::Less); - check_cmp(-a, -b, Ordering::Greater); - check_cmp(a.recip(), b.recip(), Ordering::Greater); - check_cmp(-a.recip(), -b.recip(), Ordering::Less); - } - } - } - - #[test] - fn test_to_integer() { - assert_eq!(_0.to_integer(), 0); - assert_eq!(_1.to_integer(), 1); - assert_eq!(_2.to_integer(), 2); - assert_eq!(_1_2.to_integer(), 0); - assert_eq!(_3_2.to_integer(), 1); - assert_eq!(_NEG1_2.to_integer(), 0); - } - - - #[test] - fn test_numer() { - assert_eq!(_0.numer(), &0); - assert_eq!(_1.numer(), &1); - assert_eq!(_2.numer(), &2); - assert_eq!(_1_2.numer(), &1); - assert_eq!(_3_2.numer(), &3); - assert_eq!(_NEG1_2.numer(), &(-1)); - } - #[test] - fn test_denom() { - assert_eq!(_0.denom(), &1); - assert_eq!(_1.denom(), &1); - assert_eq!(_2.denom(), &1); - assert_eq!(_1_2.denom(), &2); - assert_eq!(_3_2.denom(), &2); - assert_eq!(_NEG1_2.denom(), &2); - } - - - #[test] - fn test_is_integer() { - assert!(_0.is_integer()); - assert!(_1.is_integer()); - assert!(_2.is_integer()); - assert!(!_1_2.is_integer()); - assert!(!_3_2.is_integer()); - assert!(!_NEG1_2.is_integer()); - } - - #[test] - fn test_show() { - assert_eq!(format!("{}", _2), "2".to_string()); - assert_eq!(format!("{}", _1_2), "1/2".to_string()); - assert_eq!(format!("{}", _0), "0".to_string()); - assert_eq!(format!("{}", Ratio::from_integer(-2)), "-2".to_string()); - } - - mod arith { - use super::{_0, _1, _2, _1_2, _3_2, _NEG1_2, to_big}; - use super::super::{Ratio, Rational}; - - #[test] - fn test_add() { - fn test(a: Rational, b: Rational, c: Rational) { - assert_eq!(a + b, c); - assert_eq!(to_big(a) + to_big(b), to_big(c)); - } - - test(_1, _1_2, _3_2); - test(_1, _1, _2); - test(_1_2, _3_2, _2); - test(_1_2, _NEG1_2, _0); - } - - #[test] - fn test_sub() { - fn test(a: Rational, b: Rational, c: Rational) { - assert_eq!(a - b, c); - assert_eq!(to_big(a) - to_big(b), to_big(c)) - } - - test(_1, _1_2, _1_2); - test(_3_2, _1_2, _1); - test(_1, _NEG1_2, _3_2); - } - - #[test] - fn test_mul() { - fn test(a: Rational, b: Rational, c: Rational) { - assert_eq!(a * b, c); - assert_eq!(to_big(a) * to_big(b), to_big(c)) - } - - test(_1, _1_2, _1_2); - test(_1_2, _3_2, Ratio::new(3,4)); - test(_1_2, _NEG1_2, Ratio::new(-1, 4)); - } - - #[test] - fn test_div() { - fn test(a: Rational, b: Rational, c: Rational) { - assert_eq!(a / b, c); - assert_eq!(to_big(a) / to_big(b), to_big(c)) - } - - test(_1, _1_2, _2); - test(_3_2, _1_2, _1 + _2); - test(_1, _NEG1_2, _NEG1_2 + _NEG1_2 + _NEG1_2 + _NEG1_2); - } - - #[test] - fn test_rem() { - fn test(a: Rational, b: Rational, c: Rational) { - assert_eq!(a % b, c); - assert_eq!(to_big(a) % to_big(b), to_big(c)) - } - - test(_3_2, _1, _1_2); - test(_2, _NEG1_2, _0); - test(_1_2, _2, _1_2); - } - - #[test] - fn test_neg() { - fn test(a: Rational, b: Rational) { - assert_eq!(-a, b); - assert_eq!(-to_big(a), to_big(b)) - } - - test(_0, _0); - test(_1_2, _NEG1_2); - test(-_1, _1); - } - #[test] - fn test_zero() { - assert_eq!(_0 + _0, _0); - assert_eq!(_0 * _0, _0); - assert_eq!(_0 * _1, _0); - assert_eq!(_0 / _NEG1_2, _0); - assert_eq!(_0 - _0, _0); - } - #[test] - #[should_panic] - fn test_div_0() { - let _a = _1 / _0; - } - } - - #[test] - fn test_round() { - assert_eq!(_1_3.ceil(), _1); - assert_eq!(_1_3.floor(), _0); - assert_eq!(_1_3.round(), _0); - assert_eq!(_1_3.trunc(), _0); - - assert_eq!(_NEG1_3.ceil(), _0); - assert_eq!(_NEG1_3.floor(), -_1); - assert_eq!(_NEG1_3.round(), _0); - assert_eq!(_NEG1_3.trunc(), _0); - - assert_eq!(_2_3.ceil(), _1); - assert_eq!(_2_3.floor(), _0); - assert_eq!(_2_3.round(), _1); - assert_eq!(_2_3.trunc(), _0); - - assert_eq!(_NEG2_3.ceil(), _0); - assert_eq!(_NEG2_3.floor(), -_1); - assert_eq!(_NEG2_3.round(), -_1); - assert_eq!(_NEG2_3.trunc(), _0); - - assert_eq!(_1_2.ceil(), _1); - assert_eq!(_1_2.floor(), _0); - assert_eq!(_1_2.round(), _1); - assert_eq!(_1_2.trunc(), _0); - - assert_eq!(_NEG1_2.ceil(), _0); - assert_eq!(_NEG1_2.floor(), -_1); - assert_eq!(_NEG1_2.round(), -_1); - assert_eq!(_NEG1_2.trunc(), _0); - - assert_eq!(_1.ceil(), _1); - assert_eq!(_1.floor(), _1); - assert_eq!(_1.round(), _1); - assert_eq!(_1.trunc(), _1); - - // Overflow checks - - let _neg1 = Ratio::from_integer(-1); - let _large_rat1 = Ratio::new(i32::MAX, i32::MAX-1); - let _large_rat2 = Ratio::new(i32::MAX-1, i32::MAX); - let _large_rat3 = Ratio::new(i32::MIN+2, i32::MIN+1); - let _large_rat4 = Ratio::new(i32::MIN+1, i32::MIN+2); - let _large_rat5 = Ratio::new(i32::MIN+2, i32::MAX); - let _large_rat6 = Ratio::new(i32::MAX, i32::MIN+2); - let _large_rat7 = Ratio::new(1, i32::MIN+1); - let _large_rat8 = Ratio::new(1, i32::MAX); - - assert_eq!(_large_rat1.round(), One::one()); - assert_eq!(_large_rat2.round(), One::one()); - assert_eq!(_large_rat3.round(), One::one()); - assert_eq!(_large_rat4.round(), One::one()); - assert_eq!(_large_rat5.round(), _neg1); - assert_eq!(_large_rat6.round(), _neg1); - assert_eq!(_large_rat7.round(), Zero::zero()); - assert_eq!(_large_rat8.round(), Zero::zero()); - } - - #[test] - fn test_fract() { - assert_eq!(_1.fract(), _0); - assert_eq!(_NEG1_2.fract(), _NEG1_2); - assert_eq!(_1_2.fract(), _1_2); - assert_eq!(_3_2.fract(), _1_2); - } - - #[test] - fn test_recip() { - assert_eq!(_1 * _1.recip(), _1); - assert_eq!(_2 * _2.recip(), _1); - assert_eq!(_1_2 * _1_2.recip(), _1); - assert_eq!(_3_2 * _3_2.recip(), _1); - assert_eq!(_NEG1_2 * _NEG1_2.recip(), _1); - } - - #[test] - fn test_pow() { - assert_eq!(_1_2.pow(2), Ratio::new(1, 4)); - assert_eq!(_1_2.pow(-2), Ratio::new(4, 1)); - assert_eq!(_1.pow(1), _1); - assert_eq!(_NEG1_2.pow(2), _1_2.pow(2)); - assert_eq!(_NEG1_2.pow(3), -_1_2.pow(3)); - assert_eq!(_3_2.pow(0), _1); - assert_eq!(_3_2.pow(-1), _3_2.recip()); - assert_eq!(_3_2.pow(3), Ratio::new(27, 8)); - } - - #[test] - fn test_to_from_str() { - fn test(r: Rational, s: String) { - assert_eq!(FromStr::from_str(&s), Ok(r)); - assert_eq!(r.to_string(), s); - } - test(_1, "1".to_string()); - test(_0, "0".to_string()); - test(_1_2, "1/2".to_string()); - test(_3_2, "3/2".to_string()); - test(_2, "2".to_string()); - test(_NEG1_2, "-1/2".to_string()); - } - #[test] - fn test_from_str_fail() { - fn test(s: &str) { - let rational: Result = FromStr::from_str(s); - assert!(rational.is_err()); - } - - let xs = ["0 /1", "abc", "", "1/", "--1/2","3/2/1", "1/0"]; - for &s in xs.iter() { - test(s); - } - } - - #[cfg(feature = "bigint")] - #[test] - fn test_from_float() { - fn test(given: T, (numer, denom): (&str, &str)) { - let ratio: BigRational = Ratio::from_float(given).unwrap(); - assert_eq!(ratio, Ratio::new( - FromStr::from_str(numer).unwrap(), - FromStr::from_str(denom).unwrap())); - } - - // f32 - test(3.14159265359f32, ("13176795", "4194304")); - test(2f32.powf(100.), ("1267650600228229401496703205376", "1")); - test(-2f32.powf(100.), ("-1267650600228229401496703205376", "1")); - test(1.0 / 2f32.powf(100.), ("1", "1267650600228229401496703205376")); - test(684729.48391f32, ("1369459", "2")); - test(-8573.5918555f32, ("-4389679", "512")); - - // f64 - test(3.14159265359f64, ("3537118876014453", "1125899906842624")); - test(2f64.powf(100.), ("1267650600228229401496703205376", "1")); - test(-2f64.powf(100.), ("-1267650600228229401496703205376", "1")); - test(684729.48391f64, ("367611342500051", "536870912")); - test(-8573.5918555f64, ("-4713381968463931", "549755813888")); - test(1.0 / 2f64.powf(100.), ("1", "1267650600228229401496703205376")); - } - - #[cfg(feature = "bigint")] - #[test] - fn test_from_float_fail() { - use std::{f32, f64}; - - assert_eq!(Ratio::from_float(f32::NAN), None); - assert_eq!(Ratio::from_float(f32::INFINITY), None); - assert_eq!(Ratio::from_float(f32::NEG_INFINITY), None); - assert_eq!(Ratio::from_float(f64::NAN), None); - assert_eq!(Ratio::from_float(f64::INFINITY), None); - assert_eq!(Ratio::from_float(f64::NEG_INFINITY), None); - } - - #[test] - fn test_signed() { - assert_eq!(_NEG1_2.abs(), _1_2); - assert_eq!(_3_2.abs_sub(&_1_2), _1); - assert_eq!(_1_2.abs_sub(&_3_2), Zero::zero()); - assert_eq!(_1_2.signum(), One::one()); - assert_eq!(_NEG1_2.signum(), - ::one::>()); - assert!(_NEG1_2.is_negative()); - assert!(! _NEG1_2.is_positive()); - assert!(! _1_2.is_negative()); - } - - #[test] - fn test_hash() { - assert!(::hash(&_0) != ::hash(&_1)); - assert!(::hash(&_0) != ::hash(&_3_2)); - } -}