diff --git a/.multirust.sh b/.multirust.sh index 06cfef2..0372bca 100755 --- a/.multirust.sh +++ b/.multirust.sh @@ -7,7 +7,7 @@ set -ex for toolchain in 1.0.0 beta nightly; do run="multirust run $toolchain" $run cargo build --verbose - $run cargo test --verbose + $run make test $run .travis/test_features.sh if [ $toolchain = nightly ]; then $run .travis/test_nightly.sh diff --git a/.travis.yml b/.travis.yml index fa2027b..80df3af 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,11 +6,10 @@ rust: sudo: false script: - cargo build --verbose - - cargo test --verbose + - make test - .travis/test_features.sh - | - [ $TRAVIS_RUST_VERSION != nightly ] || - .travis/test_nightly.sh + [ $TRAVIS_RUST_VERSION != nightly ] || .travis/test_nightly.sh - cargo doc after_success: | [ $TRAVIS_BRANCH = master ] && diff --git a/.travis/test_features.sh b/.travis/test_features.sh index 150ac41..109fd50 100755 --- a/.travis/test_features.sh +++ b/.travis/test_features.sh @@ -4,6 +4,4 @@ set -ex for feature in '' bigint rational complex; do cargo build --verbose --no-default-features --features="$feature" - cargo test --verbose --no-default-features --features="$feature" done - diff --git a/.travis/test_nightly.sh b/.travis/test_nightly.sh index 475dfc1..43a0fec 100755 --- a/.travis/test_nightly.sh +++ b/.travis/test_nightly.sh @@ -4,4 +4,4 @@ set -ex cargo bench --verbose -cargo test --verbose --manifest-path=num-macros/Cargo.toml +cargo test --verbose --manifest-path=macros/Cargo.toml diff --git a/Cargo.toml b/Cargo.toml index fdacaef..fdb939a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,38 +1,63 @@ [package] - +authors = ["The Rust Project Developers"] +description = "A collection of numeric types and traits for Rust, including bigint,\ncomplex, rational, range iterators, generic integers, and more!\n" +documentation = "http://rust-num.github.io/num" +homepage = "https://github.com/rust-num/num" +keywords = ["mathematics", "numerics"] +license = "MIT/Apache-2.0" +repository = "https://github.com/rust-num/num" name = "num" version = "0.1.31" -authors = ["The Rust Project Developers"] -license = "MIT/Apache-2.0" -homepage = "https://github.com/rust-num/num" -repository = "https://github.com/rust-num/num" -documentation = "http://rust-num.github.io/num" -keywords = ["mathematics", "numerics"] -description = """ -A collection of numeric types and traits for Rust, including bigint, -complex, rational, range iterators, generic integers, and more! -""" - -[dependencies] -rand = { version = "0.3.8", optional = true } -rustc-serialize = { version = "0.3.13", optional = true } -serde = { version = "^0.7.0", optional = true } - -[dev-dependencies] -# Some tests of non-rand functionality still use rand because the tests -# themselves are randomized. -rand = { version = "0.3.8" } - -[features] - -complex = [] -rational = [] -bigint = [] -default = ["bigint", "complex", "rand", "rational", "rustc-serialize"] [[bench]] name = "bigint" [[bench]] -name = "shootout-pidigits" harness = false +name = "shootout-pidigits" + +[dependencies] + +[dependencies.num-bigint] +optional = true +path = "bigint" + +[dependencies.num-complex] +optional = true +path = "complex" + +[dependencies.num-integer] +path = "./integer" + +[dependencies.num-iter] +optional = false +path = "iter" + +[dependencies.num-rational] +optional = true +path = "rational" + +[dependencies.num-traits] +path = "./traits" + +[dev-dependencies] + +[dev-dependencies.rand] +version = "0.3.8" + +[features] +bigint = ["num-bigint"] +complex = ["num-complex"] +rational = ["num-rational"] +default = ["bigint", "complex", "rational", "rustc-serialize"] + +serde = [ + "num-bigint/serde", + "num-complex/serde", + "num-rational/serde" +] +rustc-serialize = [ + "num-bigint/rustc-serialize", + "num-complex/rustc-serialize", + "num-rational/rustc-serialize" +] diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..bce28aa --- /dev/null +++ b/Makefile @@ -0,0 +1,14 @@ +CARGO_CMD ?= cargo + +packages = bigint complex integer iter rational traits + +test: + $(MAKE) run-all TASK="test" + +run-all: $(packages) + $(CARGO_CMD) $(TASK) + +$(packages): + $(CARGO_CMD) $(TASK) --manifest-path $@/Cargo.toml + +.PHONY: $(packages) test diff --git a/bigint/Cargo.toml b/bigint/Cargo.toml new file mode 100644 index 0000000..2d2dda0 --- /dev/null +++ b/bigint/Cargo.toml @@ -0,0 +1,33 @@ +[package] +authors = ["The Rust Project Developers"] +description = "Big integer implementation for Rust" +documentation = "http://rust-num.github.io/num" +homepage = "https://github.com/rust-num/num" +keywords = ["mathematics", "numerics"] +license = "MIT/Apache-2.0" +name = "num-bigint" +repository = "https://github.com/rust-num/num" +version = "0.1.0" + +[dependencies] + +[dependencies.num-integer] +path = "../integer" + +[dependencies.num-traits] +path = "../traits" + +[dependencies.rand] +optional = true +version = "0.3.14" + +[dependencies.rustc-serialize] +optional = true +version = "0.3.19" + +[dependencies.serde] +optional = true +version = "0.7.0" + +[features] +default = ["rand", "rustc-serialize"] diff --git a/src/bigint.rs b/bigint/src/lib.rs similarity index 81% rename from src/bigint.rs rename to bigint/src/lib.rs index ede5e78..effb3ab 100644 --- a/src/bigint.rs +++ b/bigint/src/lib.rs @@ -19,7 +19,12 @@ //! ## Example //! //! ```rust -//! use num::{BigUint, Zero, One}; +//! extern crate num_bigint; +//! extern crate num_traits; +//! +//! # fn main() { +//! use num_bigint::BigUint; +//! use num_traits::{Zero, One}; //! use std::mem::replace; //! //! // Calculate large fibonacci numbers. @@ -36,17 +41,18 @@ //! //! // This is a very large number. //! println!("fib(1000) = {}", fib(1000)); +//! # } //! ``` //! //! It's easy to generate large random numbers: //! //! ```rust //! extern crate rand; -//! extern crate num; +//! extern crate num_bigint as bigint; //! //! # #[cfg(feature = "rand")] //! # fn main() { -//! use num::bigint::{ToBigInt, RandBigInt}; +//! use bigint::{ToBigInt, RandBigInt}; //! //! let mut rng = rand::thread_rng(); //! let a = rng.gen_bigint(1000); @@ -64,7 +70,15 @@ //! # } //! ``` -use Integer; +#[cfg(any(feature = "rand", test))] +extern crate rand; +#[cfg(feature = "rustc-serialize")] +extern crate rustc_serialize; +#[cfg(feature = "serde")] +extern crate serde; + +extern crate num_integer as integer; +extern crate num_traits as traits; use std::borrow::Cow; use std::default::Default; @@ -74,6 +88,8 @@ use std::num::ParseIntError; use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Rem, Shl, Shr, Sub}; use std::str::{self, FromStr}; use std::fmt; +#[cfg(test)] +use std::hash; use std::cmp::Ordering::{self, Less, Greater, Equal}; use std::{f32, f64}; use std::{u8, i64, u64}; @@ -88,10 +104,10 @@ use serde; #[cfg(any(feature = "rand", test))] use rand::Rng; -use traits::{ToPrimitive, FromPrimitive}; -use traits::Float; +use integer::Integer; +use traits::{ToPrimitive, FromPrimitive, Float, Num, Unsigned, CheckedAdd, CheckedSub, CheckedMul, + CheckedDiv, Signed, Zero, One}; -use {Num, Unsigned, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, Signed, Zero, One}; use self::Sign::{Minus, NoSign, Plus}; /// A `BigDigit` is a `BigUint`'s composing element. @@ -115,9 +131,13 @@ pub mod big_digit { const LO_MASK: DoubleBigDigit = (-1i32 as DoubleBigDigit) >> BITS; #[inline] - fn get_hi(n: DoubleBigDigit) -> BigDigit { (n >> BITS) as BigDigit } + fn get_hi(n: DoubleBigDigit) -> BigDigit { + (n >> BITS) as BigDigit + } #[inline] - fn get_lo(n: DoubleBigDigit) -> BigDigit { (n & LO_MASK) as BigDigit } + fn get_lo(n: DoubleBigDigit) -> BigDigit { + (n & LO_MASK) as BigDigit + } /// Split one `DoubleBigDigit` into two `BigDigit`s. #[inline] @@ -132,17 +152,14 @@ pub mod big_digit { } } -/* - * Generic functions for add/subtract/multiply with carry/borrow: - */ +// Generic functions for add/subtract/multiply with carry/borrow: +// // Add with carry: #[inline] fn adc(a: BigDigit, b: BigDigit, carry: &mut BigDigit) -> BigDigit { - let (hi, lo) = big_digit::from_doublebigdigit( - (a as DoubleBigDigit) + - (b as DoubleBigDigit) + - (*carry as DoubleBigDigit)); + let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) + (b as DoubleBigDigit) + + (*carry as DoubleBigDigit)); *carry = hi; lo @@ -151,25 +168,25 @@ fn adc(a: BigDigit, b: BigDigit, carry: &mut BigDigit) -> BigDigit { // Subtract with borrow: #[inline] fn sbb(a: BigDigit, b: BigDigit, borrow: &mut BigDigit) -> BigDigit { - let (hi, lo) = big_digit::from_doublebigdigit( - big_digit::BASE - + (a as DoubleBigDigit) - - (b as DoubleBigDigit) - - (*borrow as DoubleBigDigit)); - /* - hi * (base) + lo == 1*(base) + ai - bi - borrow - => ai - bi - borrow < 0 <=> hi == 0 - */ - *borrow = if hi == 0 { 1 } else { 0 }; + let (hi, lo) = big_digit::from_doublebigdigit(big_digit::BASE + (a as DoubleBigDigit) - + (b as DoubleBigDigit) - + (*borrow as DoubleBigDigit)); + // hi * (base) + lo == 1*(base) + ai - bi - borrow + // => ai - bi - borrow < 0 <=> hi == 0 + // + *borrow = if hi == 0 { + 1 + } else { + 0 + }; lo } #[inline] fn mac_with_carry(a: BigDigit, b: BigDigit, c: BigDigit, carry: &mut BigDigit) -> BigDigit { - let (hi, lo) = big_digit::from_doublebigdigit( - (a as DoubleBigDigit) + - (b as DoubleBigDigit) * (c as DoubleBigDigit) + - (*carry as DoubleBigDigit)); + let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) + + (b as DoubleBigDigit) * (c as DoubleBigDigit) + + (*carry as DoubleBigDigit)); *carry = hi; lo } @@ -196,13 +213,16 @@ fn div_wide(hi: BigDigit, lo: BigDigit, divisor: BigDigit) -> (BigDigit, BigDigi #[derive(Clone, Debug, Hash)] #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] pub struct BigUint { - data: Vec + data: Vec, } impl PartialEq for BigUint { #[inline] fn eq(&self, other: &BigUint) -> bool { - match self.cmp(other) { Equal => true, _ => false } + match self.cmp(other) { + Equal => true, + _ => false, + } } } impl Eq for BigUint {} @@ -219,12 +239,20 @@ fn cmp_slice(a: &[BigDigit], b: &[BigDigit]) -> Ordering { debug_assert!(b.last() != Some(&0)); let (a_len, b_len) = (a.len(), b.len()); - if a_len < b_len { return Less; } - if a_len > b_len { return Greater; } + if a_len < b_len { + return Less; + } + if a_len > b_len { + return Greater; + } for (&ai, &bi) in a.iter().rev().zip(b.iter().rev()) { - if ai < bi { return Less; } - if ai > bi { return Greater; } + if ai < bi { + return Less; + } + if ai > bi { + return Greater; + } } return Equal; } @@ -238,7 +266,9 @@ impl Ord for BigUint { impl Default for BigUint { #[inline] - fn default() -> BigUint { Zero::zero() } + fn default() -> BigUint { + Zero::zero() + } } impl fmt::Display for BigUint { @@ -287,9 +317,11 @@ fn from_bitwise_digits_le(v: &[u8], bits: usize) -> BigUint { let digits_per_big_digit = big_digit::BITS / bits; - let data = v.chunks(digits_per_big_digit).map(|chunk| { - chunk.iter().rev().fold(0u32, |acc, &c| (acc << bits) | c as BigDigit) - }).collect(); + let data = v.chunks(digits_per_big_digit) + .map(|chunk| { + chunk.iter().rev().fold(0u32, |acc, &c| (acc << bits) | c as BigDigit) + }) + .collect(); BigUint::new(data) } @@ -338,7 +370,11 @@ fn from_radix_digits_be(v: &[u8], radix: u32) -> BigUint { let base = base as BigDigit; let r = v.len() % power; - let i = if r == 0 { power } else { r }; + let i = if r == 0 { + power + } else { + r + }; let (head, tail) = v.split_at(i); let first = head.iter().fold(0, |acc, &d| acc * radix + d as BigDigit); @@ -372,7 +408,9 @@ impl Num for BigUint { let mut s = s; if s.starts_with('+') { let tail = &s[1..]; - if !tail.starts_with('+') { s = tail } + if !tail.starts_with('+') { + s = tail + } } if s.is_empty() { @@ -385,9 +423,9 @@ impl Num for BigUint { let mut v = Vec::with_capacity(s.len()); for b in s.bytes() { let d = match b { - b'0' ... b'9' => b - b'0', - b'a' ... b'z' => b - b'a' + 10, - b'A' ... b'Z' => b - b'A' + 10, + b'0'...b'9' => b - b'0', + b'a'...b'z' => b - b'a' + 10, + b'A'...b'Z' => b - b'A' + 10, _ => u8::MAX, }; if d < radix as u8 { @@ -611,7 +649,7 @@ fn biguint_shl(n: Cow, bits: usize) -> BigUint { data.extend(repeat(0).take(n_unit)); data.extend(n.data.iter().cloned()); data - }, + } }; let n_bits = bits % big_digit::BITS; @@ -651,7 +689,9 @@ impl<'a> Shl for &'a BigUint { #[inline] fn biguint_shr(n: Cow, bits: usize) -> BigUint { let n_unit = bits / big_digit::BITS; - if n_unit >= n.data.len() { return Zero::zero(); } + if n_unit >= n.data.len() { + return Zero::zero(); + } let mut data = match n_unit { 0 => n.into_owned().data, _ => n.data[n_unit..].to_vec(), @@ -690,15 +730,21 @@ impl<'a> Shr for &'a BigUint { impl Zero for BigUint { #[inline] - fn zero() -> BigUint { BigUint::new(Vec::new()) } + fn zero() -> BigUint { + BigUint::new(Vec::new()) + } #[inline] - fn is_zero(&self) -> bool { self.data.is_empty() } + fn is_zero(&self) -> bool { + self.data.is_empty() + } } impl One for BigUint { #[inline] - fn one() -> BigUint { BigUint::new(vec!(1)) } + fn one() -> BigUint { + BigUint::new(vec![1]) + } } impl Unsigned for BigUint {} @@ -737,34 +783,33 @@ fn add2(a: &mut [BigDigit], b: &[BigDigit]) { debug_assert!(carry == 0); } -/* - * We'd really prefer to avoid using add2/sub2 directly as much as possible - since they make the - * caller entirely responsible for ensuring a's vector is big enough, and that the result is - * normalized, they're rather error prone and verbose: - * - * We could implement the Add and Sub traits for BigUint + BigDigit slices, like below - this works - * great, except that then it becomes the module's public interface, which we probably don't want: - * - * I'm keeping the code commented out, because I think this is worth revisiting: - -impl<'a> Add<&'a [BigDigit]> for BigUint { - type Output = BigUint; - - fn add(mut self, other: &[BigDigit]) -> BigUint { - if self.data.len() < other.len() { - let extra = other.len() - self.data.len(); - self.data.extend(repeat(0).take(extra)); - } - - let carry = __add2(&mut self.data[..], other); - if carry != 0 { - self.data.push(carry); - } - - self - } -} - */ +// We'd really prefer to avoid using add2/sub2 directly as much as possible - since they make the +// caller entirely responsible for ensuring a's vector is big enough, and that the result is +// normalized, they're rather error prone and verbose: +// +// We could implement the Add and Sub traits for BigUint + BigDigit slices, like below - this works +// great, except that then it becomes the module's public interface, which we probably don't want: +// +// I'm keeping the code commented out, because I think this is worth revisiting: +// +// impl<'a> Add<&'a [BigDigit]> for BigUint { +// type Output = BigUint; +// +// fn add(mut self, other: &[BigDigit]) -> BigUint { +// if self.data.len() < other.len() { +// let extra = other.len() - self.data.len(); +// self.data.extend(repeat(0).take(extra)); +// } +// +// let carry = __add2(&mut self.data[..], other); +// if carry != 0 { +// self.data.push(carry); +// } +// +// self +// } +// } +// impl<'a> Add<&'a BigUint> for BigUint { type Output = BigUint; @@ -800,7 +845,7 @@ fn sub2(a: &mut [BigDigit], b: &[BigDigit]) { } } - /* note: we're _required_ to fail on underflow */ + // note: we're _required_ to fail on underflow assert!(borrow == 0 && b_iter.all(|x| *x == 0), "Cannot subtract b from a because b is larger than a."); } @@ -824,13 +869,13 @@ fn sub_sign(a: &[BigDigit], b: &[BigDigit]) -> BigInt { let mut ret = BigUint::from_slice(a); sub2(&mut ret.data[..], b); BigInt::from_biguint(Plus, ret.normalize()) - }, - Less => { + } + Less => { let mut ret = BigUint::from_slice(b); sub2(&mut ret.data[..], a); BigInt::from_biguint(Minus, ret.normalize()) - }, - _ => Zero::zero(), + } + _ => Zero::zero(), } } @@ -839,7 +884,9 @@ forward_all_binop_to_ref_ref!(impl Mul for BigUint, mul); /// Three argument multiply accumulate: /// acc += b * c fn mac_digit(acc: &mut [BigDigit], b: &[BigDigit], c: BigDigit) { - if c == 0 { return; } + if c == 0 { + return; + } let mut b_iter = b.iter(); let mut carry = 0; @@ -860,11 +907,14 @@ fn mac_digit(acc: &mut [BigDigit], b: &[BigDigit], c: BigDigit) { /// Three argument multiply accumulate: /// acc += b * c fn mac3(acc: &mut [BigDigit], b: &[BigDigit], c: &[BigDigit]) { - let (x, y) = if b.len() < c.len() { (b, c) } else { (c, b) }; + let (x, y) = if b.len() < c.len() { + (b, c) + } else { + (c, b) + }; - /* - * Karatsuba multiplication is slower than long multiplication for small x and y: - */ + // Karatsuba multiplication is slower than long multiplication for small x and y: + // if x.len() <= 4 { for (i, xi) in x.iter().enumerate() { mac_digit(&mut acc[i..], y, *xi); @@ -1046,14 +1096,18 @@ impl Neg for BigUint { type Output = BigUint; #[inline] - fn neg(self) -> BigUint { panic!() } + fn neg(self) -> BigUint { + panic!() + } } impl<'a> Neg for &'a BigUint { type Output = BigUint; #[inline] - fn neg(self) -> BigUint { panic!() } + fn neg(self) -> BigUint { + panic!() + } } impl CheckedAdd for BigUint { @@ -1110,52 +1164,55 @@ impl Integer for BigUint { } fn div_mod_floor(&self, other: &BigUint) -> (BigUint, BigUint) { - if other.is_zero() { panic!() } - if self.is_zero() { return (Zero::zero(), Zero::zero()); } - if *other == One::one() { return (self.clone(), Zero::zero()); } + if other.is_zero() { + panic!() + } + if self.is_zero() { + return (Zero::zero(), Zero::zero()); + } + if *other == One::one() { + return (self.clone(), Zero::zero()); + } - /* Required or the q_len calculation below can underflow: */ + // Required or the q_len calculation below can underflow: match self.cmp(other) { - Less => return (Zero::zero(), self.clone()), - Equal => return (One::one(), Zero::zero()), + Less => return (Zero::zero(), self.clone()), + Equal => return (One::one(), Zero::zero()), Greater => {} // Do nothing } - /* - * This algorithm is from Knuth, TAOCP vol 2 section 4.3, algorithm D: - * - * First, normalize the arguments so the highest bit in the highest digit of the divisor is - * set: the main loop uses the highest digit of the divisor for generating guesses, so we - * want it to be the largest number we can efficiently divide by. - */ + // This algorithm is from Knuth, TAOCP vol 2 section 4.3, algorithm D: + // + // First, normalize the arguments so the highest bit in the highest digit of the divisor is + // set: the main loop uses the highest digit of the divisor for generating guesses, so we + // want it to be the largest number we can efficiently divide by. + // let shift = other.data.last().unwrap().leading_zeros() as usize; let mut a = self << shift; - let b = other << shift; + let b = other << shift; - /* - * The algorithm works by incrementally calculating "guesses", q0, for part of the - * remainder. Once we have any number q0 such that q0 * b <= a, we can set - * - * q += q0 - * a -= q0 * b - * - * and then iterate until a < b. Then, (q, a) will be our desired quotient and remainder. - * - * q0, our guess, is calculated by dividing the last few digits of a by the last digit of b - * - this should give us a guess that is "close" to the actual quotient, but is possibly - * greater than the actual quotient. If q0 * b > a, we simply use iterated subtraction - * until we have a guess such that q0 & b <= a. - */ + // The algorithm works by incrementally calculating "guesses", q0, for part of the + // remainder. Once we have any number q0 such that q0 * b <= a, we can set + // + // q += q0 + // a -= q0 * b + // + // and then iterate until a < b. Then, (q, a) will be our desired quotient and remainder. + // + // q0, our guess, is calculated by dividing the last few digits of a by the last digit of b + // - this should give us a guess that is "close" to the actual quotient, but is possibly + // greater than the actual quotient. If q0 * b > a, we simply use iterated subtraction + // until we have a guess such that q0 & b <= a. + // let bn = *b.data.last().unwrap(); let q_len = a.data.len() - b.data.len() + 1; let mut q = BigUint { data: vec![0; q_len] }; - /* - * We reuse the same temporary to avoid hitting the allocator in our inner loop - this is - * sized to hold a0 (in the common case; if a particular digit of the quotient is zero a0 - * can be bigger). - */ + // We reuse the same temporary to avoid hitting the allocator in our inner loop - this is + // sized to hold a0 (in the common case; if a particular digit of the quotient is zero a0 + // can be bigger). + // let mut tmp = BigUint { data: Vec::with_capacity(2) }; for j in (0..q_len).rev() { @@ -1220,15 +1277,21 @@ impl Integer for BigUint { /// Calculates the Lowest Common Multiple (LCM) of the number and `other`. #[inline] - fn lcm(&self, other: &BigUint) -> BigUint { ((self * other) / self.gcd(other)) } + fn lcm(&self, other: &BigUint) -> BigUint { + ((self * other) / self.gcd(other)) + } /// Deprecated, use `is_multiple_of` instead. #[inline] - fn divides(&self, other: &BigUint) -> bool { self.is_multiple_of(other) } + fn divides(&self, other: &BigUint) -> bool { + self.is_multiple_of(other) + } /// Returns `true` if the number is a multiple of `other`. #[inline] - fn is_multiple_of(&self, other: &BigUint) -> bool { (self % other).is_zero() } + fn is_multiple_of(&self, other: &BigUint) -> bool { + (self % other).is_zero() + } /// Returns `true` if the number is divisible by `2`. #[inline] @@ -1236,13 +1299,15 @@ impl Integer for BigUint { // Considering only the last digit. match self.data.first() { Some(x) => x.is_even(), - None => true + None => true, } } /// Returns `true` if the number is not divisible by `2`. #[inline] - fn is_odd(&self) -> bool { !self.is_even() } + fn is_odd(&self) -> bool { + !self.is_even() + } } impl ToPrimitive for BigUint { @@ -1264,9 +1329,8 @@ impl ToPrimitive for BigUint { match self.data.len() { 0 => Some(0), 1 => Some(self.data[0] as u64), - 2 => Some(big_digit::to_doublebigdigit(self.data[1], self.data[0]) - as u64), - _ => None + 2 => Some(big_digit::to_doublebigdigit(self.data[1], self.data[0]) as u64), + _ => None, } } @@ -1284,7 +1348,8 @@ impl ToPrimitive for BigUint { let exponent = (len - 2) * big_digit::BITS; // we need 25 significant digits, 24 to be stored and 1 for rounding // this gives at least 33 significant digits - let mantissa = big_digit::to_doublebigdigit(self.data[len - 1], self.data[len - 2]); + let mantissa = big_digit::to_doublebigdigit(self.data[len - 1], + self.data[len - 2]); // this cast handles rounding let ret = (mantissa as f32) * 2.0.powi(exponent as i32); if ret.is_infinite() { @@ -1310,7 +1375,8 @@ impl ToPrimitive for BigUint { None } else { let mut exponent = (len - 2) * big_digit::BITS; - let mut mantissa = big_digit::to_doublebigdigit(self.data[len - 1], self.data[len - 2]); + let mut mantissa = big_digit::to_doublebigdigit(self.data[len - 1], + self.data[len - 2]); // we need at least 54 significant bit digits, 53 to be stored and 1 for rounding // so we take enough from the next BigDigit to make it up to 64 let shift = mantissa.leading_zeros() as usize; @@ -1443,18 +1509,18 @@ macro_rules! impl_to_biguint { } } -impl_to_biguint!(isize, FromPrimitive::from_isize); -impl_to_biguint!(i8, FromPrimitive::from_i8); -impl_to_biguint!(i16, FromPrimitive::from_i16); -impl_to_biguint!(i32, FromPrimitive::from_i32); -impl_to_biguint!(i64, FromPrimitive::from_i64); +impl_to_biguint!(isize, FromPrimitive::from_isize); +impl_to_biguint!(i8, FromPrimitive::from_i8); +impl_to_biguint!(i16, FromPrimitive::from_i16); +impl_to_biguint!(i32, FromPrimitive::from_i32); +impl_to_biguint!(i64, FromPrimitive::from_i64); impl_to_biguint!(usize, FromPrimitive::from_usize); -impl_to_biguint!(u8, FromPrimitive::from_u8); -impl_to_biguint!(u16, FromPrimitive::from_u16); -impl_to_biguint!(u32, FromPrimitive::from_u32); -impl_to_biguint!(u64, FromPrimitive::from_u64); -impl_to_biguint!(f32, FromPrimitive::from_f32); -impl_to_biguint!(f64, FromPrimitive::from_f64); +impl_to_biguint!(u8, FromPrimitive::from_u8); +impl_to_biguint!(u16, FromPrimitive::from_u16); +impl_to_biguint!(u32, FromPrimitive::from_u32); +impl_to_biguint!(u64, FromPrimitive::from_u64); +impl_to_biguint!(f32, FromPrimitive::from_f32); +impl_to_biguint!(f64, FromPrimitive::from_f64); // Extract bitwise digits that evenly divide BigDigit fn to_bitwise_digits_le(u: &BigUint, bits: usize) -> Vec { @@ -1549,7 +1615,7 @@ fn to_str_radix_reversed(u: &BigUint, radix: u32) -> Vec { assert!(2 <= radix && radix <= 36, "The radix must be within 2...36"); if u.is_zero() { - return vec![b'0'] + return vec![b'0']; } let mut res = if radix.is_power_of_two() { @@ -1604,7 +1670,7 @@ impl BigUint { /// # Examples /// /// ``` - /// use num::bigint::BigUint; + /// use num_bigint::BigUint; /// /// assert_eq!(BigUint::from_bytes_be(b"A"), /// BigUint::parse_bytes(b"65", 10).unwrap()); @@ -1643,7 +1709,7 @@ impl BigUint { /// # Examples /// /// ``` - /// use num::bigint::BigUint; + /// use num_bigint::BigUint; /// /// let i = BigUint::parse_bytes(b"1125", 10).unwrap(); /// assert_eq!(i.to_bytes_le(), vec![101, 4]); @@ -1662,7 +1728,7 @@ impl BigUint { /// # Examples /// /// ``` - /// use num::bigint::BigUint; + /// use num_bigint::BigUint; /// /// let i = BigUint::parse_bytes(b"1125", 10).unwrap(); /// assert_eq!(i.to_bytes_be(), vec![4, 101]); @@ -1680,7 +1746,7 @@ impl BigUint { /// # Examples /// /// ``` - /// use num::bigint::BigUint; + /// use num_bigint::BigUint; /// /// let i = BigUint::parse_bytes(b"ff", 16).unwrap(); /// assert_eq!(i.to_str_radix(16), "ff"); @@ -1697,7 +1763,7 @@ impl BigUint { /// # Examples /// /// ``` - /// use num::bigint::{BigUint, ToBigUint}; + /// use num_bigint::{BigUint, ToBigUint}; /// /// assert_eq!(BigUint::parse_bytes(b"1234", 10), ToBigUint::to_biguint(&1234)); /// assert_eq!(BigUint::parse_bytes(b"ABCD", 16), ToBigUint::to_biguint(&0xABCD)); @@ -1710,9 +1776,11 @@ impl BigUint { /// Determines the fewest bits necessary to express the `BigUint`. pub fn bits(&self) -> usize { - if self.is_zero() { return 0; } + if self.is_zero() { + return 0; + } let zeros = self.data.last().unwrap().leading_zeros(); - return self.data.len()*big_digit::BITS - zeros as usize; + return self.data.len() * big_digit::BITS - zeros as usize; } /// Strips off trailing zero bigdigits - comparisons require the last element in the vector to @@ -1728,8 +1796,8 @@ impl BigUint { #[cfg(feature = "serde")] impl serde::Serialize for BigUint { - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where - S: serde::Serializer + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: serde::Serializer { self.data.serialize(serializer) } @@ -1737,13 +1805,11 @@ impl serde::Serialize for BigUint { #[cfg(feature = "serde")] impl serde::Deserialize for BigUint { - fn deserialize(deserializer: &mut D) -> Result where - D: serde::Deserializer, + fn deserialize(deserializer: &mut D) -> Result + where D: serde::Deserializer { let data = try!(Vec::deserialize(deserializer)); - Ok(BigUint { - data: data, - }) + Ok(BigUint { data: data }) } } @@ -1758,44 +1824,43 @@ fn get_radix_base(radix: u32) -> (DoubleBigDigit, usize) { // let base = radix.pow(power); // println!("({:10}, {:2}), // {:2}", base, power, radix); // } - const BASES: [(DoubleBigDigit, usize); 37] = [ - (0, 0), (0, 0), - (4294967296, 32), // 2 - (3486784401, 20), // 3 - (4294967296, 16), // 4 - (1220703125, 13), // 5 - (2176782336, 12), // 6 - (1977326743, 11), // 7 - (1073741824, 10), // 8 - (3486784401, 10), // 9 - (1000000000, 9), // 10 - (2357947691, 9), // 11 - ( 429981696, 8), // 12 - ( 815730721, 8), // 13 - (1475789056, 8), // 14 - (2562890625, 8), // 15 - (4294967296, 8), // 16 - ( 410338673, 7), // 17 - ( 612220032, 7), // 18 - ( 893871739, 7), // 19 - (1280000000, 7), // 20 - (1801088541, 7), // 21 - (2494357888, 7), // 22 - (3404825447, 7), // 23 - ( 191102976, 6), // 24 - ( 244140625, 6), // 25 - ( 308915776, 6), // 26 - ( 387420489, 6), // 27 - ( 481890304, 6), // 28 - ( 594823321, 6), // 29 - ( 729000000, 6), // 30 - ( 887503681, 6), // 31 - (1073741824, 6), // 32 - (1291467969, 6), // 33 - (1544804416, 6), // 34 - (1838265625, 6), // 35 - (2176782336, 6), // 36 - ]; + const BASES: [(DoubleBigDigit, usize); 37] = [(0, 0), + (0, 0), + (4294967296, 32), // 2 + (3486784401, 20), // 3 + (4294967296, 16), // 4 + (1220703125, 13), // 5 + (2176782336, 12), // 6 + (1977326743, 11), // 7 + (1073741824, 10), // 8 + (3486784401, 10), // 9 + (1000000000, 9), // 10 + (2357947691, 9), // 11 + (429981696, 8), // 12 + (815730721, 8), // 13 + (1475789056, 8), // 14 + (2562890625, 8), // 15 + (4294967296, 8), // 16 + (410338673, 7), // 17 + (612220032, 7), // 18 + (893871739, 7), // 19 + (1280000000, 7), // 20 + (1801088541, 7), // 21 + (2494357888, 7), // 22 + (3404825447, 7), // 23 + (191102976, 6), // 24 + (244140625, 6), // 25 + (308915776, 6), // 26 + (387420489, 6), // 27 + (481890304, 6), // 28 + (594823321, 6), // 29 + (729000000, 6), // 30 + (887503681, 6), // 31 + (1073741824, 6), // 32 + (1291467969, 6), // 33 + (1544804416, 6), // 34 + (1838265625, 6), // 35 + (2176782336, 6) /* 36 */]; assert!(2 <= radix && radix <= 36, "The radix must be within 2...36"); BASES[radix as usize] @@ -1804,7 +1869,11 @@ fn get_radix_base(radix: u32) -> (DoubleBigDigit, usize) { /// A Sign is a `BigInt`'s composing element. #[derive(PartialEq, PartialOrd, Eq, Ord, Copy, Clone, Debug, Hash)] #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] -pub enum Sign { Minus, NoSign, Plus } +pub enum Sign { + Minus, + NoSign, + Plus, +} impl Neg for Sign { type Output = Sign; @@ -1813,9 +1882,9 @@ impl Neg for Sign { #[inline] fn neg(self) -> Sign { match self { - Minus => Plus, - NoSign => NoSign, - Plus => Minus + Minus => Plus, + NoSign => NoSign, + Plus => Minus, } } } @@ -1826,7 +1895,7 @@ impl Mul for Sign { #[inline] fn mul(self, other: Sign) -> Sign { match (self, other) { - (NoSign, _) | (_, NoSign) => NoSign, + (NoSign, _) | (_, NoSign) => NoSign, (Plus, Plus) | (Minus, Minus) => Plus, (Plus, Minus) | (Minus, Plus) => Minus, } @@ -1835,8 +1904,8 @@ impl Mul for Sign { #[cfg(feature = "serde")] impl serde::Serialize for Sign { - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where - S: serde::Serializer + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: serde::Serializer { match *self { Sign::Minus => (-1i8).serialize(serializer), @@ -1848,8 +1917,8 @@ impl serde::Serialize for Sign { #[cfg(feature = "serde")] impl serde::Deserialize for Sign { - fn deserialize(deserializer: &mut D) -> Result where - D: serde::Deserializer, + fn deserialize(deserializer: &mut D) -> Result + where D: serde::Deserializer { use serde::de::Error; @@ -1868,7 +1937,7 @@ impl serde::Deserialize for Sign { #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] pub struct BigInt { sign: Sign, - data: BigUint + data: BigUint, } impl PartialEq for BigInt { @@ -1891,11 +1960,13 @@ impl Ord for BigInt { #[inline] fn cmp(&self, other: &BigInt) -> Ordering { let scmp = self.sign.cmp(&other.sign); - if scmp != Equal { return scmp; } + if scmp != Equal { + return scmp; + } match self.sign { - NoSign => Equal, - Plus => self.data.cmp(&other.data), + NoSign => Equal, + Plus => self.data.cmp(&other.data), Minus => other.data.cmp(&self.data), } } @@ -1903,7 +1974,9 @@ impl Ord for BigInt { impl Default for BigInt { #[inline] - fn default() -> BigInt { Zero::zero() } + fn default() -> BigInt { + Zero::zero() + } } impl fmt::Display for BigInt { @@ -1932,7 +2005,9 @@ impl fmt::LowerHex for BigInt { impl fmt::UpperHex for BigInt { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(!self.is_negative(), "0x", &self.data.to_str_radix(16).to_ascii_uppercase()) + f.pad_integral(!self.is_negative(), + "0x", + &self.data.to_str_radix(16).to_ascii_uppercase()) } } @@ -1953,9 +2028,13 @@ impl Num for BigInt { fn from_str_radix(mut s: &str, radix: u32) -> Result { let sign = if s.starts_with('-') { let tail = &s[1..]; - if !tail.starts_with('+') { s = tail } + if !tail.starts_with('+') { + s = tail + } Minus - } else { Plus }; + } else { + Plus + }; let bu = try!(BigUint::from_str_radix(s, radix)); Ok(BigInt::from_biguint(sign, bu)) } @@ -1965,7 +2044,9 @@ impl Shl for BigInt { type Output = BigInt; #[inline] - fn shl(self, rhs: usize) -> BigInt { (&self) << rhs } + fn shl(self, rhs: usize) -> BigInt { + (&self) << rhs + } } impl<'a> Shl for &'a BigInt { @@ -2002,7 +2083,9 @@ impl Zero for BigInt { } #[inline] - fn is_zero(&self) -> bool { self.sign == NoSign } + fn is_zero(&self) -> bool { + self.sign == NoSign + } } impl One for BigInt { @@ -2017,29 +2100,37 @@ impl Signed for BigInt { fn abs(&self) -> BigInt { match self.sign { Plus | NoSign => self.clone(), - Minus => BigInt::from_biguint(Plus, self.data.clone()) + Minus => BigInt::from_biguint(Plus, self.data.clone()), } } #[inline] fn abs_sub(&self, other: &BigInt) -> BigInt { - if *self <= *other { Zero::zero() } else { self - other } + if *self <= *other { + Zero::zero() + } else { + self - other + } } #[inline] fn signum(&self) -> BigInt { match self.sign { - Plus => BigInt::from_biguint(Plus, One::one()), + Plus => BigInt::from_biguint(Plus, One::one()), Minus => BigInt::from_biguint(Minus, One::one()), - NoSign => Zero::zero(), + NoSign => Zero::zero(), } } #[inline] - fn is_positive(&self) -> bool { self.sign == Plus } + fn is_positive(&self) -> bool { + self.sign == Plus + } #[inline] - fn is_negative(&self) -> bool { self.sign == Minus } + fn is_negative(&self) -> bool { + self.sign == Minus + } } // We want to forward to BigUint::add, but it's not clear how that will go until @@ -2069,7 +2160,12 @@ impl<'a, 'b> Add<&'b BigInt> for &'a BigInt { #[inline] fn add(self, other: &BigInt) -> BigInt { - bigint_add!(self, self.clone(), &self.data, other, other.clone(), &other.data) + bigint_add!(self, + self.clone(), + &self.data, + other, + other.clone(), + &other.data) } } @@ -2127,7 +2223,12 @@ impl<'a, 'b> Sub<&'b BigInt> for &'a BigInt { #[inline] fn sub(self, other: &BigInt) -> BigInt { - bigint_sub!(self, self.clone(), &self.data, other, other.clone(), &other.data) + bigint_sub!(self, + self.clone(), + &self.data, + other, + other.clone(), + &other.data) } } @@ -2165,8 +2266,7 @@ impl<'a, 'b> Mul<&'b BigInt> for &'a BigInt { #[inline] fn mul(self, other: &BigInt) -> BigInt { - BigInt::from_biguint(self.sign * other.sign, - &self.data * &other.data) + BigInt::from_biguint(self.sign * other.sign, &self.data * &other.data) } } @@ -2251,7 +2351,11 @@ impl Integer for BigInt { let (d_ui, r_ui) = self.data.div_mod_floor(&other.data); let d = BigInt::from_biguint(self.sign, d_ui); let r = BigInt::from_biguint(self.sign, r_ui); - if other.is_negative() { (-d, r) } else { (d, r) } + if other.is_negative() { + (-d, r) + } else { + (d, r) + } } #[inline] @@ -2273,15 +2377,15 @@ impl Integer for BigInt { let m = BigInt::from_biguint(Plus, m_ui); let one: BigInt = One::one(); match (self.sign, other.sign) { - (_, NoSign) => panic!(), - (Plus, Plus) | (NoSign, Plus) => (d, m), + (_, NoSign) => panic!(), + (Plus, Plus) | (NoSign, Plus) => (d, m), (Plus, Minus) | (NoSign, Minus) => { if m.is_zero() { (-d, Zero::zero()) } else { (-d - one, m + other) } - }, + } (Minus, Plus) => { if m.is_zero() { (-d, Zero::zero()) @@ -2289,7 +2393,7 @@ impl Integer for BigInt { (-d - one, other - m) } } - (Minus, Minus) => (d, -m) + (Minus, Minus) => (d, -m), } } @@ -2309,27 +2413,35 @@ impl Integer for BigInt { /// Deprecated, use `is_multiple_of` instead. #[inline] - fn divides(&self, other: &BigInt) -> bool { return self.is_multiple_of(other); } + fn divides(&self, other: &BigInt) -> bool { + return self.is_multiple_of(other); + } /// Returns `true` if the number is a multiple of `other`. #[inline] - fn is_multiple_of(&self, other: &BigInt) -> bool { self.data.is_multiple_of(&other.data) } + fn is_multiple_of(&self, other: &BigInt) -> bool { + self.data.is_multiple_of(&other.data) + } /// Returns `true` if the number is divisible by `2`. #[inline] - fn is_even(&self) -> bool { self.data.is_even() } + fn is_even(&self) -> bool { + self.data.is_even() + } /// Returns `true` if the number is not divisible by `2`. #[inline] - fn is_odd(&self) -> bool { self.data.is_odd() } + fn is_odd(&self) -> bool { + self.data.is_odd() + } } impl ToPrimitive for BigInt { #[inline] fn to_i64(&self) -> Option { match self.sign { - Plus => self.data.to_i64(), - NoSign => Some(0), + Plus => self.data.to_i64(), + NoSign => Some(0), Minus => { self.data.to_u64().and_then(|n| { let m: u64 = 1 << 63; @@ -2350,18 +2462,30 @@ impl ToPrimitive for BigInt { match self.sign { Plus => self.data.to_u64(), NoSign => Some(0), - Minus => None + Minus => None, } } #[inline] fn to_f32(&self) -> Option { - self.data.to_f32().map(|n| if self.sign == Minus { -n } else { n }) + self.data.to_f32().map(|n| { + if self.sign == Minus { + -n + } else { + n + } + }) } #[inline] fn to_f64(&self) -> Option { - self.data.to_f64().map(|n| if self.sign == Minus { -n } else { n }) + self.data.to_f64().map(|n| { + if self.sign == Minus { + -n + } else { + n + } + }) } } @@ -2393,7 +2517,10 @@ impl From for BigInt { BigInt::from(n as u64) } else { let u = u64::MAX - (n as u64) + 1; - BigInt { sign: Minus, data: BigUint::from(u) } + BigInt { + sign: Minus, + data: BigUint::from(u), + } } } } @@ -2418,7 +2545,10 @@ impl From for BigInt { #[inline] fn from(n: u64) -> Self { if n > 0 { - BigInt { sign: Plus, data: BigUint::from(n) } + BigInt { + sign: Plus, + data: BigUint::from(n), + } } else { BigInt::zero() } @@ -2447,15 +2577,18 @@ impl From for BigInt { if n.is_zero() { BigInt::zero() } else { - BigInt { sign: Plus, data: n } + BigInt { + sign: Plus, + data: n, + } } } } #[cfg(feature = "serde")] impl serde::Serialize for BigInt { - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where - S: serde::Serializer + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: serde::Serializer { (self.sign, &self.data).serialize(serializer) } @@ -2463,8 +2596,8 @@ impl serde::Serialize for BigInt { #[cfg(feature = "serde")] impl serde::Deserialize for BigInt { - fn deserialize(deserializer: &mut D) -> Result where - D: serde::Deserializer, + fn deserialize(deserializer: &mut D) -> Result + where D: serde::Deserializer { let (sign, data) = try!(serde::Deserialize::deserialize(deserializer)); Ok(BigInt { @@ -2493,7 +2626,10 @@ impl ToBigInt for BigUint { if self.is_zero() { Some(Zero::zero()) } else { - Some(BigInt { sign: Plus, data: self.clone() }) + Some(BigInt { + sign: Plus, + data: self.clone(), + }) } } } @@ -2509,18 +2645,18 @@ macro_rules! impl_to_bigint { } } -impl_to_bigint!(isize, FromPrimitive::from_isize); -impl_to_bigint!(i8, FromPrimitive::from_i8); -impl_to_bigint!(i16, FromPrimitive::from_i16); -impl_to_bigint!(i32, FromPrimitive::from_i32); -impl_to_bigint!(i64, FromPrimitive::from_i64); +impl_to_bigint!(isize, FromPrimitive::from_isize); +impl_to_bigint!(i8, FromPrimitive::from_i8); +impl_to_bigint!(i16, FromPrimitive::from_i16); +impl_to_bigint!(i32, FromPrimitive::from_i32); +impl_to_bigint!(i64, FromPrimitive::from_i64); impl_to_bigint!(usize, FromPrimitive::from_usize); -impl_to_bigint!(u8, FromPrimitive::from_u8); -impl_to_bigint!(u16, FromPrimitive::from_u16); -impl_to_bigint!(u32, FromPrimitive::from_u32); -impl_to_bigint!(u64, FromPrimitive::from_u64); -impl_to_bigint!(f32, FromPrimitive::from_f32); -impl_to_bigint!(f64, FromPrimitive::from_f64); +impl_to_bigint!(u8, FromPrimitive::from_u8); +impl_to_bigint!(u16, FromPrimitive::from_u16); +impl_to_bigint!(u32, FromPrimitive::from_u32); +impl_to_bigint!(u64, FromPrimitive::from_u64); +impl_to_bigint!(f32, FromPrimitive::from_f32); +impl_to_bigint!(f64, FromPrimitive::from_f64); pub trait RandBigInt { /// Generate a random `BigUint` of the given bit size. @@ -2548,8 +2684,8 @@ pub trait RandBigInt { impl RandBigInt for R { fn gen_biguint(&mut self, bit_size: usize) -> BigUint { let (digits, rem) = bit_size.div_rem(&big_digit::BITS); - let mut data = Vec::with_capacity(digits+1); - for _ in 0 .. digits { + let mut data = Vec::with_capacity(digits + 1); + for _ in 0..digits { data.push(self.gen()); } if rem > 0 { @@ -2586,22 +2722,18 @@ impl RandBigInt for R { let bits = bound.bits(); loop { let n = self.gen_biguint(bits); - if n < *bound { return n; } + if n < *bound { + return n; + } } } - fn gen_biguint_range(&mut self, - lbound: &BigUint, - ubound: &BigUint) - -> BigUint { + fn gen_biguint_range(&mut self, lbound: &BigUint, ubound: &BigUint) -> BigUint { assert!(*lbound < *ubound); return lbound + self.gen_biguint_below(&(ubound - lbound)); } - fn gen_bigint_range(&mut self, - lbound: &BigInt, - ubound: &BigInt) - -> BigInt { + fn gen_bigint_range(&mut self, lbound: &BigInt, ubound: &BigInt) -> BigInt { assert!(*lbound < *ubound); let delta = (ubound - lbound).to_biguint().unwrap(); return lbound + self.gen_biguint_below(&delta).to_bigint().unwrap(); @@ -2623,9 +2755,15 @@ impl BigInt { #[inline] pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt { if sign == NoSign || data.is_zero() { - return BigInt { sign: NoSign, data: Zero::zero() }; + return BigInt { + sign: NoSign, + data: Zero::zero(), + }; + } + BigInt { + sign: sign, + data: data, } - BigInt { sign: sign, data: data } } /// Creates and initializes a `BigInt`. @@ -2641,7 +2779,7 @@ impl BigInt { /// # Examples /// /// ``` - /// use num::bigint::{BigInt, Sign}; + /// use num_bigint::{BigInt, Sign}; /// /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"A"), /// BigInt::parse_bytes(b"65", 10).unwrap()); @@ -2670,7 +2808,7 @@ impl BigInt { /// # Examples /// /// ``` - /// use num::bigint::{ToBigInt, Sign}; + /// use num_bigint::{ToBigInt, Sign}; /// /// let i = -1125.to_bigint().unwrap(); /// assert_eq!(i.to_bytes_le(), (Sign::Minus, vec![101, 4])); @@ -2685,7 +2823,7 @@ impl BigInt { /// # Examples /// /// ``` - /// use num::bigint::{ToBigInt, Sign}; + /// use num_bigint::{ToBigInt, Sign}; /// /// let i = -1125.to_bigint().unwrap(); /// assert_eq!(i.to_bytes_be(), (Sign::Minus, vec![4, 101])); @@ -2701,7 +2839,7 @@ impl BigInt { /// # Examples /// /// ``` - /// use num::bigint::BigInt; + /// use num_bigint::BigInt; /// /// let i = BigInt::parse_bytes(b"ff", 16).unwrap(); /// assert_eq!(i.to_str_radix(16), "ff"); @@ -2723,7 +2861,7 @@ impl BigInt { /// # Examples /// /// ``` - /// use num::bigint::{ToBigInt, Sign}; + /// use num_bigint::{ToBigInt, Sign}; /// /// assert_eq!(ToBigInt::to_bigint(&1234).unwrap().sign(), Sign::Plus); /// assert_eq!(ToBigInt::to_bigint(&-4321).unwrap().sign(), Sign::Minus); @@ -2739,7 +2877,7 @@ impl BigInt { /// # Examples /// /// ``` - /// use num::bigint::{BigInt, ToBigInt}; + /// use num_bigint::{BigInt, ToBigInt}; /// /// assert_eq!(BigInt::parse_bytes(b"1234", 10), ToBigInt::to_bigint(&1234)); /// assert_eq!(BigInt::parse_bytes(b"ABCD", 16), ToBigInt::to_bigint(&0xABCD)); @@ -2762,7 +2900,7 @@ impl BigInt { match self.sign { Plus => Some(self.data.clone()), NoSign => Some(Zero::zero()), - Minus => None + Minus => None, } } @@ -2800,13 +2938,15 @@ impl fmt::Display for ParseBigIntError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { &ParseBigIntError::ParseInt(ref e) => e.fmt(f), - &ParseBigIntError::Other => "failed to parse provided string".fmt(f) + &ParseBigIntError::Other => "failed to parse provided string".fmt(f), } } } impl Error for ParseBigIntError { - fn description(&self) -> &str { "failed to parse bigint/biguint" } + fn description(&self) -> &str { + "failed to parse bigint/biguint" + } } impl From for ParseBigIntError { @@ -2815,9 +2955,17 @@ impl From for ParseBigIntError { } } +#[cfg(test)] +fn hash(x: &T) -> u64 { + use std::hash::Hasher; + let mut hasher = hash::SipHasher::new(); + x.hash(&mut hasher); + hasher.finish() +} + #[cfg(test)] mod biguint_tests { - use Integer; + use integer::Integer; use super::{BigDigit, BigUint, ToBigUint, big_digit}; use super::{BigInt, RandBigInt, ToBigInt}; use super::Sign::Plus; @@ -2830,9 +2978,9 @@ mod biguint_tests { use std::{u8, u16, u32, u64, usize}; use rand::thread_rng; - use {Num, Zero, One, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv}; - use {ToPrimitive, FromPrimitive}; - use Float; + use traits::{Num, Zero, One, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, ToPrimitive, + FromPrimitive, Float}; + /// Assert that an op works for all val/ref combinations macro_rules! assert_op { @@ -2921,7 +3069,7 @@ mod biguint_tests { #[test] fn test_cmp() { - let data: [&[_]; 7] = [ &[], &[1], &[2], &[!0], &[0, 1], &[2, 1], &[1, 1, 1] ]; + let data: [&[_]; 7] = [&[], &[1], &[2], &[!0], &[0, 1], &[2, 1], &[1, 1, 1]]; let data: Vec = data.iter().map(|v| BigUint::from_slice(*v)).collect(); for (i, ni) in data.iter().enumerate() { for (j0, nj) in data[i..].iter().enumerate() { @@ -2958,26 +3106,28 @@ mod biguint_tests { #[test] fn test_hash() { - let a = BigUint::new(vec!()); - let b = BigUint::new(vec!(0)); - let c = BigUint::new(vec!(1)); - let d = BigUint::new(vec!(1,0,0,0,0,0)); - let e = BigUint::new(vec!(0,0,0,0,0,1)); - assert!(::hash(&a) == ::hash(&b)); - assert!(::hash(&b) != ::hash(&c)); - assert!(::hash(&c) == ::hash(&d)); - assert!(::hash(&d) != ::hash(&e)); + let a = BigUint::new(vec![]); + let b = BigUint::new(vec![0]); + let c = BigUint::new(vec![1]); + let d = BigUint::new(vec![1, 0, 0, 0, 0, 0]); + let e = BigUint::new(vec![0, 0, 0, 0, 0, 1]); + assert!(super::hash(&a) == super::hash(&b)); + assert!(super::hash(&b) != super::hash(&c)); + assert!(super::hash(&c) == super::hash(&d)); + assert!(super::hash(&d) != super::hash(&e)); } const BIT_TESTS: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[ - // LEFT RIGHT AND OR XOR - ( &[], &[], &[], &[], &[] ), - ( &[268, 482, 17], &[964, 54], &[260, 34], &[972, 502, 17], &[712, 468, 17] ), - ]; + &'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[// LEFT RIGHT AND OR XOR + (&[], &[], &[], &[], &[]), + (&[268, 482, 17], + &[964, 54], + &[260, 34], + &[972, 502, 17], + &[712, 468, 17])]; #[test] fn test_bitand() { @@ -3139,7 +3289,8 @@ mod biguint_tests { a987\ 6543\ 2100"); - check("88887777666655554444333322221111", 16, + check("88887777666655554444333322221111", + 16, "888877776666555544443333222211110000"); } @@ -3256,7 +3407,8 @@ mod biguint_tests { 7654\ 3210"); - check("888877776666555544443333222211110000", 16, + check("888877776666555544443333222211110000", + 16, "88887777666655554444333322221111"); } @@ -3276,16 +3428,16 @@ mod biguint_tests { check(One::one(), 1); check(i64::MAX.to_biguint().unwrap(), i64::MAX); - check(BigUint::new(vec!( )), 0); - check(BigUint::new(vec!( 1 )), (1 << (0*big_digit::BITS))); - check(BigUint::new(vec!(N1 )), (1 << (1*big_digit::BITS)) - 1); - check(BigUint::new(vec!( 0, 1 )), (1 << (1*big_digit::BITS))); - check(BigUint::new(vec!(N1, N1 >> 1)), i64::MAX); + check(BigUint::new(vec![]), 0); + check(BigUint::new(vec![1]), (1 << (0 * big_digit::BITS))); + check(BigUint::new(vec![N1]), (1 << (1 * big_digit::BITS)) - 1); + check(BigUint::new(vec![0, 1]), (1 << (1 * big_digit::BITS))); + check(BigUint::new(vec![N1, N1 >> 1]), i64::MAX); assert_eq!(i64::MIN.to_biguint(), None); - assert_eq!(BigUint::new(vec!(N1, N1 )).to_i64(), None); - assert_eq!(BigUint::new(vec!( 0, 0, 1)).to_i64(), None); - assert_eq!(BigUint::new(vec!(N1, N1, N1)).to_i64(), None); + assert_eq!(BigUint::new(vec![N1, N1]).to_i64(), None); + assert_eq!(BigUint::new(vec![0, 0, 1]).to_i64(), None); + assert_eq!(BigUint::new(vec![N1, N1, N1]).to_i64(), None); } // `DoubleBigDigit` size dependent @@ -3302,14 +3454,14 @@ mod biguint_tests { check(u64::MIN.to_biguint().unwrap(), u64::MIN); check(u64::MAX.to_biguint().unwrap(), u64::MAX); - check(BigUint::new(vec!( )), 0); - check(BigUint::new(vec!( 1 )), (1 << (0*big_digit::BITS))); - check(BigUint::new(vec!(N1 )), (1 << (1*big_digit::BITS)) - 1); - check(BigUint::new(vec!( 0, 1)), (1 << (1*big_digit::BITS))); - check(BigUint::new(vec!(N1, N1)), u64::MAX); + check(BigUint::new(vec![]), 0); + check(BigUint::new(vec![1]), (1 << (0 * big_digit::BITS))); + check(BigUint::new(vec![N1]), (1 << (1 * big_digit::BITS)) - 1); + check(BigUint::new(vec![0, 1]), (1 << (1 * big_digit::BITS))); + check(BigUint::new(vec![N1, N1]), u64::MAX); - assert_eq!(BigUint::new(vec!( 0, 0, 1)).to_u64(), None); - assert_eq!(BigUint::new(vec!(N1, N1, N1)).to_u64(), None); + assert_eq!(BigUint::new(vec![0, 0, 1]).to_u64(), None); + assert_eq!(BigUint::new(vec![N1, N1, N1]).to_u64(), None); } #[test] @@ -3325,7 +3477,8 @@ mod biguint_tests { check(&BigUint::from(u16::MAX), 2.0.powi(16) - 1.0); check(&BigUint::from(1u64 << 32), 2.0.powi(32)); check(&BigUint::from_slice(&[0, 0, 1]), 2.0.powi(64)); - check(&((BigUint::one() << 100) + (BigUint::one() << 123)), 2.0.powi(100) + 2.0.powi(123)); + check(&((BigUint::one() << 100) + (BigUint::one() << 123)), + 2.0.powi(100) + 2.0.powi(123)); check(&(BigUint::one() << 127), 2.0.powi(127)); check(&(BigUint::from((1u64 << 24) - 1) << (128 - 24)), f32::MAX); @@ -3358,12 +3511,14 @@ mod biguint_tests { assert_eq!(BigUint::from_f32(-0.99999), Some(BigUint::zero())); assert_eq!(BigUint::from_f32(-0.5), Some(BigUint::zero())); assert_eq!(BigUint::from_f32(-0.0), Some(BigUint::zero())); - assert_eq!(BigUint::from_f32(f32::MIN_POSITIVE / 2.0), Some(BigUint::zero())); + assert_eq!(BigUint::from_f32(f32::MIN_POSITIVE / 2.0), + Some(BigUint::zero())); assert_eq!(BigUint::from_f32(f32::MIN_POSITIVE), Some(BigUint::zero())); assert_eq!(BigUint::from_f32(0.5), Some(BigUint::zero())); assert_eq!(BigUint::from_f32(0.99999), Some(BigUint::zero())); assert_eq!(BigUint::from_f32(f32::consts::E), Some(BigUint::from(2u32))); - assert_eq!(BigUint::from_f32(f32::consts::PI), Some(BigUint::from(3u32))); + assert_eq!(BigUint::from_f32(f32::consts::PI), + Some(BigUint::from(3u32))); // special float values assert_eq!(BigUint::from_f32(f32::NAN), None); @@ -3393,7 +3548,8 @@ mod biguint_tests { check(&BigUint::from(u32::MAX), 2.0.powi(32) - 1.0); check(&BigUint::from(1u64 << 32), 2.0.powi(32)); check(&BigUint::from_slice(&[0, 0, 1]), 2.0.powi(64)); - check(&((BigUint::one() << 100) + (BigUint::one() << 152)), 2.0.powi(100) + 2.0.powi(152)); + check(&((BigUint::one() << 100) + (BigUint::one() << 152)), + 2.0.powi(100) + 2.0.powi(152)); check(&(BigUint::one() << 1023), 2.0.powi(1023)); check(&(BigUint::from((1u64 << 53) - 1) << (1024 - 53)), f64::MAX); @@ -3421,12 +3577,14 @@ mod biguint_tests { assert_eq!(BigUint::from_f64(-0.99999), Some(BigUint::zero())); assert_eq!(BigUint::from_f64(-0.5), Some(BigUint::zero())); assert_eq!(BigUint::from_f64(-0.0), Some(BigUint::zero())); - assert_eq!(BigUint::from_f64(f64::MIN_POSITIVE / 2.0), Some(BigUint::zero())); + assert_eq!(BigUint::from_f64(f64::MIN_POSITIVE / 2.0), + Some(BigUint::zero())); assert_eq!(BigUint::from_f64(f64::MIN_POSITIVE), Some(BigUint::zero())); assert_eq!(BigUint::from_f64(0.5), Some(BigUint::zero())); assert_eq!(BigUint::from_f64(0.99999), Some(BigUint::zero())); assert_eq!(BigUint::from_f64(f64::consts::E), Some(BigUint::from(2u32))); - assert_eq!(BigUint::from_f64(f64::consts::PI), Some(BigUint::from(3u32))); + assert_eq!(BigUint::from_f64(f64::consts::PI), + Some(BigUint::from(3u32))); // special float values assert_eq!(BigUint::from_f64(f64::NAN), None); @@ -3450,8 +3608,8 @@ mod biguint_tests { assert_eq!(n.to_bigint().unwrap().to_biguint().unwrap(), n); } check(Zero::zero(), Zero::zero()); - check(BigUint::new(vec!(1,2,3)), - BigInt::from_biguint(Plus, BigUint::new(vec!(1,2,3)))); + check(BigUint::new(vec![1, 2, 3]), + BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3]))); } #[test] @@ -3473,18 +3631,16 @@ mod biguint_tests { } const SUM_TRIPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[ - (&[], &[], &[]), - (&[], &[ 1], &[ 1]), - (&[ 1], &[ 1], &[ 2]), - (&[ 1], &[ 1, 1], &[ 2, 1]), - (&[ 1], &[N1], &[ 0, 1]), - (&[ 1], &[N1, N1], &[ 0, 0, 1]), - (&[N1, N1], &[N1, N1], &[N2, N1, 1]), - (&[ 1, 1, 1], &[N1, N1], &[ 0, 1, 2]), - (&[ 2, 2, 1], &[N1, N2], &[ 1, 1, 2]) - ]; + &'static [BigDigit], + &'static [BigDigit])] = &[(&[], &[], &[]), + (&[], &[1], &[1]), + (&[1], &[1], &[2]), + (&[1], &[1, 1], &[2, 1]), + (&[1], &[N1], &[0, 1]), + (&[1], &[N1, N1], &[0, 0, 1]), + (&[N1, N1], &[N1, N1], &[N2, N1, 1]), + (&[1, 1, 1], &[N1, N1], &[0, 1, 2]), + (&[2, 2, 1], &[N1, N2], &[1, 1, 2])]; #[test] fn test_add() { @@ -3515,48 +3671,45 @@ mod biguint_tests { #[test] #[should_panic] fn test_sub_fail_on_underflow() { - let (a, b) : (BigUint, BigUint) = (Zero::zero(), One::one()); + let (a, b): (BigUint, BigUint) = (Zero::zero(), One::one()); a - b; } const M: u32 = ::std::u32::MAX; const MUL_TRIPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[ - (&[], &[], &[]), - (&[], &[ 1], &[]), - (&[ 2], &[], &[]), - (&[ 1], &[ 1], &[1]), - (&[ 2], &[ 3], &[ 6]), - (&[ 1], &[ 1, 1, 1], &[1, 1, 1]), - (&[ 1, 2, 3], &[ 3], &[ 3, 6, 9]), - (&[ 1, 1, 1], &[N1], &[N1, N1, N1]), - (&[ 1, 2, 3], &[N1], &[N1, N2, N2, 2]), - (&[ 1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]), - (&[N1], &[N1], &[ 1, N2]), - (&[N1, N1], &[N1], &[ 1, N1, N2]), - (&[N1, N1, N1], &[N1], &[ 1, N1, N1, N2]), - (&[N1, N1, N1, N1], &[N1], &[ 1, N1, N1, N1, N2]), - (&[ M/2 + 1], &[ 2], &[ 0, 1]), - (&[0, M/2 + 1], &[ 2], &[ 0, 0, 1]), - (&[ 1, 2], &[ 1, 2, 3], &[1, 4, 7, 6]), - (&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]), - (&[N1, N1, N1], &[N1, N1, N1, N1], &[1, 0, 0, N1, N2, N1, N1]), - (&[ 0, 0, 1], &[ 1, 2, 3], &[0, 0, 1, 2, 3]), - (&[ 0, 0, 1], &[ 0, 0, 0, 1], &[0, 0, 0, 0, 0, 1]) - ]; + &'static [BigDigit], + &'static [BigDigit])] = &[(&[], &[], &[]), + (&[], &[1], &[]), + (&[2], &[], &[]), + (&[1], &[1], &[1]), + (&[2], &[3], &[6]), + (&[1], &[1, 1, 1], &[1, 1, 1]), + (&[1, 2, 3], &[3], &[3, 6, 9]), + (&[1, 1, 1], &[N1], &[N1, N1, N1]), + (&[1, 2, 3], &[N1], &[N1, N2, N2, 2]), + (&[1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]), + (&[N1], &[N1], &[1, N2]), + (&[N1, N1], &[N1], &[1, N1, N2]), + (&[N1, N1, N1], &[N1], &[1, N1, N1, N2]), + (&[N1, N1, N1, N1], &[N1], &[1, N1, N1, N1, N2]), + (&[M / 2 + 1], &[2], &[0, 1]), + (&[0, M / 2 + 1], &[2], &[0, 0, 1]), + (&[1, 2], &[1, 2, 3], &[1, 4, 7, 6]), + (&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]), + (&[N1, N1, N1], + &[N1, N1, N1, N1], + &[1, 0, 0, N1, N2, N1, N1]), + (&[0, 0, 1], &[1, 2, 3], &[0, 0, 1, 2, 3]), + (&[0, 0, 1], &[0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])]; const DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] - = &[ - (&[ 1], &[ 2], &[], &[1]), - (&[ 1, 1], &[ 2], &[ M/2+1], &[1]), - (&[ 1, 1, 1], &[ 2], &[ M/2+1, M/2+1], &[1]), - (&[ 0, 1], &[N1], &[1], &[1]), - (&[N1, N1], &[N2], &[2, 1], &[3]) - ]; + &'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[(&[1], &[2], &[], &[1]), + (&[1, 1], &[2], &[M / 2 + 1], &[1]), + (&[1, 1, 1], &[2], &[M / 2 + 1, M / 2 + 1], &[1]), + (&[0, 1], &[N1], &[1], &[1]), + (&[N1, N1], &[N2], &[2, 1], &[3])]; #[test] fn test_mul() { @@ -3746,64 +3899,66 @@ mod biguint_tests { fn to_str_pairs() -> Vec<(BigUint, Vec<(u32, String)>)> { let bits = big_digit::BITS; - vec!(( Zero::zero(), vec!( - (2, "0".to_string()), (3, "0".to_string()) - )), ( BigUint::from_slice(&[ 0xff ]), vec!( - (2, "11111111".to_string()), - (3, "100110".to_string()), - (4, "3333".to_string()), - (5, "2010".to_string()), - (6, "1103".to_string()), - (7, "513".to_string()), - (8, "377".to_string()), - (9, "313".to_string()), - (10, "255".to_string()), - (11, "212".to_string()), - (12, "193".to_string()), - (13, "168".to_string()), - (14, "143".to_string()), - (15, "120".to_string()), - (16, "ff".to_string()) - )), ( BigUint::from_slice(&[ 0xfff ]), vec!( - (2, "111111111111".to_string()), - (4, "333333".to_string()), - (16, "fff".to_string()) - )), ( BigUint::from_slice(&[ 1, 2 ]), vec!( - (2, - format!("10{}1", repeat("0").take(bits - 1).collect::())), - (4, - format!("2{}1", repeat("0").take(bits / 2 - 1).collect::())), - (10, match bits { - 32 => "8589934593".to_string(), - 16 => "131073".to_string(), - _ => panic!() - }), - (16, - format!("2{}1", repeat("0").take(bits / 4 - 1).collect::())) - )), ( BigUint::from_slice(&[ 1, 2, 3 ]), vec!( - (2, - format!("11{}10{}1", - repeat("0").take(bits - 2).collect::(), - repeat("0").take(bits - 1).collect::())), - (4, - format!("3{}2{}1", - repeat("0").take(bits / 2 - 1).collect::(), - repeat("0").take(bits / 2 - 1).collect::())), - (8, match bits { - 32 => "6000000000100000000001".to_string(), - 16 => "140000400001".to_string(), - _ => panic!() - }), - (10, match bits { - 32 => "55340232229718589441".to_string(), - 16 => "12885032961".to_string(), - _ => panic!() - }), - (16, - format!("3{}2{}1", - repeat("0").take(bits / 4 - 1).collect::(), - repeat("0").take(bits / 4 - 1).collect::())) - )) ) + vec![(Zero::zero(), + vec![(2, "0".to_string()), (3, "0".to_string())]), + (BigUint::from_slice(&[0xff]), + vec![(2, "11111111".to_string()), + (3, "100110".to_string()), + (4, "3333".to_string()), + (5, "2010".to_string()), + (6, "1103".to_string()), + (7, "513".to_string()), + (8, "377".to_string()), + (9, "313".to_string()), + (10, "255".to_string()), + (11, "212".to_string()), + (12, "193".to_string()), + (13, "168".to_string()), + (14, "143".to_string()), + (15, "120".to_string()), + (16, "ff".to_string())]), + (BigUint::from_slice(&[0xfff]), + vec![(2, "111111111111".to_string()), + (4, "333333".to_string()), + (16, "fff".to_string())]), + (BigUint::from_slice(&[1, 2]), + vec![(2, + format!("10{}1", repeat("0").take(bits - 1).collect::())), + (4, + format!("2{}1", repeat("0").take(bits / 2 - 1).collect::())), + (10, + match bits { + 32 => "8589934593".to_string(), + 16 => "131073".to_string(), + _ => panic!(), + }), + (16, + format!("2{}1", repeat("0").take(bits / 4 - 1).collect::()))]), + (BigUint::from_slice(&[1, 2, 3]), + vec![(2, + format!("11{}10{}1", + repeat("0").take(bits - 2).collect::(), + repeat("0").take(bits - 1).collect::())), + (4, + format!("3{}2{}1", + repeat("0").take(bits / 2 - 1).collect::(), + repeat("0").take(bits / 2 - 1).collect::())), + (8, + match bits { + 32 => "6000000000100000000001".to_string(), + 16 => "140000400001".to_string(), + _ => panic!(), + }), + (10, + match bits { + 32 => "55340232229718589441".to_string(), + 16 => "12885032961".to_string(), + _ => panic!(), + }), + (16, + format!("3{}2{}1", + repeat("0").take(bits / 4 - 1).collect::(), + repeat("0").take(bits / 4 - 1).collect::()))])] } #[test] @@ -3825,8 +3980,7 @@ mod biguint_tests { let &(ref n, ref rs) = num_pair; for str_pair in rs.iter() { let &(ref radix, ref str) = str_pair; - assert_eq!(n, - &BigUint::from_str_radix(str, *radix).unwrap()); + assert_eq!(n, &BigUint::from_str_radix(str, *radix).unwrap()); } } @@ -3884,7 +4038,8 @@ mod biguint_tests { let hello = BigUint::parse_bytes("224055342307539".as_bytes(), 10).unwrap(); assert_eq!(format!("{:b}", a), "1010"); - assert_eq!(format!("{:b}", hello), "110010111100011011110011000101101001100011010011"); + assert_eq!(format!("{:b}", hello), + "110010111100011011110011000101101001100011010011"); assert_eq!(format!("{:♥>+#8b}", a), "♥+0b1010"); } @@ -3924,7 +4079,8 @@ mod biguint_tests { fn check(n: usize, s: &str) { let n = factor(n); let ans = match BigUint::from_str_radix(s, 10) { - Ok(x) => x, Err(_) => panic!() + Ok(x) => x, + Err(_) => panic!(), }; assert_eq!(n, ans); } @@ -3937,7 +4093,7 @@ mod biguint_tests { #[test] fn test_bits() { - assert_eq!(BigUint::new(vec!(0,0,0,0)).bits(), 0); + assert_eq!(BigUint::new(vec![0, 0, 0, 0]).bits(), 0); let n: BigUint = FromPrimitive::from_usize(0).unwrap(); assert_eq!(n.bits(), 0); let n: BigUint = FromPrimitive::from_usize(1).unwrap(); @@ -3983,7 +4139,7 @@ mod biguint_tests { #[should_panic] fn test_zero_rand_range() { thread_rng().gen_biguint_range(&FromPrimitive::from_usize(54).unwrap(), - &FromPrimitive::from_usize(54).unwrap()); + &FromPrimitive::from_usize(54).unwrap()); } #[test] @@ -4014,7 +4170,7 @@ mod biguint_tests { let mut rng: StdRng = SeedableRng::from_seed(seed); for _ in 0..count { - /* Test with numbers of random sizes: */ + // Test with numbers of random sizes: let xbits = rng.gen_range(0, bits_max); let ybits = rng.gen_range(0, bits_max); @@ -4045,7 +4201,6 @@ mod biguint_tests { #[cfg(test)] mod bigint_tests { - use Integer; use super::{BigDigit, BigUint, ToBigUint}; use super::{Sign, BigInt, RandBigInt, ToBigInt, big_digit}; use super::Sign::{Minus, NoSign, Plus}; @@ -4055,12 +4210,12 @@ mod bigint_tests { use std::{i8, i16, i32, i64, isize}; use std::iter::repeat; use std::{u8, u16, u32, u64, usize}; - use std::ops::{Neg}; + use std::ops::Neg; use rand::thread_rng; - use {Zero, One, Signed, ToPrimitive, FromPrimitive, Num}; - use Float; + use integer::Integer; + use traits::{Zero, One, Signed, ToPrimitive, FromPrimitive, Num, Float}; /// Assert that an op works for all val/ref combinations macro_rules! assert_op { @@ -4076,7 +4231,10 @@ mod bigint_tests { fn test_from_biguint() { fn check(inp_s: Sign, inp_n: usize, ans_s: Sign, ans_n: usize) { let inp = BigInt::from_biguint(inp_s, FromPrimitive::from_usize(inp_n).unwrap()); - let ans = BigInt { sign: ans_s, data: FromPrimitive::from_usize(ans_n).unwrap()}; + let ans = BigInt { + sign: ans_s, + data: FromPrimitive::from_usize(ans_n).unwrap(), + }; assert_eq!(inp, ans); } check(Plus, 1, Plus, 1); @@ -4153,7 +4311,7 @@ mod bigint_tests { #[test] fn test_cmp() { - let vs: [&[BigDigit]; 4] = [ &[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1] ]; + let vs: [&[BigDigit]; 4] = [&[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1]]; let mut nums = Vec::new(); for s in vs.iter().rev() { nums.push(BigInt::from_slice(Minus, *s)); @@ -4197,17 +4355,17 @@ mod bigint_tests { #[test] fn test_hash() { - let a = BigInt::new(NoSign, vec!()); - let b = BigInt::new(NoSign, vec!(0)); - let c = BigInt::new(Plus, vec!(1)); - let d = BigInt::new(Plus, vec!(1,0,0,0,0,0)); - let e = BigInt::new(Plus, vec!(0,0,0,0,0,1)); - let f = BigInt::new(Minus, vec!(1)); - assert!(::hash(&a) == ::hash(&b)); - assert!(::hash(&b) != ::hash(&c)); - assert!(::hash(&c) == ::hash(&d)); - assert!(::hash(&d) != ::hash(&e)); - assert!(::hash(&c) != ::hash(&f)); + let a = BigInt::new(NoSign, vec![]); + let b = BigInt::new(NoSign, vec![0]); + let c = BigInt::new(Plus, vec![1]); + let d = BigInt::new(Plus, vec![1, 0, 0, 0, 0, 0]); + let e = BigInt::new(Plus, vec![0, 0, 0, 0, 0, 1]); + let f = BigInt::new(Minus, vec![1]); + assert!(super::hash(&a) == super::hash(&b)); + assert!(super::hash(&b) != super::hash(&c)); + assert!(super::hash(&c) == super::hash(&d)); + assert!(super::hash(&d) != super::hash(&e)); + assert!(super::hash(&c) != super::hash(&f)); } #[test] @@ -4223,21 +4381,18 @@ mod bigint_tests { check(i64::MIN.to_bigint().unwrap(), i64::MIN); check(i64::MAX.to_bigint().unwrap(), i64::MAX); - assert_eq!( - (i64::MAX as u64 + 1).to_bigint().unwrap().to_i64(), - None); + assert_eq!((i64::MAX as u64 + 1).to_bigint().unwrap().to_i64(), None); - assert_eq!( - BigInt::from_biguint(Plus, BigUint::new(vec!(1, 2, 3, 4, 5))).to_i64(), - None); + assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(), + None); - assert_eq!( - BigInt::from_biguint(Minus, BigUint::new(vec!(1,0,0,1<<(big_digit::BITS-1)))).to_i64(), - None); + assert_eq!(BigInt::from_biguint(Minus, + BigUint::new(vec![1, 0, 0, 1 << (big_digit::BITS - 1)])) + .to_i64(), + None); - assert_eq!( - BigInt::from_biguint(Minus, BigUint::new(vec!(1, 2, 3, 4, 5))).to_i64(), - None); + assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(), + None); } #[test] @@ -4253,13 +4408,13 @@ mod bigint_tests { check(u64::MIN.to_bigint().unwrap(), u64::MIN); check(u64::MAX.to_bigint().unwrap(), u64::MAX); - assert_eq!( - BigInt::from_biguint(Plus, BigUint::new(vec!(1, 2, 3, 4, 5))).to_u64(), - None); + assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(), + None); let max_value: BigUint = FromPrimitive::from_u64(u64::MAX).unwrap(); assert_eq!(BigInt::from_biguint(Minus, max_value).to_u64(), None); - assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec!(1, 2, 3, 4, 5))).to_u64(), None); + assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(), + None); } #[test] @@ -4279,7 +4434,8 @@ mod bigint_tests { check(&BigInt::from(u16::MAX), 2.0.powi(16) - 1.0); check(&BigInt::from(1u64 << 32), 2.0.powi(32)); check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64)); - check(&((BigInt::one() << 100) + (BigInt::one() << 123)), 2.0.powi(100) + 2.0.powi(123)); + check(&((BigInt::one() << 100) + (BigInt::one() << 123)), + 2.0.powi(100) + 2.0.powi(123)); check(&(BigInt::one() << 127), 2.0.powi(127)); check(&(BigInt::from((1u64 << 24) - 1) << (128 - 24)), f32::MAX); @@ -4311,12 +4467,14 @@ mod bigint_tests { } // rounding - assert_eq!(BigInt::from_f32(-f32::consts::PI), Some(BigInt::from(-3i32))); + assert_eq!(BigInt::from_f32(-f32::consts::PI), + Some(BigInt::from(-3i32))); assert_eq!(BigInt::from_f32(-f32::consts::E), Some(BigInt::from(-2i32))); assert_eq!(BigInt::from_f32(-0.99999), Some(BigInt::zero())); assert_eq!(BigInt::from_f32(-0.5), Some(BigInt::zero())); assert_eq!(BigInt::from_f32(-0.0), Some(BigInt::zero())); - assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE / 2.0), Some(BigInt::zero())); + assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE / 2.0), + Some(BigInt::zero())); assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE), Some(BigInt::zero())); assert_eq!(BigInt::from_f32(0.5), Some(BigInt::zero())); assert_eq!(BigInt::from_f32(0.99999), Some(BigInt::zero())); @@ -4344,7 +4502,7 @@ mod bigint_tests { #[test] fn test_convert_f64() { fn check(b1: &BigInt, f: f64) { - let b2 = BigInt::from_f64(f).unwrap(); + let b2 = BigInt::from_f64(f).unwrap(); assert_eq!(b1, &b2); assert_eq!(b1.to_f64().unwrap(), f); let neg_b1 = -b1; @@ -4358,7 +4516,8 @@ mod bigint_tests { check(&BigInt::from(u32::MAX), 2.0.powi(32) - 1.0); check(&BigInt::from(1u64 << 32), 2.0.powi(32)); check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64)); - check(&((BigInt::one() << 100) + (BigInt::one() << 152)), 2.0.powi(100) + 2.0.powi(152)); + check(&((BigInt::one() << 100) + (BigInt::one() << 152)), + 2.0.powi(100) + 2.0.powi(152)); check(&(BigInt::one() << 1023), 2.0.powi(1023)); check(&(BigInt::from((1u64 << 53) - 1) << (1024 - 53)), f64::MAX); @@ -4382,12 +4541,14 @@ mod bigint_tests { } // rounding - assert_eq!(BigInt::from_f64(-f64::consts::PI), Some(BigInt::from(-3i32))); + assert_eq!(BigInt::from_f64(-f64::consts::PI), + Some(BigInt::from(-3i32))); assert_eq!(BigInt::from_f64(-f64::consts::E), Some(BigInt::from(-2i32))); assert_eq!(BigInt::from_f64(-0.99999), Some(BigInt::zero())); assert_eq!(BigInt::from_f64(-0.5), Some(BigInt::zero())); assert_eq!(BigInt::from_f64(-0.0), Some(BigInt::zero())); - assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE / 2.0), Some(BigInt::zero())); + assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE / 2.0), + Some(BigInt::zero())); assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE), Some(BigInt::zero())); assert_eq!(BigInt::from_f64(0.5), Some(BigInt::zero())); assert_eq!(BigInt::from_f64(0.99999), Some(BigInt::zero())); @@ -4420,12 +4581,11 @@ mod bigint_tests { } let zero: BigInt = Zero::zero(); let unsigned_zero: BigUint = Zero::zero(); - let positive = BigInt::from_biguint( - Plus, BigUint::new(vec!(1,2,3))); + let positive = BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3])); let negative = -&positive; check(zero, unsigned_zero); - check(positive, BigUint::new(vec!(1,2,3))); + check(positive, BigUint::new(vec![1, 2, 3])); assert_eq!(negative.to_biguint(), None); } @@ -4444,7 +4604,8 @@ mod bigint_tests { check!(u8, BigInt::from_slice(Plus, &[u8::MAX as BigDigit])); check!(u16, BigInt::from_slice(Plus, &[u16::MAX as BigDigit])); check!(u32, BigInt::from_slice(Plus, &[u32::MAX as BigDigit])); - check!(u64, BigInt::from_slice(Plus, &[u32::MAX as BigDigit, u32::MAX as BigDigit])); + check!(u64, + BigInt::from_slice(Plus, &[u32::MAX as BigDigit, u32::MAX as BigDigit])); check!(usize, BigInt::from(usize::MAX as u64)); } @@ -4462,41 +4623,45 @@ mod bigint_tests { } } - check!(i8, BigInt::from_slice(Minus, &[1 << 7]), - BigInt::from_slice(Plus, &[i8::MAX as BigDigit])); - check!(i16, BigInt::from_slice(Minus, &[1 << 15]), - BigInt::from_slice(Plus, &[i16::MAX as BigDigit])); - check!(i32, BigInt::from_slice(Minus, &[1 << 31]), - BigInt::from_slice(Plus, &[i32::MAX as BigDigit])); - check!(i64, BigInt::from_slice(Minus, &[0, 1 << 31]), - BigInt::from_slice(Plus, &[u32::MAX as BigDigit, i32::MAX as BigDigit])); - check!(isize, BigInt::from(isize::MIN as i64), - BigInt::from(isize::MAX as i64)); + check!(i8, + BigInt::from_slice(Minus, &[1 << 7]), + BigInt::from_slice(Plus, &[i8::MAX as BigDigit])); + check!(i16, + BigInt::from_slice(Minus, &[1 << 15]), + BigInt::from_slice(Plus, &[i16::MAX as BigDigit])); + check!(i32, + BigInt::from_slice(Minus, &[1 << 31]), + BigInt::from_slice(Plus, &[i32::MAX as BigDigit])); + check!(i64, + BigInt::from_slice(Minus, &[0, 1 << 31]), + BigInt::from_slice(Plus, &[u32::MAX as BigDigit, i32::MAX as BigDigit])); + check!(isize, + BigInt::from(isize::MIN as i64), + BigInt::from(isize::MAX as i64)); } #[test] fn test_convert_from_biguint() { assert_eq!(BigInt::from(BigUint::zero()), BigInt::zero()); assert_eq!(BigInt::from(BigUint::one()), BigInt::one()); - assert_eq!(BigInt::from(BigUint::from_slice(&[1, 2, 3])), BigInt::from_slice(Plus, &[1, 2, 3])); + assert_eq!(BigInt::from(BigUint::from_slice(&[1, 2, 3])), + BigInt::from_slice(Plus, &[1, 2, 3])); } const N1: BigDigit = -1i32 as BigDigit; const N2: BigDigit = -2i32 as BigDigit; const SUM_TRIPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[ - (&[], &[], &[]), - (&[], &[ 1], &[ 1]), - (&[ 1], &[ 1], &[ 2]), - (&[ 1], &[ 1, 1], &[ 2, 1]), - (&[ 1], &[N1], &[ 0, 1]), - (&[ 1], &[N1, N1], &[ 0, 0, 1]), - (&[N1, N1], &[N1, N1], &[N2, N1, 1]), - (&[ 1, 1, 1], &[N1, N1], &[ 0, 1, 2]), - (&[ 2, 2, 1], &[N1, N2], &[ 1, 1, 2]) - ]; + &'static [BigDigit], + &'static [BigDigit])] = &[(&[], &[], &[]), + (&[], &[1], &[1]), + (&[1], &[1], &[2]), + (&[1], &[1, 1], &[2, 1]), + (&[1], &[N1], &[0, 1]), + (&[1], &[N1, N1], &[0, 0, 1]), + (&[N1, N1], &[N1, N1], &[N2, N1, 1]), + (&[1, 1, 1], &[N1, N1], &[0, 1, 2]), + (&[2, 2, 1], &[N1, N2], &[1, 1, 2])]; #[test] fn test_add() { @@ -4540,42 +4705,39 @@ mod bigint_tests { const M: u32 = ::std::u32::MAX; static MUL_TRIPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[ - (&[], &[], &[]), - (&[], &[ 1], &[]), - (&[ 2], &[], &[]), - (&[ 1], &[ 1], &[1]), - (&[ 2], &[ 3], &[ 6]), - (&[ 1], &[ 1, 1, 1], &[1, 1, 1]), - (&[ 1, 2, 3], &[ 3], &[ 3, 6, 9]), - (&[ 1, 1, 1], &[N1], &[N1, N1, N1]), - (&[ 1, 2, 3], &[N1], &[N1, N2, N2, 2]), - (&[ 1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]), - (&[N1], &[N1], &[ 1, N2]), - (&[N1, N1], &[N1], &[ 1, N1, N2]), - (&[N1, N1, N1], &[N1], &[ 1, N1, N1, N2]), - (&[N1, N1, N1, N1], &[N1], &[ 1, N1, N1, N1, N2]), - (&[ M/2 + 1], &[ 2], &[ 0, 1]), - (&[0, M/2 + 1], &[ 2], &[ 0, 0, 1]), - (&[ 1, 2], &[ 1, 2, 3], &[1, 4, 7, 6]), - (&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]), - (&[N1, N1, N1], &[N1, N1, N1, N1], &[1, 0, 0, N1, N2, N1, N1]), - (&[ 0, 0, 1], &[ 1, 2, 3], &[0, 0, 1, 2, 3]), - (&[ 0, 0, 1], &[ 0, 0, 0, 1], &[0, 0, 0, 0, 0, 1]) - ]; + &'static [BigDigit], + &'static [BigDigit])] = &[(&[], &[], &[]), + (&[], &[1], &[]), + (&[2], &[], &[]), + (&[1], &[1], &[1]), + (&[2], &[3], &[6]), + (&[1], &[1, 1, 1], &[1, 1, 1]), + (&[1, 2, 3], &[3], &[3, 6, 9]), + (&[1, 1, 1], &[N1], &[N1, N1, N1]), + (&[1, 2, 3], &[N1], &[N1, N2, N2, 2]), + (&[1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]), + (&[N1], &[N1], &[1, N2]), + (&[N1, N1], &[N1], &[1, N1, N2]), + (&[N1, N1, N1], &[N1], &[1, N1, N1, N2]), + (&[N1, N1, N1, N1], &[N1], &[1, N1, N1, N1, N2]), + (&[M / 2 + 1], &[2], &[0, 1]), + (&[0, M / 2 + 1], &[2], &[0, 0, 1]), + (&[1, 2], &[1, 2, 3], &[1, 4, 7, 6]), + (&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]), + (&[N1, N1, N1], + &[N1, N1, N1, N1], + &[1, 0, 0, N1, N2, N1, N1]), + (&[0, 0, 1], &[1, 2, 3], &[0, 0, 1, 2, 3]), + (&[0, 0, 1], &[0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])]; static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] - = &[ - (&[ 1], &[ 2], &[], &[1]), - (&[ 1, 1], &[ 2], &[ M/2+1], &[1]), - (&[ 1, 1, 1], &[ 2], &[ M/2+1, M/2+1], &[1]), - (&[ 0, 1], &[N1], &[1], &[1]), - (&[N1, N1], &[N2], &[2, 1], &[3]) - ]; + &'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[(&[1], &[2], &[], &[1]), + (&[1, 1], &[2], &[M / 2 + 1], &[1]), + (&[1, 1, 1], &[2], &[M / 2 + 1, M / 2 + 1], &[1]), + (&[0, 1], &[N1], &[1], &[1]), + (&[N1, N1], &[N2], &[2, 1], &[3])]; #[test] fn test_mul() { @@ -4640,8 +4802,12 @@ mod bigint_tests { let b = BigInt::from_slice(Plus, b_vec); let c = BigInt::from_slice(Plus, c_vec); - if !a.is_zero() { check(&c, &a, &b, &Zero::zero()); } - if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); } + if !a.is_zero() { + check(&c, &a, &b, &Zero::zero()); + } + if !b.is_zero() { + check(&c, &b, &a, &Zero::zero()); + } } for elm in DIV_REM_QUADRUPLES.iter() { @@ -4687,8 +4853,12 @@ mod bigint_tests { let b = BigInt::from_slice(Plus, b_vec); let c = BigInt::from_slice(Plus, c_vec); - if !a.is_zero() { check(&c, &a, &b, &Zero::zero()); } - if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); } + if !a.is_zero() { + check(&c, &a, &b, &Zero::zero()); + } + if !b.is_zero() { + check(&c, &b, &a, &Zero::zero()); + } } for elm in DIV_REM_QUADRUPLES.iter() { @@ -4872,8 +5042,7 @@ mod bigint_tests { // issue 10522, this hit an edge case that caused it to // attempt to allocate a vector of size (-1u) == huge. - let x: BigInt = - format!("1{}", repeat("0").take(36).collect::()).parse().unwrap(); + let x: BigInt = format!("1{}", repeat("0").take(36).collect::()).parse().unwrap(); let _y = x.to_string(); } @@ -4903,7 +5072,8 @@ mod bigint_tests { let hello = BigInt::parse_bytes("-224055342307539".as_bytes(), 10).unwrap(); assert_eq!(format!("{:b}", a), "1010"); - assert_eq!(format!("{:b}", hello), "-110010111100011011110011000101101001100011010011"); + assert_eq!(format!("{:b}", hello), + "-110010111100011011110011000101101001100011010011"); assert_eq!(format!("{:♥>+#8b}", a), "♥+0b1010"); } @@ -4929,10 +5099,8 @@ mod bigint_tests { #[test] fn test_neg() { - assert!(-BigInt::new(Plus, vec!(1, 1, 1)) == - BigInt::new(Minus, vec!(1, 1, 1))); - assert!(-BigInt::new(Minus, vec!(1, 1, 1)) == - BigInt::new(Plus, vec!(1, 1, 1))); + assert!(-BigInt::new(Plus, vec![1, 1, 1]) == BigInt::new(Minus, vec![1, 1, 1])); + assert!(-BigInt::new(Minus, vec![1, 1, 1]) == BigInt::new(Plus, vec![1, 1, 1])); let zero: BigInt = Zero::zero(); assert_eq!(-&zero, zero); } @@ -4964,8 +5132,8 @@ mod bigint_tests { } let l: BigInt = FromPrimitive::from_usize(403469000 + 2352).unwrap(); let u: BigInt = FromPrimitive::from_usize(403469000 + 3513).unwrap(); - check( l.clone(), u.clone()); - check(-l.clone(), u.clone()); + check(l.clone(), u.clone()); + check(-l.clone(), u.clone()); check(-u.clone(), -l.clone()); } @@ -4973,7 +5141,7 @@ mod bigint_tests { #[should_panic] fn test_zero_rand_range() { thread_rng().gen_bigint_range(&FromPrimitive::from_isize(54).unwrap(), - &FromPrimitive::from_isize(54).unwrap()); + &FromPrimitive::from_isize(54).unwrap()); } #[test] diff --git a/complex/Cargo.toml b/complex/Cargo.toml new file mode 100644 index 0000000..854128e --- /dev/null +++ b/complex/Cargo.toml @@ -0,0 +1,28 @@ +[package] +authors = ["The Rust Project Developers"] +description = "Complex numbers implementation for Rust" +documentation = "http://rust-num.github.io/num" +homepage = "https://github.com/rust-num/num" +keywords = ["mathematics", "numerics"] +license = "MIT/Apache-2.0" +name = "num-complex" +repository = "https://github.com/rust-num/num" +version = "0.1.0" + +[dependencies] + +[dependencies.num-traits] +optional = false +path = "../traits" + +[dependencies.rustc-serialize] +optional = true +version = "0.3.19" + +[dependencies.serde] +optional = true +version = "^0.7.0" + +[features] +default = ["rustc-serialize"] +unstable = [] diff --git a/src/complex.rs b/complex/src/lib.rs similarity index 98% rename from src/complex.rs rename to complex/src/lib.rs index 8f8cfae..333e552 100644 --- a/src/complex.rs +++ b/complex/src/lib.rs @@ -8,16 +8,25 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - //! Complex numbers. +extern crate num_traits as traits; + +#[cfg(feature = "rustc-serialize")] +extern crate rustc_serialize; + +#[cfg(feature = "serde")] +extern crate serde; + use std::fmt; +#[cfg(test)] +use std::hash; use std::ops::{Add, Div, Mul, Neg, Sub}; #[cfg(feature = "serde")] use serde; -use {Zero, One, Num, Float}; +use traits::{Zero, One, Num, Float}; // FIXME #1284: handle complex NaN & infinity etc. This // probably doesn't map to C's _Complex correctly. @@ -593,6 +602,14 @@ impl serde::Deserialize for Complex where } } +#[cfg(test)] +fn hash(x: &T) -> u64 { + use std::hash::Hasher; + let mut hasher = hash::SipHasher::new(); + x.hash(&mut hasher); + hasher.finish() +} + #[cfg(test)] mod test { #![allow(non_upper_case_globals)] @@ -600,7 +617,7 @@ mod test { use super::{Complex64, Complex}; use std::f64; - use {Zero, One, Float}; + use traits::{Zero, One, Float}; pub const _0_0i : Complex64 = Complex { re: 0.0, im: 0.0 }; pub const _1_0i : Complex64 = Complex { re: 1.0, im: 0.0 }; @@ -993,7 +1010,7 @@ mod test { mod complex_arithmetic { use super::{_0_0i, _1_0i, _1_1i, _0_1i, _neg1_1i, _05_05i, all_consts}; - use Zero; + use traits::Zero; #[test] fn test_add() { diff --git a/integer/Cargo.toml b/integer/Cargo.toml new file mode 100644 index 0000000..e98b258 --- /dev/null +++ b/integer/Cargo.toml @@ -0,0 +1,13 @@ +[package] +authors = ["The Rust Project Developers"] +description = "Integer traits and functions" +documentation = "http://rust-num.github.io/num" +homepage = "https://github.com/rust-num/num" +keywords = ["mathematics", "numerics"] +license = "MIT/Apache-2.0" +repository = "https://github.com/rust-num/num" +name = "num-integer" +version = "0.1.0" + +[dependencies.num-traits] +path = "../traits" diff --git a/src/integer.rs b/integer/src/lib.rs similarity index 88% rename from src/integer.rs rename to integer/src/lib.rs index 883c01c..9c7e8aa 100644 --- a/src/integer.rs +++ b/integer/src/lib.rs @@ -10,17 +10,17 @@ //! Integer trait and functions. -use {Num, Signed}; +extern crate num_traits as traits; -pub trait Integer - : Sized + Num + Ord -{ +use traits::{Num, Signed}; + +pub trait Integer: Sized + Num + PartialOrd + Ord + Eq { /// Floored integer division. /// /// # Examples /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// assert!(( 8).div_floor(& 3) == 2); /// assert!(( 8).div_floor(&-3) == -3); /// assert!((-8).div_floor(& 3) == -3); @@ -36,7 +36,7 @@ pub trait Integer /// Floored integer modulo, satisfying: /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// # let n = 1; let d = 1; /// assert!(n.div_floor(&d) * d + n.mod_floor(&d) == n) /// ~~~ @@ -44,7 +44,7 @@ pub trait Integer /// # Examples /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// assert!(( 8).mod_floor(& 3) == 2); /// assert!(( 8).mod_floor(&-3) == -1); /// assert!((-8).mod_floor(& 3) == 1); @@ -62,7 +62,7 @@ pub trait Integer /// # Examples /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// assert_eq!(6.gcd(&8), 2); /// assert_eq!(7.gcd(&3), 1); /// ~~~ @@ -73,7 +73,7 @@ pub trait Integer /// # Examples /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// assert_eq!(7.lcm(&3), 21); /// assert_eq!(2.lcm(&4), 4); /// ~~~ @@ -87,7 +87,7 @@ pub trait Integer /// # Examples /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// assert_eq!(9.is_multiple_of(&3), true); /// assert_eq!(3.is_multiple_of(&9), false); /// ~~~ @@ -98,7 +98,7 @@ pub trait Integer /// # Examples /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// assert_eq!(3.is_even(), false); /// assert_eq!(4.is_even(), true); /// ~~~ @@ -109,7 +109,7 @@ pub trait Integer /// # Examples /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// assert_eq!(3.is_odd(), true); /// assert_eq!(4.is_odd(), false); /// ~~~ @@ -121,7 +121,7 @@ pub trait Integer /// # Examples /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// assert_eq!(( 8).div_rem( &3), ( 2, 2)); /// assert_eq!(( 8).div_rem(&-3), (-2, 2)); /// assert_eq!((-8).div_rem( &3), (-2, -2)); @@ -141,7 +141,7 @@ pub trait Integer /// # Examples /// /// ~~~ - /// # use num::Integer; + /// # use num_integer::Integer; /// assert_eq!(( 8).div_mod_floor( &3), ( 2, 2)); /// assert_eq!(( 8).div_mod_floor(&-3), (-3, -1)); /// assert_eq!((-8).div_mod_floor( &3), (-3, 1)); @@ -158,26 +158,44 @@ pub trait Integer } /// Simultaneous integer division and modulus -#[inline] pub fn div_rem(x: T, y: T) -> (T, T) { x.div_rem(&y) } +#[inline] +pub fn div_rem(x: T, y: T) -> (T, T) { + x.div_rem(&y) +} /// Floored integer division -#[inline] pub fn div_floor(x: T, y: T) -> T { x.div_floor(&y) } +#[inline] +pub fn div_floor(x: T, y: T) -> T { + x.div_floor(&y) +} /// Floored integer modulus -#[inline] pub fn mod_floor(x: T, y: T) -> T { x.mod_floor(&y) } +#[inline] +pub fn mod_floor(x: T, y: T) -> T { + x.mod_floor(&y) +} /// Simultaneous floored integer division and modulus -#[inline] pub fn div_mod_floor(x: T, y: T) -> (T, T) { x.div_mod_floor(&y) } +#[inline] +pub fn div_mod_floor(x: T, y: T) -> (T, T) { + x.div_mod_floor(&y) +} /// Calculates the Greatest Common Divisor (GCD) of the number and `other`. The /// result is always positive. -#[inline(always)] pub fn gcd(x: T, y: T) -> T { x.gcd(&y) } +#[inline(always)] +pub fn gcd(x: T, y: T) -> T { + x.gcd(&y) +} /// Calculates the Lowest Common Multiple (LCM) of the number and `other`. -#[inline(always)] pub fn lcm(x: T, y: T) -> T { x.lcm(&y) } +#[inline(always)] +pub fn lcm(x: T, y: T) -> T { + x.lcm(&y) +} macro_rules! impl_integer_for_isize { ($T:ty, $test_mod:ident) => ( impl Integer for $T { /// Floored integer division #[inline] - fn div_floor(&self, other: &$T) -> $T { + fn div_floor(&self, other: &Self) -> Self { // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_, // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf) match self.div_rem(other) { @@ -189,7 +207,7 @@ macro_rules! impl_integer_for_isize { /// Floored integer modulo #[inline] - fn mod_floor(&self, other: &$T) -> $T { + fn mod_floor(&self, other: &Self) -> Self { // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_, // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf) match *self % *other { @@ -201,7 +219,7 @@ macro_rules! impl_integer_for_isize { /// Calculates `div_floor` and `mod_floor` simultaneously #[inline] - fn div_mod_floor(&self, other: &$T) -> ($T,$T) { + fn div_mod_floor(&self, other: &Self) -> (Self, Self) { // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_, // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf) match self.div_rem(other) { @@ -214,7 +232,7 @@ macro_rules! impl_integer_for_isize { /// Calculates the Greatest Common Divisor (GCD) of the number and /// `other`. The result is always positive. #[inline] - fn gcd(&self, other: &$T) -> $T { + fn gcd(&self, other: &Self) -> Self { // Use Stein's algorithm let mut m = *self; let mut n = *other; @@ -231,7 +249,7 @@ macro_rules! impl_integer_for_isize { // Assuming two's complement, the number created by the shift // is positive for all numbers except gcd = abs(min value) // The call to .abs() causes a panic in debug mode - if m == <$T>::min_value() || n == <$T>::min_value() { + if m == Self::min_value() || n == Self::min_value() { return (1 << shift).abs() } @@ -255,18 +273,22 @@ macro_rules! impl_integer_for_isize { /// Calculates the Lowest Common Multiple (LCM) of the number and /// `other`. #[inline] - fn lcm(&self, other: &$T) -> $T { + fn lcm(&self, other: &Self) -> Self { // should not have to recalculate abs (*self * (*other / self.gcd(other))).abs() } /// Deprecated, use `is_multiple_of` instead. #[inline] - fn divides(&self, other: &$T) -> bool { return self.is_multiple_of(other); } + fn divides(&self, other: &Self) -> bool { + self.is_multiple_of(other) + } /// Returns `true` if the number is a multiple of `other`. #[inline] - fn is_multiple_of(&self, other: &$T) -> bool { *self % *other == 0 } + fn is_multiple_of(&self, other: &Self) -> bool { + *self % *other == 0 + } /// Returns `true` if the number is divisible by `2` #[inline] @@ -278,7 +300,7 @@ macro_rules! impl_integer_for_isize { /// Simultaneous truncated integer division and modulus. #[inline] - fn div_rem(&self, other: &$T) -> ($T, $T) { + fn div_rem(&self, other: &Self) -> (Self, Self) { (*self / *other, *self % *other) } } @@ -293,7 +315,7 @@ macro_rules! impl_integer_for_isize { /// - `d`: denominator (divisor) /// - `qr`: quotient and remainder #[cfg(test)] - fn test_division_rule((n,d): ($T,$T), (q,r): ($T,$T)) { + fn test_division_rule((n,d): ($T, $T), (q,r): ($T, $T)) { assert_eq!(d * q + r, n); } @@ -462,26 +484,30 @@ macro_rules! impl_integer_for_isize { ) } -impl_integer_for_isize!(i8, test_integer_i8); -impl_integer_for_isize!(i16, test_integer_i16); -impl_integer_for_isize!(i32, test_integer_i32); -impl_integer_for_isize!(i64, test_integer_i64); -impl_integer_for_isize!(isize, test_integer_isize); +impl_integer_for_isize!(i8, test_integer_i8); +impl_integer_for_isize!(i16, test_integer_i16); +impl_integer_for_isize!(i32, test_integer_i32); +impl_integer_for_isize!(i64, test_integer_i64); +impl_integer_for_isize!(isize, test_integer_isize); macro_rules! impl_integer_for_usize { ($T:ty, $test_mod:ident) => ( impl Integer for $T { /// Unsigned integer division. Returns the same result as `div` (`/`). #[inline] - fn div_floor(&self, other: &$T) -> $T { *self / *other } + fn div_floor(&self, other: &Self) -> Self { + *self / *other + } /// Unsigned integer modulo operation. Returns the same result as `rem` (`%`). #[inline] - fn mod_floor(&self, other: &$T) -> $T { *self % *other } + fn mod_floor(&self, other: &Self) -> Self { + *self % *other + } /// Calculates the Greatest Common Divisor (GCD) of the number and `other` #[inline] - fn gcd(&self, other: &$T) -> $T { + fn gcd(&self, other: &Self) -> Self { // Use Stein's algorithm let mut m = *self; let mut n = *other; @@ -505,29 +531,37 @@ macro_rules! impl_integer_for_usize { /// Calculates the Lowest Common Multiple (LCM) of the number and `other`. #[inline] - fn lcm(&self, other: &$T) -> $T { + fn lcm(&self, other: &Self) -> Self { *self * (*other / self.gcd(other)) } /// Deprecated, use `is_multiple_of` instead. #[inline] - fn divides(&self, other: &$T) -> bool { return self.is_multiple_of(other); } + fn divides(&self, other: &Self) -> bool { + self.is_multiple_of(other) + } /// Returns `true` if the number is a multiple of `other`. #[inline] - fn is_multiple_of(&self, other: &$T) -> bool { *self % *other == 0 } + fn is_multiple_of(&self, other: &Self) -> bool { + *self % *other == 0 + } /// Returns `true` if the number is divisible by `2`. #[inline] - fn is_even(&self) -> bool { (*self) & 1 == 0 } + fn is_even(&self) -> bool { + *self % 2 == 0 + } /// Returns `true` if the number is not divisible by `2`. #[inline] - fn is_odd(&self) -> bool { !(*self).is_even() } + fn is_odd(&self) -> bool { + !self.is_even() + } /// Simultaneous truncated integer division and modulus. #[inline] - fn div_rem(&self, other: &$T) -> ($T, $T) { + fn div_rem(&self, other: &Self) -> (Self, Self) { (*self / *other, *self % *other) } } @@ -621,10 +655,10 @@ macro_rules! impl_integer_for_usize { ) } -impl_integer_for_usize!(u8, test_integer_u8); -impl_integer_for_usize!(u16, test_integer_u16); -impl_integer_for_usize!(u32, test_integer_u32); -impl_integer_for_usize!(u64, test_integer_u64); +impl_integer_for_usize!(u8, test_integer_u8); +impl_integer_for_usize!(u16, test_integer_u16); +impl_integer_for_usize!(u32, test_integer_u32); +impl_integer_for_usize!(u64, test_integer_u64); impl_integer_for_usize!(usize, test_integer_usize); #[test] diff --git a/iter/Cargo.toml b/iter/Cargo.toml new file mode 100644 index 0000000..4cb0561 --- /dev/null +++ b/iter/Cargo.toml @@ -0,0 +1,20 @@ +[package] +authors = ["The Rust Project Developers"] +description = "External iterators for generic mathematics" +documentation = "http://rust-num.github.io/num" +homepage = "https://github.com/rust-num/num" +keywords = ["mathematics", "numerics"] +license = "MIT/Apache-2.0" +repository = "https://github.com/rust-num/num" +name = "num-iter" +version = "0.1.0" + +[dependencies] + +[dependencies.num-integer] +optional = false +path = "../integer" + +[dependencies.num-traits] +optional = false +path = "../traits" diff --git a/src/iter.rs b/iter/src/lib.rs similarity index 98% rename from src/iter.rs rename to iter/src/lib.rs index 33bc267..76fafbd 100644 --- a/src/iter.rs +++ b/iter/src/lib.rs @@ -10,7 +10,11 @@ //! External iterators for generic mathematics -use {Integer, Zero, One, CheckedAdd, ToPrimitive}; +extern crate num_traits as traits; +extern crate num_integer as integer; + +use integer::Integer; +use traits::{Zero, One, CheckedAdd, ToPrimitive}; use std::ops::{Add, Sub}; /// An iterator over the range [start, stop) @@ -27,11 +31,9 @@ pub struct Range { /// # Example /// /// ```rust -/// use num::iter; -/// /// let array = [0, 1, 2, 3, 4]; /// -/// for i in iter::range(0, 5) { +/// for i in num_iter::range(0, 5) { /// println!("{}", i); /// assert_eq!(i, array[i]); /// } @@ -261,7 +263,7 @@ mod tests { use std::usize; use std::ops::{Add, Mul}; use std::cmp::Ordering; - use {One, ToPrimitive}; + use traits::{One, ToPrimitive}; #[test] fn test_range() { diff --git a/num-macros/Cargo.toml b/macros/Cargo.toml similarity index 89% rename from num-macros/Cargo.toml rename to macros/Cargo.toml index c543038..427b6f2 100644 --- a/num-macros/Cargo.toml +++ b/macros/Cargo.toml @@ -7,9 +7,7 @@ homepage = "https://github.com/rust-num/num" repository = "https://github.com/rust-num/num" documentation = "http://rust-num.github.io/num" keywords = ["mathematics", "numerics"] -description = """ -Numeric syntax extensions. -""" +description = "Numeric syntax extensions" [lib] name = "num_macros" diff --git a/num-macros/src/lib.rs b/macros/src/lib.rs similarity index 100% rename from num-macros/src/lib.rs rename to macros/src/lib.rs diff --git a/num-macros/tests/test_macro.rs b/macros/tests/test_macro.rs similarity index 100% rename from num-macros/tests/test_macro.rs rename to macros/tests/test_macro.rs diff --git a/rational/Cargo.toml b/rational/Cargo.toml new file mode 100644 index 0000000..1fa46e3 --- /dev/null +++ b/rational/Cargo.toml @@ -0,0 +1,34 @@ +[package] +authors = ["The Rust Project Developers"] +description = "Rational numbers implementation for Rust" +documentation = "http://rust-num.github.io/num" +homepage = "https://github.com/rust-num/num" +keywords = ["mathematics", "numerics"] +license = "MIT/Apache-2.0" +name = "num-rational" +repository = "https://github.com/rust-num/num" +version = "0.1.0" + +[dependencies] + +[dependencies.num-bigint] +optional = true +path = "../bigint" + +[dependencies.num-integer] +path = "../integer" + +[dependencies.num-traits] +path = "../traits" + +[dependencies.rustc-serialize] +optional = true +version = "0.3.19" + +[dependencies.serde] +optional = true +version = "0.7.0" + +[features] +default = ["bigint", "rustc-serialize"] +bigint = ["num-bigint"] diff --git a/src/rational.rs b/rational/src/lib.rs similarity index 80% rename from src/rational.rs rename to rational/src/lib.rs index 5778839..f6e2cbd 100644 --- a/src/rational.rs +++ b/rational/src/lib.rs @@ -10,21 +10,32 @@ //! Rational numbers -use Integer; +#[cfg(feature = "rustc-serialize")] +extern crate rustc_serialize; +#[cfg(feature = "serde")] +extern crate serde; +#[cfg(feature = "num-bigint")] +extern crate num_bigint as bigint; + +extern crate num_traits as traits; +extern crate num_integer as integer; use std::cmp; use std::error::Error; use std::fmt; +#[cfg(test)] +use std::hash; use std::ops::{Add, Div, Mul, Neg, Rem, Sub}; use std::str::FromStr; #[cfg(feature = "serde")] use serde; -#[cfg(feature = "bigint")] +#[cfg(feature = "num-bigint")] use bigint::{BigInt, BigUint, Sign}; -use traits::{FromPrimitive, Float, PrimInt}; -use {Num, Signed, Zero, One}; + +use integer::Integer; +use traits::{FromPrimitive, Float, PrimInt, Num, Signed, Zero, One}; /// Represents the ratio between 2 numbers. #[derive(Copy, Clone, Hash, Debug)] @@ -32,7 +43,7 @@ use {Num, Signed, Zero, One}; #[allow(missing_docs)] pub struct Ratio { numer: T, - denom: T + denom: T, } /// Alias for a `Ratio` of machine-sized integers. @@ -40,7 +51,7 @@ pub type Rational = Ratio; pub type Rational32 = Ratio; pub type Rational64 = Ratio; -#[cfg(feature = "bigint")] +#[cfg(feature = "num-bigint")] /// Alias for arbitrary precision rationals. pub type BigRational = Ratio; @@ -54,7 +65,10 @@ impl Ratio { /// 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 } + Ratio { + numer: numer, + denom: denom, + } } /// Create a new Ratio. Fails if `denom == 0`. @@ -94,7 +108,7 @@ impl Ratio { /// Put self into lowest terms, with denom > 0. fn reduce(&mut self) { - let g : T = self.numer.gcd(&self.denom); + let g: T = self.numer.gcd(&self.denom); // FIXME(#5992): assignment operator overloads // self.numer /= g; @@ -128,7 +142,8 @@ impl Ratio { 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()) + Ratio::from_integer((self.numer.clone() - self.denom.clone() + one) / + self.denom.clone()) } else { Ratio::from_integer(self.numer.clone() / self.denom.clone()) } @@ -141,7 +156,8 @@ impl Ratio { 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()) + Ratio::from_integer((self.numer.clone() + self.denom.clone() - one) / + self.denom.clone()) } } @@ -154,7 +170,9 @@ impl Ratio { // Find unsigned fractional part of rational number let mut fractional = self.fract(); - if fractional < zero { fractional = zero - fractional }; + 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 @@ -197,13 +215,14 @@ impl 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)), + cmp::Ordering::Greater => { + Ratio::new_raw(self.numer.pow(expon as u32), self.denom.pow(expon as u32)) + } } } } -#[cfg(feature = "bigint")] +#[cfg(feature = "num-bigint")] impl Ratio { /// Converts a float into a rational number. pub fn from_float(f: T) -> Option { @@ -211,7 +230,11 @@ impl Ratio { return None; } let (mantissa, exponent, sign) = f.integer_decode(); - let bigint_sign = if sign == 1 { Sign::Plus } else { Sign::Minus }; + 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); @@ -225,7 +248,7 @@ impl Ratio { } } -/* Comparisons */ +// 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. @@ -236,13 +259,21 @@ impl Ord for Ratio { // 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 }; + 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() }; + return if self.numer < T::zero() { + ord + } else { + ord.reverse() + }; } // Unfortunately, we don't have CheckedMul to try. That could sometimes avoid all the @@ -267,7 +298,7 @@ impl Ord for Ratio { self_recip.cmp(&other_recip).reverse() } } - }, + } } } } @@ -340,17 +371,17 @@ macro_rules! forward_all_binop { }; } -/* Arithmetic */ +// 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; + type Output = Ratio; #[inline] fn mul(self, rhs: &Ratio) -> Ratio { - Ratio::new(self.numer.clone() * rhs.numer.clone(), self.denom.clone() * rhs.denom.clone()) + Ratio::new(self.numer.clone() * rhs.numer.clone(), + self.denom.clone() * rhs.denom.clone()) } } @@ -363,7 +394,8 @@ impl<'a, 'b, T> Div<&'b Ratio> for &'a Ratio #[inline] fn div(self, rhs: &Ratio) -> Ratio { - Ratio::new(self.numer.clone() * rhs.denom.clone(), self.denom.clone() * rhs.numer.clone()) + Ratio::new(self.numer.clone() * rhs.denom.clone(), + self.denom.clone() * rhs.numer.clone()) } } @@ -414,9 +446,8 @@ impl<'a, T> Neg for &'a Ratio } } -/* Constants */ -impl - Zero for Ratio { +// Constants +impl Zero for Ratio { #[inline] fn zero() -> Ratio { Ratio::new_raw(Zero::zero(), One::one()) @@ -428,8 +459,7 @@ impl } } -impl - One for Ratio { +impl One for Ratio { #[inline] fn one() -> Ratio { Ratio::new_raw(One::one(), One::one()) @@ -443,19 +473,21 @@ impl Num for Ratio { 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}) + Err(ParseRatioError { kind: RatioErrorKind::ParseError }) } else { - let a_result: Result = T::from_str_radix( - split[0], - radix).map_err(|_| ParseRatioError{kind: RatioErrorKind::ParseError}); + 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())) + 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())) + } }) }) } @@ -465,12 +497,20 @@ impl Num for Ratio { impl Signed for Ratio { #[inline] fn abs(&self) -> Ratio { - if self.is_negative() { -self.clone() } else { self.clone() } + 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 } + if *self <= *other { + Zero::zero() + } else { + self - other + } } #[inline] @@ -480,12 +520,14 @@ impl Signed for Ratio { } else if self.is_zero() { Self::zero() } else { - - Self::one() + -Self::one() } } #[inline] - fn is_positive(&self) -> bool { !self.is_negative() } + fn is_positive(&self) -> bool { + !self.is_negative() + } #[inline] fn is_negative(&self) -> bool { @@ -493,9 +535,9 @@ impl Signed for Ratio { } } -/* String conversions */ -impl fmt::Display for Ratio where - T: fmt::Display + Eq + One +// 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 { @@ -514,17 +556,16 @@ impl FromStr for Ratio { 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 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})); + let den = try!(FromStr::from_str(d) + .map_err(|_| ParseRatioError { kind: RatioErrorKind::ParseError })); if Zero::is_zero(&den) { - Err(ParseRatioError{kind: RatioErrorKind::ZeroDenominator}) + Err(ParseRatioError { kind: RatioErrorKind::ZeroDenominator }) } else { Ok(Ratio::new(num, den)) } @@ -535,8 +576,8 @@ impl FromStr for Ratio { 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 + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: serde::Serializer { (self.numer(), self.denom()).serialize(serializer) } @@ -546,8 +587,8 @@ impl serde::Serialize for Ratio impl serde::Deserialize for Ratio where T: serde::Deserialize + Clone + Integer + PartialOrd { - fn deserialize(deserializer: &mut D) -> Result where - D: serde::Deserializer, + fn deserialize(deserializer: &mut D) -> Result + where D: serde::Deserializer { let (numer, denom) = try!(serde::Deserialize::deserialize(deserializer)); if denom == Zero::zero() { @@ -560,7 +601,9 @@ impl serde::Deserialize for Ratio // FIXME: Bubble up specific errors #[derive(Copy, Clone, Debug, PartialEq)] -pub struct ParseRatioError { kind: RatioErrorKind } +pub struct ParseRatioError { + kind: RatioErrorKind, +} #[derive(Copy, Clone, Debug, PartialEq)] enum RatioErrorKind { @@ -575,7 +618,9 @@ impl fmt::Display for ParseRatioError { } impl Error for ParseRatioError { - fn description(&self) -> &str { self.kind.description() } + fn description(&self) -> &str { + self.kind.description() + } } impl RatioErrorKind { @@ -588,39 +633,73 @@ impl RatioErrorKind { } #[cfg(test)] -mod test { +fn hash(x: &T) -> u64 { + use std::hash::Hasher; + let mut hasher = hash::SipHasher::new(); + x.hash(&mut hasher); + hasher.finish() +} +#[cfg(test)] +mod test { use super::{Ratio, Rational}; - #[cfg(feature = "bigint")] + #[cfg(feature = "num-bigint")] use super::BigRational; + use std::str::FromStr; use std::i32; - use {Zero, One, Signed, FromPrimitive, Float}; + use traits::{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}; + 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")] + #[cfg(feature = "num-bigint")] pub fn to_big(n: Rational) -> BigRational { - Ratio::new( - FromPrimitive::from_isize(n.numer).unwrap(), - FromPrimitive::from_isize(n.denom).unwrap() - ) + Ratio::new(FromPrimitive::from_isize(n.numer).unwrap(), + FromPrimitive::from_isize(n.denom).unwrap()) } - #[cfg(not(feature = "bigint"))] + #[cfg(not(feature = "num-bigint"))] pub fn to_big(n: Rational) -> Rational { - Ratio::new( - FromPrimitive::from_isize(n.numer).unwrap(), - FromPrimitive::from_isize(n.denom).unwrap() - ) + Ratio::new(FromPrimitive::from_isize(n.numer).unwrap(), + FromPrimitive::from_isize(n.denom).unwrap()) } #[test] @@ -629,21 +708,21 @@ mod test { 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)); + 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); + let one22 = Ratio::new(2, 2); assert_eq!(one22, One::one()); } #[test] #[should_panic] fn test_new_zero() { - let _a = Ratio::new(1,0); + let _a = Ratio::new(1, 0); } @@ -690,7 +769,7 @@ mod test { 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..] { + 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); @@ -785,7 +864,7 @@ mod test { } test(_1, _1_2, _1_2); - test(_1_2, _3_2, Ratio::new(3,4)); + test(_1_2, _3_2, Ratio::new(3, 4)); test(_1_2, _NEG1_2, Ratio::new(-1, 4)); } @@ -810,7 +889,7 @@ mod test { test(_3_2, _1, _1_2); test(_2, _NEG1_2, _0); - test(_1_2, _2, _1_2); + test(_1_2, _2, _1_2); } #[test] @@ -835,7 +914,7 @@ mod test { #[test] #[should_panic] fn test_div_0() { - let _a = _1 / _0; + let _a = _1 / _0; } } @@ -879,13 +958,13 @@ mod test { // 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_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()); @@ -947,27 +1026,28 @@ mod test { assert!(rational.is_err()); } - let xs = ["0 /1", "abc", "", "1/", "--1/2","3/2/1", "1/0"]; + let xs = ["0 /1", "abc", "", "1/", "--1/2", "3/2/1", "1/0"]; for &s in xs.iter() { test(s); } } - #[cfg(feature = "bigint")] + #[cfg(feature = "num-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())); + 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(1.0 / 2f32.powf(100.), + ("1", "1267650600228229401496703205376")); test(684729.48391f32, ("1369459", "2")); test(-8573.5918555f32, ("-4389679", "512")); @@ -977,10 +1057,11 @@ mod test { test(-2f64.powf(100.), ("-1267650600228229401496703205376", "1")); test(684729.48391f64, ("367611342500051", "536870912")); test(-8573.5918555f64, ("-4713381968463931", "549755813888")); - test(1.0 / 2f64.powf(100.), ("1", "1267650600228229401496703205376")); + test(1.0 / 2f64.powf(100.), + ("1", "1267650600228229401496703205376")); } - #[cfg(feature = "bigint")] + #[cfg(feature = "num-bigint")] #[test] fn test_from_float_fail() { use std::{f32, f64}; @@ -999,10 +1080,10 @@ mod test { 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_eq!(_NEG1_2.signum(), ->::one()); assert!(_NEG1_2.is_negative()); - assert!(! _NEG1_2.is_positive()); - assert!(! _1_2.is_negative()); + assert!(!_NEG1_2.is_positive()); + assert!(!_1_2.is_negative()); } #[test] diff --git a/src/lib.rs b/src/lib.rs index c9a3099..97d0fc1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -57,44 +57,41 @@ html_root_url = "http://rust-num.github.io/num/", html_playground_url = "http://play.rust-lang.org/")] -#[cfg(feature = "rustc-serialize")] -extern crate rustc_serialize; +pub extern crate num_traits; +pub extern crate num_integer; +pub extern crate num_iter; +#[cfg(feature = "num-complex")] +pub extern crate num_complex; +#[cfg(feature = "num-bigint")] +pub extern crate num_bigint; +#[cfg(feature = "num-rational")] +pub extern crate num_rational; -// Some of the tests of non-RNG-based functionality are randomized using the -// RNG-based functionality, so the RNG-based functionality needs to be enabled -// for tests. -#[cfg(any(feature = "rand", all(feature = "bigint", test)))] -extern crate rand; - -#[cfg(feature = "serde")] -extern crate serde; - -#[cfg(feature = "bigint")] -pub use bigint::{BigInt, BigUint}; -#[cfg(feature = "rational")] -pub use rational::Rational; -#[cfg(all(feature = "rational", feature="bigint"))] -pub use rational::BigRational; -#[cfg(feature = "complex")] -pub use complex::Complex; -pub use integer::Integer; -pub use iter::{range, range_inclusive, range_step, range_step_inclusive}; -pub use traits::{Num, Zero, One, Signed, Unsigned, Bounded, - Saturating, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, - PrimInt, Float, ToPrimitive, FromPrimitive, NumCast, cast}; - -#[cfg(test)] use std::hash; +#[cfg(feature = "num-bigint")] +pub use num_bigint::{BigInt, BigUint}; +#[cfg(feature = "num-rational")] +pub use num_rational::Rational; +#[cfg(all(feature = "num-rational", feature="num-bigint"))] +pub use num_rational::BigRational; +#[cfg(feature = "num-complex")] +pub use num_complex::Complex; +pub use num_integer::Integer; +pub use num_iter::{range, range_inclusive, range_step, range_step_inclusive}; +pub use num_traits::{Num, Zero, One, Signed, Unsigned, Bounded, + Saturating, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, + PrimInt, Float, ToPrimitive, FromPrimitive, NumCast, cast}; use std::ops::{Mul}; -#[cfg(feature = "bigint")] -pub mod bigint; -pub mod complex; -pub mod integer; -pub mod iter; -pub mod traits; -#[cfg(feature = "rational")] -pub mod rational; +#[cfg(feature = "num-bigint")] +pub use num_bigint as bigint; +#[cfg(feature = "num-complex")] +pub use num_complex as complex; +pub use num_integer as integer; +pub use num_iter as iter; +pub use num_traits as traits; +#[cfg(feature = "num-rational")] +pub use num_rational as rational; /// Returns the additive identity, `0`. #[inline(always)] pub fn zero() -> T { Zero::zero() } @@ -206,11 +203,3 @@ pub fn checked_pow(mut base: T, mut exp: usize) -> } Some(acc) } - -#[cfg(test)] -fn hash(x: &T) -> u64 { - use std::hash::Hasher; - let mut hasher = hash::SipHasher::new(); - x.hash(&mut hasher); - hasher.finish() -} diff --git a/src/traits.rs b/src/traits.rs deleted file mode 100644 index a4205d7..0000000 --- a/src/traits.rs +++ /dev/null @@ -1,2552 +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. - -//! Numeric traits for generic mathematics - -use std::ops::{Add, Sub, Mul, Div, Rem, Neg}; -use std::ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr}; -use std::{usize, u8, u16, u32, u64}; -use std::{isize, i8, i16, i32, i64}; -use std::{f32, f64}; -use std::mem::{self, size_of}; -use std::num::FpCategory; - -/// The base trait for numeric types -pub trait Num: PartialEq + Zero + One - + Add + Sub - + Mul + Div + Rem -{ - /// Parse error for `from_str_radix` - type FromStrRadixErr; - - /// Convert from a string and radix <= 36. - fn from_str_radix(str: &str, radix: u32) -> Result; -} - -macro_rules! int_trait_impl { - ($name:ident for $($t:ty)*) => ($( - impl $name for $t { - type FromStrRadixErr = ::std::num::ParseIntError; - fn from_str_radix(s: &str, radix: u32) - -> Result - { - <$t>::from_str_radix(s, radix) - } - } - )*) -} - -// FIXME: std::num::ParseFloatError is stable in 1.0, but opaque to us, -// so there's not really any way for us to reuse it. -#[derive(Debug)] -pub struct ParseFloatError { pub kind: FloatErrorKind } -#[derive(Debug)] -pub enum FloatErrorKind { Empty, Invalid } - -// FIXME: The standard library from_str_radix on floats was deprecated, so we're stuck -// with this implementation ourselves until we want to make a breaking change. -// (would have to drop it from `Num` though) -macro_rules! float_trait_impl { - ($name:ident for $($t:ty)*) => ($( - impl $name for $t { - type FromStrRadixErr = ParseFloatError; - fn from_str_radix(src: &str, radix: u32) - -> Result - { - use self::FloatErrorKind::*; - use self::ParseFloatError as PFE; - - // Special values - match src { - "inf" => return Ok(Float::infinity()), - "-inf" => return Ok(Float::neg_infinity()), - "NaN" => return Ok(Float::nan()), - _ => {}, - } - - fn slice_shift_char(src: &str) -> Option<(char, &str)> { - src.chars().nth(0).map(|ch| (ch, &src[1..])) - } - - let (is_positive, src) = match slice_shift_char(src) { - None => return Err(PFE { kind: Empty }), - Some(('-', "")) => return Err(PFE { kind: Empty }), - Some(('-', src)) => (false, src), - Some((_, _)) => (true, src), - }; - - // The significand to accumulate - let mut sig = if is_positive { 0.0 } else { -0.0 }; - // Necessary to detect overflow - let mut prev_sig = sig; - let mut cs = src.chars().enumerate(); - // Exponent prefix and exponent index offset - let mut exp_info = None::<(char, usize)>; - - // Parse the integer part of the significand - for (i, c) in cs.by_ref() { - match c.to_digit(radix) { - Some(digit) => { - // shift significand one digit left - sig = sig * (radix as $t); - - // add/subtract current digit depending on sign - if is_positive { - sig = sig + ((digit as isize) as $t); - } else { - sig = sig - ((digit as isize) as $t); - } - - // Detect overflow by comparing to last value, except - // if we've not seen any non-zero digits. - if prev_sig != 0.0 { - if is_positive && sig <= prev_sig - { return Ok(Float::infinity()); } - if !is_positive && sig >= prev_sig - { return Ok(Float::neg_infinity()); } - - // Detect overflow by reversing the shift-and-add process - if is_positive && (prev_sig != (sig - digit as $t) / radix as $t) - { return Ok(Float::infinity()); } - if !is_positive && (prev_sig != (sig + digit as $t) / radix as $t) - { return Ok(Float::neg_infinity()); } - } - prev_sig = sig; - }, - None => match c { - 'e' | 'E' | 'p' | 'P' => { - exp_info = Some((c, i + 1)); - break; // start of exponent - }, - '.' => { - break; // start of fractional part - }, - _ => { - return Err(PFE { kind: Invalid }); - }, - }, - } - } - - // If we are not yet at the exponent parse the fractional - // part of the significand - if exp_info.is_none() { - let mut power = 1.0; - for (i, c) in cs.by_ref() { - match c.to_digit(radix) { - Some(digit) => { - // Decrease power one order of magnitude - power = power / (radix as $t); - // add/subtract current digit depending on sign - sig = if is_positive { - sig + (digit as $t) * power - } else { - sig - (digit as $t) * power - }; - // Detect overflow by comparing to last value - if is_positive && sig < prev_sig - { return Ok(Float::infinity()); } - if !is_positive && sig > prev_sig - { return Ok(Float::neg_infinity()); } - prev_sig = sig; - }, - None => match c { - 'e' | 'E' | 'p' | 'P' => { - exp_info = Some((c, i + 1)); - break; // start of exponent - }, - _ => { - return Err(PFE { kind: Invalid }); - }, - }, - } - } - } - - // Parse and calculate the exponent - let exp = match exp_info { - Some((c, offset)) => { - let base = match c { - 'E' | 'e' if radix == 10 => 10.0, - 'P' | 'p' if radix == 16 => 2.0, - _ => return Err(PFE { kind: Invalid }), - }; - - // Parse the exponent as decimal integer - let src = &src[offset..]; - let (is_positive, exp) = match slice_shift_char(src) { - Some(('-', src)) => (false, src.parse::()), - Some(('+', src)) => (true, src.parse::()), - Some((_, _)) => (true, src.parse::()), - None => return Err(PFE { kind: Invalid }), - }; - - match (is_positive, exp) { - (true, Ok(exp)) => base.powi(exp as i32), - (false, Ok(exp)) => 1.0 / base.powi(exp as i32), - (_, Err(_)) => return Err(PFE { kind: Invalid }), - } - }, - None => 1.0, // no exponent - }; - - Ok(sig * exp) - - } - } - )*) -} - -int_trait_impl!(Num for usize u8 u16 u32 u64 isize i8 i16 i32 i64); -float_trait_impl!(Num for f32 f64); - -/// Defines an additive identity element for `Self`. -pub trait Zero: Sized + Add { - /// Returns the additive identity element of `Self`, `0`. - /// - /// # Laws - /// - /// ```{.text} - /// a + 0 = a ∀ a ∈ Self - /// 0 + a = a ∀ a ∈ Self - /// ``` - /// - /// # Purity - /// - /// This function should return the same result at all times regardless of - /// external mutable state, for example values stored in TLS or in - /// `static mut`s. - // FIXME (#5527): This should be an associated constant - fn zero() -> Self; - - /// Returns `true` if `self` is equal to the additive identity. - #[inline] - fn is_zero(&self) -> bool; -} - -macro_rules! zero_impl { - ($t:ty, $v:expr) => { - impl Zero for $t { - #[inline] - fn zero() -> $t { $v } - #[inline] - fn is_zero(&self) -> bool { *self == $v } - } - } -} - -zero_impl!(usize, 0usize); -zero_impl!(u8, 0u8); -zero_impl!(u16, 0u16); -zero_impl!(u32, 0u32); -zero_impl!(u64, 0u64); - -zero_impl!(isize, 0isize); -zero_impl!(i8, 0i8); -zero_impl!(i16, 0i16); -zero_impl!(i32, 0i32); -zero_impl!(i64, 0i64); - -zero_impl!(f32, 0.0f32); -zero_impl!(f64, 0.0f64); - -/// Defines a multiplicative identity element for `Self`. -pub trait One: Sized + Mul { - /// Returns the multiplicative identity element of `Self`, `1`. - /// - /// # Laws - /// - /// ```{.text} - /// a * 1 = a ∀ a ∈ Self - /// 1 * a = a ∀ a ∈ Self - /// ``` - /// - /// # Purity - /// - /// This function should return the same result at all times regardless of - /// external mutable state, for example values stored in TLS or in - /// `static mut`s. - // FIXME (#5527): This should be an associated constant - fn one() -> Self; -} - -macro_rules! one_impl { - ($t:ty, $v:expr) => { - impl One for $t { - #[inline] - fn one() -> $t { $v } - } - } -} - -one_impl!(usize, 1usize); -one_impl!(u8, 1u8); -one_impl!(u16, 1u16); -one_impl!(u32, 1u32); -one_impl!(u64, 1u64); - -one_impl!(isize, 1isize); -one_impl!(i8, 1i8); -one_impl!(i16, 1i16); -one_impl!(i32, 1i32); -one_impl!(i64, 1i64); - -one_impl!(f32, 1.0f32); -one_impl!(f64, 1.0f64); - -/// Useful functions for signed numbers (i.e. numbers that can be negative). -pub trait Signed: Sized + Num + Neg { - /// Computes the absolute value. - /// - /// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`. - /// - /// For signed integers, `::MIN` will be returned if the number is `::MIN`. - fn abs(&self) -> Self; - - /// The positive difference of two numbers. - /// - /// Returns `zero` if the number is less than or equal to `other`, otherwise the difference - /// between `self` and `other` is returned. - fn abs_sub(&self, other: &Self) -> Self; - - /// Returns the sign of the number. - /// - /// For `f32` and `f64`: - /// - /// * `1.0` if the number is positive, `+0.0` or `INFINITY` - /// * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` - /// * `NaN` if the number is `NaN` - /// - /// For signed integers: - /// - /// * `0` if the number is zero - /// * `1` if the number is positive - /// * `-1` if the number is negative - fn signum(&self) -> Self; - - /// Returns true if the number is positive and false if the number is zero or negative. - fn is_positive(&self) -> bool; - - /// Returns true if the number is negative and false if the number is zero or positive. - fn is_negative(&self) -> bool; -} - -macro_rules! signed_impl { - ($($t:ty)*) => ($( - impl Signed for $t { - #[inline] - fn abs(&self) -> $t { - if self.is_negative() { -*self } else { *self } - } - - #[inline] - fn abs_sub(&self, other: &$t) -> $t { - if *self <= *other { 0 } else { *self - *other } - } - - #[inline] - fn signum(&self) -> $t { - match *self { - n if n > 0 => 1, - 0 => 0, - _ => -1, - } - } - - #[inline] - fn is_positive(&self) -> bool { *self > 0 } - - #[inline] - fn is_negative(&self) -> bool { *self < 0 } - } - )*) -} - -signed_impl!(isize i8 i16 i32 i64); - -macro_rules! signed_float_impl { - ($t:ty, $nan:expr, $inf:expr, $neg_inf:expr) => { - impl Signed for $t { - /// Computes the absolute value. Returns `NAN` if the number is `NAN`. - #[inline] - fn abs(&self) -> $t { - <$t>::abs(*self) - } - - /// The positive difference of two numbers. Returns `0.0` if the number is - /// less than or equal to `other`, otherwise the difference between`self` - /// and `other` is returned. - #[inline] - fn abs_sub(&self, other: &$t) -> $t { - <$t>::abs_sub(*self, *other) - } - - /// # Returns - /// - /// - `1.0` if the number is positive, `+0.0` or `INFINITY` - /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` - /// - `NAN` if the number is NaN - #[inline] - fn signum(&self) -> $t { - <$t>::signum(*self) - } - - /// Returns `true` if the number is positive, including `+0.0` and `INFINITY` - #[inline] - fn is_positive(&self) -> bool { *self > 0.0 || (1.0 / *self) == $inf } - - /// Returns `true` if the number is negative, including `-0.0` and `NEG_INFINITY` - #[inline] - fn is_negative(&self) -> bool { *self < 0.0 || (1.0 / *self) == $neg_inf } - } - } -} - -signed_float_impl!(f32, f32::NAN, f32::INFINITY, f32::NEG_INFINITY); -signed_float_impl!(f64, f64::NAN, f64::INFINITY, f64::NEG_INFINITY); - -/// A trait for values which cannot be negative -pub trait Unsigned: Num {} - -macro_rules! empty_trait_impl { - ($name:ident for $($t:ty)*) => ($( - impl $name for $t {} - )*) -} - -empty_trait_impl!(Unsigned for usize u8 u16 u32 u64); - -/// Numbers which have upper and lower bounds -pub trait Bounded { - // FIXME (#5527): These should be associated constants - /// returns the smallest finite number this type can represent - fn min_value() -> Self; - /// returns the largest finite number this type can represent - fn max_value() -> Self; -} - -macro_rules! bounded_impl { - ($t:ty, $min:expr, $max:expr) => { - impl Bounded for $t { - #[inline] - fn min_value() -> $t { $min } - - #[inline] - fn max_value() -> $t { $max } - } - } -} - -bounded_impl!(usize, usize::MIN, usize::MAX); -bounded_impl!(u8, u8::MIN, u8::MAX); -bounded_impl!(u16, u16::MIN, u16::MAX); -bounded_impl!(u32, u32::MIN, u32::MAX); -bounded_impl!(u64, u64::MIN, u64::MAX); - -bounded_impl!(isize, isize::MIN, isize::MAX); -bounded_impl!(i8, i8::MIN, i8::MAX); -bounded_impl!(i16, i16::MIN, i16::MAX); -bounded_impl!(i32, i32::MIN, i32::MAX); -bounded_impl!(i64, i64::MIN, i64::MAX); - -bounded_impl!(f32, f32::MIN, f32::MAX); -bounded_impl!(f64, f64::MIN, f64::MAX); - -macro_rules! for_each_tuple_ { - ( $m:ident !! ) => ( - $m! { } - ); - ( $m:ident !! $h:ident, $($t:ident,)* ) => ( - $m! { $h $($t)* } - for_each_tuple_! { $m !! $($t,)* } - ); -} -macro_rules! for_each_tuple { - ( $m:ident ) => ( - for_each_tuple_! { $m !! A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, } - ); -} - -macro_rules! bounded_tuple { - ( $($name:ident)* ) => ( - impl<$($name: Bounded,)*> Bounded for ($($name,)*) { - fn min_value() -> Self { - ($($name::min_value(),)*) - } - fn max_value() -> Self { - ($($name::max_value(),)*) - } - } - ); -} - -for_each_tuple!(bounded_tuple); - -/// Saturating math operations -pub trait Saturating { - /// Saturating addition operator. - /// Returns a+b, saturating at the numeric bounds instead of overflowing. - fn saturating_add(self, v: Self) -> Self; - - /// Saturating subtraction operator. - /// Returns a-b, saturating at the numeric bounds instead of overflowing. - fn saturating_sub(self, v: Self) -> Self; -} - -impl Saturating for T { - #[inline] - fn saturating_add(self, v: T) -> T { - match self.checked_add(&v) { - Some(x) => x, - None => if v >= Zero::zero() { - Bounded::max_value() - } else { - Bounded::min_value() - } - } - } - - #[inline] - fn saturating_sub(self, v: T) -> T { - match self.checked_sub(&v) { - Some(x) => x, - None => if v >= Zero::zero() { - Bounded::min_value() - } else { - Bounded::max_value() - } - } - } -} - -/// Performs addition that returns `None` instead of wrapping around on -/// overflow. -pub trait CheckedAdd: Sized + Add { - /// Adds two numbers, checking for overflow. If overflow happens, `None` is - /// returned. - fn checked_add(&self, v: &Self) -> Option; -} - -macro_rules! checked_impl { - ($trait_name:ident, $method:ident, $t:ty) => { - impl $trait_name for $t { - #[inline] - fn $method(&self, v: &$t) -> Option<$t> { - <$t>::$method(*self, *v) - } - } - } -} - -checked_impl!(CheckedAdd, checked_add, u8); -checked_impl!(CheckedAdd, checked_add, u16); -checked_impl!(CheckedAdd, checked_add, u32); -checked_impl!(CheckedAdd, checked_add, u64); -checked_impl!(CheckedAdd, checked_add, usize); - -checked_impl!(CheckedAdd, checked_add, i8); -checked_impl!(CheckedAdd, checked_add, i16); -checked_impl!(CheckedAdd, checked_add, i32); -checked_impl!(CheckedAdd, checked_add, i64); -checked_impl!(CheckedAdd, checked_add, isize); - -/// Performs subtraction that returns `None` instead of wrapping around on underflow. -pub trait CheckedSub: Sized + Sub { - /// Subtracts two numbers, checking for underflow. If underflow happens, - /// `None` is returned. - fn checked_sub(&self, v: &Self) -> Option; -} - -checked_impl!(CheckedSub, checked_sub, u8); -checked_impl!(CheckedSub, checked_sub, u16); -checked_impl!(CheckedSub, checked_sub, u32); -checked_impl!(CheckedSub, checked_sub, u64); -checked_impl!(CheckedSub, checked_sub, usize); - -checked_impl!(CheckedSub, checked_sub, i8); -checked_impl!(CheckedSub, checked_sub, i16); -checked_impl!(CheckedSub, checked_sub, i32); -checked_impl!(CheckedSub, checked_sub, i64); -checked_impl!(CheckedSub, checked_sub, isize); - -/// Performs multiplication that returns `None` instead of wrapping around on underflow or -/// overflow. -pub trait CheckedMul: Sized + Mul { - /// Multiplies two numbers, checking for underflow or overflow. If underflow - /// or overflow happens, `None` is returned. - fn checked_mul(&self, v: &Self) -> Option; -} - -checked_impl!(CheckedMul, checked_mul, u8); -checked_impl!(CheckedMul, checked_mul, u16); -checked_impl!(CheckedMul, checked_mul, u32); -checked_impl!(CheckedMul, checked_mul, u64); -checked_impl!(CheckedMul, checked_mul, usize); - -checked_impl!(CheckedMul, checked_mul, i8); -checked_impl!(CheckedMul, checked_mul, i16); -checked_impl!(CheckedMul, checked_mul, i32); -checked_impl!(CheckedMul, checked_mul, i64); -checked_impl!(CheckedMul, checked_mul, isize); - -/// Performs division that returns `None` instead of panicking on division by zero and instead of -/// wrapping around on underflow and overflow. -pub trait CheckedDiv: Sized + Div { - /// Divides two numbers, checking for underflow, overflow and division by - /// zero. If any of that happens, `None` is returned. - fn checked_div(&self, v: &Self) -> Option; -} - -macro_rules! checkeddiv_int_impl { - ($t:ty, $min:expr) => { - impl CheckedDiv for $t { - #[inline] - fn checked_div(&self, v: &$t) -> Option<$t> { - if *v == 0 || (*self == $min && *v == -1) { - None - } else { - Some(*self / *v) - } - } - } - } -} - -checkeddiv_int_impl!(isize, isize::MIN); -checkeddiv_int_impl!(i8, i8::MIN); -checkeddiv_int_impl!(i16, i16::MIN); -checkeddiv_int_impl!(i32, i32::MIN); -checkeddiv_int_impl!(i64, i64::MIN); - -macro_rules! checkeddiv_uint_impl { - ($($t:ty)*) => ($( - impl CheckedDiv for $t { - #[inline] - fn checked_div(&self, v: &$t) -> Option<$t> { - if *v == 0 { - None - } else { - Some(*self / *v) - } - } - } - )*) -} - -checkeddiv_uint_impl!(usize u8 u16 u32 u64); - -pub trait PrimInt - : Sized - + Copy - + Num + NumCast - + Bounded - + PartialOrd + Ord + Eq - + Not - + BitAnd - + BitOr - + BitXor - + Shl - + Shr - + CheckedAdd - + CheckedSub - + CheckedMul - + CheckedDiv - + Saturating -{ - /// Returns the number of ones in the binary representation of `self`. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0b01001100u8; - /// - /// assert_eq!(n.count_ones(), 3); - /// ``` - fn count_ones(self) -> u32; - - /// Returns the number of zeros in the binary representation of `self`. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0b01001100u8; - /// - /// assert_eq!(n.count_zeros(), 5); - /// ``` - fn count_zeros(self) -> u32; - - /// Returns the number of leading zeros in the binary representation - /// of `self`. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0b0101000u16; - /// - /// assert_eq!(n.leading_zeros(), 10); - /// ``` - fn leading_zeros(self) -> u32; - - /// Returns the number of trailing zeros in the binary representation - /// of `self`. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0b0101000u16; - /// - /// assert_eq!(n.trailing_zeros(), 3); - /// ``` - fn trailing_zeros(self) -> u32; - - /// Shifts the bits to the left by a specified amount amount, `n`, wrapping - /// the truncated bits to the end of the resulting integer. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0x3456789ABCDEF012u64; - /// - /// assert_eq!(n.rotate_left(12), m); - /// ``` - fn rotate_left(self, n: u32) -> Self; - - /// Shifts the bits to the right by a specified amount amount, `n`, wrapping - /// the truncated bits to the beginning of the resulting integer. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0xDEF0123456789ABCu64; - /// - /// assert_eq!(n.rotate_right(12), m); - /// ``` - fn rotate_right(self, n: u32) -> Self; - - /// Shifts the bits to the left by a specified amount amount, `n`, filling - /// zeros in the least significant bits. - /// - /// This is bitwise equivalent to signed `Shl`. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0x3456789ABCDEF000u64; - /// - /// assert_eq!(n.signed_shl(12), m); - /// ``` - fn signed_shl(self, n: u32) -> Self; - - /// Shifts the bits to the right by a specified amount amount, `n`, copying - /// the "sign bit" in the most significant bits even for unsigned types. - /// - /// This is bitwise equivalent to signed `Shr`. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0xFEDCBA9876543210u64; - /// let m = 0xFFFFEDCBA9876543u64; - /// - /// assert_eq!(n.signed_shr(12), m); - /// ``` - fn signed_shr(self, n: u32) -> Self; - - /// Shifts the bits to the left by a specified amount amount, `n`, filling - /// zeros in the least significant bits. - /// - /// This is bitwise equivalent to unsigned `Shl`. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0x0123456789ABCDEFi64; - /// let m = 0x3456789ABCDEF000i64; - /// - /// assert_eq!(n.unsigned_shl(12), m); - /// ``` - fn unsigned_shl(self, n: u32) -> Self; - - /// Shifts the bits to the right by a specified amount amount, `n`, filling - /// zeros in the most significant bits. - /// - /// This is bitwise equivalent to unsigned `Shr`. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0xFEDCBA9876543210i64; - /// let m = 0x000FEDCBA9876543i64; - /// - /// assert_eq!(n.unsigned_shr(12), m); - /// ``` - fn unsigned_shr(self, n: u32) -> Self; - - /// Reverses the byte order of the integer. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0xEFCDAB8967452301u64; - /// - /// assert_eq!(n.swap_bytes(), m); - /// ``` - fn swap_bytes(self) -> Self; - - /// Convert an integer from big endian to the target's endianness. - /// - /// On big endian this is a no-op. On little endian the bytes are swapped. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "big") { - /// assert_eq!(u64::from_be(n), n) - /// } else { - /// assert_eq!(u64::from_be(n), n.swap_bytes()) - /// } - /// ``` - fn from_be(x: Self) -> Self; - - /// Convert an integer from little endian to the target's endianness. - /// - /// On little endian this is a no-op. On big endian the bytes are swapped. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "little") { - /// assert_eq!(u64::from_le(n), n) - /// } else { - /// assert_eq!(u64::from_le(n), n.swap_bytes()) - /// } - /// ``` - fn from_le(x: Self) -> Self; - - /// Convert `self` to big endian from the target's endianness. - /// - /// On big endian this is a no-op. On little endian the bytes are swapped. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "big") { - /// assert_eq!(n.to_be(), n) - /// } else { - /// assert_eq!(n.to_be(), n.swap_bytes()) - /// } - /// ``` - fn to_be(self) -> Self; - - /// Convert `self` to little endian from the target's endianness. - /// - /// On little endian this is a no-op. On big endian the bytes are swapped. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "little") { - /// assert_eq!(n.to_le(), n) - /// } else { - /// assert_eq!(n.to_le(), n.swap_bytes()) - /// } - /// ``` - fn to_le(self) -> Self; - - /// Raises self to the power of `exp`, using exponentiation by squaring. - /// - /// # Examples - /// - /// ``` - /// use num::traits::PrimInt; - /// - /// assert_eq!(2i32.pow(4), 16); - /// ``` - fn pow(self, mut exp: u32) -> Self; -} - -macro_rules! prim_int_impl { - ($T:ty, $S:ty, $U:ty) => ( - impl PrimInt for $T { - fn count_ones(self) -> u32 { - <$T>::count_ones(self) - } - - fn count_zeros(self) -> u32 { - <$T>::count_zeros(self) - } - - fn leading_zeros(self) -> u32 { - <$T>::leading_zeros(self) - } - - fn trailing_zeros(self) -> u32 { - <$T>::trailing_zeros(self) - } - - fn rotate_left(self, n: u32) -> Self { - <$T>::rotate_left(self, n) - } - - fn rotate_right(self, n: u32) -> Self { - <$T>::rotate_right(self, n) - } - - fn signed_shl(self, n: u32) -> Self { - ((self as $S) << n) as $T - } - - fn signed_shr(self, n: u32) -> Self { - ((self as $S) >> n) as $T - } - - fn unsigned_shl(self, n: u32) -> Self { - ((self as $U) << n) as $T - } - - fn unsigned_shr(self, n: u32) -> Self { - ((self as $U) >> n) as $T - } - - fn swap_bytes(self) -> Self { - <$T>::swap_bytes(self) - } - - fn from_be(x: Self) -> Self { - <$T>::from_be(x) - } - - fn from_le(x: Self) -> Self { - <$T>::from_le(x) - } - - fn to_be(self) -> Self { - <$T>::to_be(self) - } - - fn to_le(self) -> Self { - <$T>::to_le(self) - } - - fn pow(self, exp: u32) -> Self { - <$T>::pow(self, exp) - } - } - ) -} - -// prim_int_impl!(type, signed, unsigned); -prim_int_impl!(u8, i8, u8); -prim_int_impl!(u16, i16, u16); -prim_int_impl!(u32, i32, u32); -prim_int_impl!(u64, i64, u64); -prim_int_impl!(usize, isize, usize); -prim_int_impl!(i8, i8, u8); -prim_int_impl!(i16, i16, u16); -prim_int_impl!(i32, i32, u32); -prim_int_impl!(i64, i64, u64); -prim_int_impl!(isize, isize, usize); - -/// A generic trait for converting a value to a number. -pub trait ToPrimitive { - /// Converts the value of `self` to an `isize`. - #[inline] - fn to_isize(&self) -> Option { - self.to_i64().and_then(|x| x.to_isize()) - } - - /// Converts the value of `self` to an `i8`. - #[inline] - fn to_i8(&self) -> Option { - self.to_i64().and_then(|x| x.to_i8()) - } - - /// Converts the value of `self` to an `i16`. - #[inline] - fn to_i16(&self) -> Option { - self.to_i64().and_then(|x| x.to_i16()) - } - - /// Converts the value of `self` to an `i32`. - #[inline] - fn to_i32(&self) -> Option { - self.to_i64().and_then(|x| x.to_i32()) - } - - /// Converts the value of `self` to an `i64`. - fn to_i64(&self) -> Option; - - /// Converts the value of `self` to a `usize`. - #[inline] - fn to_usize(&self) -> Option { - self.to_u64().and_then(|x| x.to_usize()) - } - - /// Converts the value of `self` to an `u8`. - #[inline] - fn to_u8(&self) -> Option { - self.to_u64().and_then(|x| x.to_u8()) - } - - /// Converts the value of `self` to an `u16`. - #[inline] - fn to_u16(&self) -> Option { - self.to_u64().and_then(|x| x.to_u16()) - } - - /// Converts the value of `self` to an `u32`. - #[inline] - fn to_u32(&self) -> Option { - self.to_u64().and_then(|x| x.to_u32()) - } - - /// Converts the value of `self` to an `u64`. - #[inline] - fn to_u64(&self) -> Option; - - /// Converts the value of `self` to an `f32`. - #[inline] - fn to_f32(&self) -> Option { - self.to_f64().and_then(|x| x.to_f32()) - } - - /// Converts the value of `self` to an `f64`. - #[inline] - fn to_f64(&self) -> Option { - self.to_i64().and_then(|x| x.to_f64()) - } -} - -macro_rules! impl_to_primitive_int_to_int { - ($SrcT:ty, $DstT:ty, $slf:expr) => ( - { - if size_of::<$SrcT>() <= size_of::<$DstT>() { - Some($slf as $DstT) - } else { - let n = $slf as i64; - let min_value: $DstT = Bounded::min_value(); - let max_value: $DstT = Bounded::max_value(); - if min_value as i64 <= n && n <= max_value as i64 { - Some($slf as $DstT) - } else { - None - } - } - } - ) -} - -macro_rules! impl_to_primitive_int_to_uint { - ($SrcT:ty, $DstT:ty, $slf:expr) => ( - { - let zero: $SrcT = Zero::zero(); - let max_value: $DstT = Bounded::max_value(); - if zero <= $slf && $slf as u64 <= max_value as u64 { - Some($slf as $DstT) - } else { - None - } - } - ) -} - -macro_rules! impl_to_primitive_int { - ($T:ty) => ( - impl ToPrimitive for $T { - #[inline] - fn to_isize(&self) -> Option { impl_to_primitive_int_to_int!($T, isize, *self) } - #[inline] - fn to_i8(&self) -> Option { impl_to_primitive_int_to_int!($T, i8, *self) } - #[inline] - fn to_i16(&self) -> Option { impl_to_primitive_int_to_int!($T, i16, *self) } - #[inline] - fn to_i32(&self) -> Option { impl_to_primitive_int_to_int!($T, i32, *self) } - #[inline] - fn to_i64(&self) -> Option { impl_to_primitive_int_to_int!($T, i64, *self) } - - #[inline] - fn to_usize(&self) -> Option { impl_to_primitive_int_to_uint!($T, usize, *self) } - #[inline] - fn to_u8(&self) -> Option { impl_to_primitive_int_to_uint!($T, u8, *self) } - #[inline] - fn to_u16(&self) -> Option { impl_to_primitive_int_to_uint!($T, u16, *self) } - #[inline] - fn to_u32(&self) -> Option { impl_to_primitive_int_to_uint!($T, u32, *self) } - #[inline] - fn to_u64(&self) -> Option { impl_to_primitive_int_to_uint!($T, u64, *self) } - - #[inline] - fn to_f32(&self) -> Option { Some(*self as f32) } - #[inline] - fn to_f64(&self) -> Option { Some(*self as f64) } - } - ) -} - -impl_to_primitive_int! { isize } -impl_to_primitive_int! { i8 } -impl_to_primitive_int! { i16 } -impl_to_primitive_int! { i32 } -impl_to_primitive_int! { i64 } - -macro_rules! impl_to_primitive_uint_to_int { - ($DstT:ty, $slf:expr) => ( - { - let max_value: $DstT = Bounded::max_value(); - if $slf as u64 <= max_value as u64 { - Some($slf as $DstT) - } else { - None - } - } - ) -} - -macro_rules! impl_to_primitive_uint_to_uint { - ($SrcT:ty, $DstT:ty, $slf:expr) => ( - { - if size_of::<$SrcT>() <= size_of::<$DstT>() { - Some($slf as $DstT) - } else { - let zero: $SrcT = Zero::zero(); - let max_value: $DstT = Bounded::max_value(); - if zero <= $slf && $slf as u64 <= max_value as u64 { - Some($slf as $DstT) - } else { - None - } - } - } - ) -} - -macro_rules! impl_to_primitive_uint { - ($T:ty) => ( - impl ToPrimitive for $T { - #[inline] - fn to_isize(&self) -> Option { impl_to_primitive_uint_to_int!(isize, *self) } - #[inline] - fn to_i8(&self) -> Option { impl_to_primitive_uint_to_int!(i8, *self) } - #[inline] - fn to_i16(&self) -> Option { impl_to_primitive_uint_to_int!(i16, *self) } - #[inline] - fn to_i32(&self) -> Option { impl_to_primitive_uint_to_int!(i32, *self) } - #[inline] - fn to_i64(&self) -> Option { impl_to_primitive_uint_to_int!(i64, *self) } - - #[inline] - fn to_usize(&self) -> Option { - impl_to_primitive_uint_to_uint!($T, usize, *self) - } - #[inline] - fn to_u8(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u8, *self) } - #[inline] - fn to_u16(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u16, *self) } - #[inline] - fn to_u32(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u32, *self) } - #[inline] - fn to_u64(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u64, *self) } - - #[inline] - fn to_f32(&self) -> Option { Some(*self as f32) } - #[inline] - fn to_f64(&self) -> Option { Some(*self as f64) } - } - ) -} - -impl_to_primitive_uint! { usize } -impl_to_primitive_uint! { u8 } -impl_to_primitive_uint! { u16 } -impl_to_primitive_uint! { u32 } -impl_to_primitive_uint! { u64 } - -macro_rules! impl_to_primitive_float_to_float { - ($SrcT:ident, $DstT:ident, $slf:expr) => ( - if size_of::<$SrcT>() <= size_of::<$DstT>() { - Some($slf as $DstT) - } else { - let n = $slf as f64; - let max_value: $SrcT = ::std::$SrcT::MAX; - if -max_value as f64 <= n && n <= max_value as f64 { - Some($slf as $DstT) - } else { - None - } - } - ) -} - -macro_rules! impl_to_primitive_float { - ($T:ident) => ( - impl ToPrimitive for $T { - #[inline] - fn to_isize(&self) -> Option { Some(*self as isize) } - #[inline] - fn to_i8(&self) -> Option { Some(*self as i8) } - #[inline] - fn to_i16(&self) -> Option { Some(*self as i16) } - #[inline] - fn to_i32(&self) -> Option { Some(*self as i32) } - #[inline] - fn to_i64(&self) -> Option { Some(*self as i64) } - - #[inline] - fn to_usize(&self) -> Option { Some(*self as usize) } - #[inline] - fn to_u8(&self) -> Option { Some(*self as u8) } - #[inline] - fn to_u16(&self) -> Option { Some(*self as u16) } - #[inline] - fn to_u32(&self) -> Option { Some(*self as u32) } - #[inline] - fn to_u64(&self) -> Option { Some(*self as u64) } - - #[inline] - fn to_f32(&self) -> Option { impl_to_primitive_float_to_float!($T, f32, *self) } - #[inline] - fn to_f64(&self) -> Option { impl_to_primitive_float_to_float!($T, f64, *self) } - } - ) -} - -impl_to_primitive_float! { f32 } -impl_to_primitive_float! { f64 } - -/// A generic trait for converting a number to a value. -pub trait FromPrimitive: Sized { - /// Convert an `isize` to return an optional value of this type. If the - /// value cannot be represented by this value, the `None` is returned. - #[inline] - fn from_isize(n: isize) -> Option { - FromPrimitive::from_i64(n as i64) - } - - /// Convert an `i8` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - #[inline] - fn from_i8(n: i8) -> Option { - FromPrimitive::from_i64(n as i64) - } - - /// Convert an `i16` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - #[inline] - fn from_i16(n: i16) -> Option { - FromPrimitive::from_i64(n as i64) - } - - /// Convert an `i32` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - #[inline] - fn from_i32(n: i32) -> Option { - FromPrimitive::from_i64(n as i64) - } - - /// Convert an `i64` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - fn from_i64(n: i64) -> Option; - - /// Convert a `usize` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - #[inline] - fn from_usize(n: usize) -> Option { - FromPrimitive::from_u64(n as u64) - } - - /// Convert an `u8` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - #[inline] - fn from_u8(n: u8) -> Option { - FromPrimitive::from_u64(n as u64) - } - - /// Convert an `u16` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - #[inline] - fn from_u16(n: u16) -> Option { - FromPrimitive::from_u64(n as u64) - } - - /// Convert an `u32` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - #[inline] - fn from_u32(n: u32) -> Option { - FromPrimitive::from_u64(n as u64) - } - - /// Convert an `u64` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - fn from_u64(n: u64) -> Option; - - /// Convert a `f32` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - #[inline] - fn from_f32(n: f32) -> Option { - FromPrimitive::from_f64(n as f64) - } - - /// Convert a `f64` to return an optional value of this type. If the - /// type cannot be represented by this value, the `None` is returned. - #[inline] - fn from_f64(n: f64) -> Option { - FromPrimitive::from_i64(n as i64) - } -} - -macro_rules! impl_from_primitive { - ($T:ty, $to_ty:ident) => ( - #[allow(deprecated)] - impl FromPrimitive for $T { - #[inline] fn from_i8(n: i8) -> Option<$T> { n.$to_ty() } - #[inline] fn from_i16(n: i16) -> Option<$T> { n.$to_ty() } - #[inline] fn from_i32(n: i32) -> Option<$T> { n.$to_ty() } - #[inline] fn from_i64(n: i64) -> Option<$T> { n.$to_ty() } - - #[inline] fn from_u8(n: u8) -> Option<$T> { n.$to_ty() } - #[inline] fn from_u16(n: u16) -> Option<$T> { n.$to_ty() } - #[inline] fn from_u32(n: u32) -> Option<$T> { n.$to_ty() } - #[inline] fn from_u64(n: u64) -> Option<$T> { n.$to_ty() } - - #[inline] fn from_f32(n: f32) -> Option<$T> { n.$to_ty() } - #[inline] fn from_f64(n: f64) -> Option<$T> { n.$to_ty() } - } - ) -} - -impl_from_primitive! { isize, to_isize } -impl_from_primitive! { i8, to_i8 } -impl_from_primitive! { i16, to_i16 } -impl_from_primitive! { i32, to_i32 } -impl_from_primitive! { i64, to_i64 } -impl_from_primitive! { usize, to_usize } -impl_from_primitive! { u8, to_u8 } -impl_from_primitive! { u16, to_u16 } -impl_from_primitive! { u32, to_u32 } -impl_from_primitive! { u64, to_u64 } -impl_from_primitive! { f32, to_f32 } -impl_from_primitive! { f64, to_f64 } - -/// Cast from one machine scalar to another. -/// -/// # Examples -/// -/// ``` -/// use num; -/// -/// let twenty: f32 = num::cast(0x14).unwrap(); -/// assert_eq!(twenty, 20f32); -/// ``` -/// -#[inline] -pub fn cast(n: T) -> Option { - NumCast::from(n) -} - -/// An interface for casting between machine scalars. -pub trait NumCast: Sized + ToPrimitive { - /// Creates a number from another value that can be converted into - /// a primitive via the `ToPrimitive` trait. - fn from(n: T) -> Option; -} - -macro_rules! impl_num_cast { - ($T:ty, $conv:ident) => ( - impl NumCast for $T { - #[inline] - #[allow(deprecated)] - fn from(n: N) -> Option<$T> { - // `$conv` could be generated using `concat_idents!`, but that - // macro seems to be broken at the moment - n.$conv() - } - } - ) -} - -impl_num_cast! { u8, to_u8 } -impl_num_cast! { u16, to_u16 } -impl_num_cast! { u32, to_u32 } -impl_num_cast! { u64, to_u64 } -impl_num_cast! { usize, to_usize } -impl_num_cast! { i8, to_i8 } -impl_num_cast! { i16, to_i16 } -impl_num_cast! { i32, to_i32 } -impl_num_cast! { i64, to_i64 } -impl_num_cast! { isize, to_isize } -impl_num_cast! { f32, to_f32 } -impl_num_cast! { f64, to_f64 } - -pub trait Float - : Num - + Copy - + NumCast - + PartialOrd - + Neg -{ - /// Returns the `NaN` value. - /// - /// ``` - /// use num::traits::Float; - /// - /// let nan: f32 = Float::nan(); - /// - /// assert!(nan.is_nan()); - /// ``` - fn nan() -> Self; - /// Returns the infinite value. - /// - /// ``` - /// use num::traits::Float; - /// use std::f32; - /// - /// let infinity: f32 = Float::infinity(); - /// - /// assert!(infinity.is_infinite()); - /// assert!(!infinity.is_finite()); - /// assert!(infinity > f32::MAX); - /// ``` - fn infinity() -> Self; - /// Returns the negative infinite value. - /// - /// ``` - /// use num::traits::Float; - /// use std::f32; - /// - /// let neg_infinity: f32 = Float::neg_infinity(); - /// - /// assert!(neg_infinity.is_infinite()); - /// assert!(!neg_infinity.is_finite()); - /// assert!(neg_infinity < f32::MIN); - /// ``` - fn neg_infinity() -> Self; - /// Returns `-0.0`. - /// - /// ``` - /// use num::traits::{Zero, Float}; - /// - /// let inf: f32 = Float::infinity(); - /// let zero: f32 = Zero::zero(); - /// let neg_zero: f32 = Float::neg_zero(); - /// - /// assert_eq!(zero, neg_zero); - /// assert_eq!(7.0f32/inf, zero); - /// assert_eq!(zero * 10.0, zero); - /// ``` - fn neg_zero() -> Self; - - /// Returns the smallest finite value that this type can represent. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let x: f64 = Float::min_value(); - /// - /// assert_eq!(x, f64::MIN); - /// ``` - fn min_value() -> Self; - - /// Returns the smallest positive, normalized value that this type can represent. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let x: f64 = Float::min_positive_value(); - /// - /// assert_eq!(x, f64::MIN_POSITIVE); - /// ``` - fn min_positive_value() -> Self; - - /// Returns the largest finite value that this type can represent. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let x: f64 = Float::max_value(); - /// assert_eq!(x, f64::MAX); - /// ``` - fn max_value() -> Self; - - /// Returns `true` if this value is `NaN` and false otherwise. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let nan = f64::NAN; - /// let f = 7.0; - /// - /// assert!(nan.is_nan()); - /// assert!(!f.is_nan()); - /// ``` - fn is_nan(self) -> bool; - - /// Returns `true` if this value is positive infinity or negative infinity and - /// false otherwise. - /// - /// ``` - /// use num::traits::Float; - /// use std::f32; - /// - /// let f = 7.0f32; - /// let inf: f32 = Float::infinity(); - /// let neg_inf: f32 = Float::neg_infinity(); - /// let nan: f32 = f32::NAN; - /// - /// assert!(!f.is_infinite()); - /// assert!(!nan.is_infinite()); - /// - /// assert!(inf.is_infinite()); - /// assert!(neg_inf.is_infinite()); - /// ``` - fn is_infinite(self) -> bool; - - /// Returns `true` if this number is neither infinite nor `NaN`. - /// - /// ``` - /// use num::traits::Float; - /// use std::f32; - /// - /// let f = 7.0f32; - /// let inf: f32 = Float::infinity(); - /// let neg_inf: f32 = Float::neg_infinity(); - /// let nan: f32 = f32::NAN; - /// - /// assert!(f.is_finite()); - /// - /// assert!(!nan.is_finite()); - /// assert!(!inf.is_finite()); - /// assert!(!neg_inf.is_finite()); - /// ``` - fn is_finite(self) -> bool; - - /// Returns `true` if the number is neither zero, infinite, - /// [subnormal][subnormal], or `NaN`. - /// - /// ``` - /// use num::traits::Float; - /// use std::f32; - /// - /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32 - /// let max = f32::MAX; - /// let lower_than_min = 1.0e-40_f32; - /// let zero = 0.0f32; - /// - /// assert!(min.is_normal()); - /// assert!(max.is_normal()); - /// - /// assert!(!zero.is_normal()); - /// assert!(!f32::NAN.is_normal()); - /// assert!(!f32::INFINITY.is_normal()); - /// // Values between `0` and `min` are Subnormal. - /// assert!(!lower_than_min.is_normal()); - /// ``` - /// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number - fn is_normal(self) -> bool; - - /// Returns the floating point category of the number. If only one property - /// is going to be tested, it is generally faster to use the specific - /// predicate instead. - /// - /// ``` - /// use num::traits::Float; - /// use std::num::FpCategory; - /// use std::f32; - /// - /// let num = 12.4f32; - /// let inf = f32::INFINITY; - /// - /// assert_eq!(num.classify(), FpCategory::Normal); - /// assert_eq!(inf.classify(), FpCategory::Infinite); - /// ``` - fn classify(self) -> FpCategory; - - /// Returns the largest integer less than or equal to a number. - /// - /// ``` - /// use num::traits::Float; - /// - /// let f = 3.99; - /// let g = 3.0; - /// - /// assert_eq!(f.floor(), 3.0); - /// assert_eq!(g.floor(), 3.0); - /// ``` - fn floor(self) -> Self; - - /// Returns the smallest integer greater than or equal to a number. - /// - /// ``` - /// use num::traits::Float; - /// - /// let f = 3.01; - /// let g = 4.0; - /// - /// assert_eq!(f.ceil(), 4.0); - /// assert_eq!(g.ceil(), 4.0); - /// ``` - fn ceil(self) -> Self; - - /// Returns the nearest integer to a number. Round half-way cases away from - /// `0.0`. - /// - /// ``` - /// use num::traits::Float; - /// - /// let f = 3.3; - /// let g = -3.3; - /// - /// assert_eq!(f.round(), 3.0); - /// assert_eq!(g.round(), -3.0); - /// ``` - fn round(self) -> Self; - - /// Return the integer part of a number. - /// - /// ``` - /// use num::traits::Float; - /// - /// let f = 3.3; - /// let g = -3.7; - /// - /// assert_eq!(f.trunc(), 3.0); - /// assert_eq!(g.trunc(), -3.0); - /// ``` - fn trunc(self) -> Self; - - /// Returns the fractional part of a number. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 3.5; - /// let y = -3.5; - /// let abs_difference_x = (x.fract() - 0.5).abs(); - /// let abs_difference_y = (y.fract() - (-0.5)).abs(); - /// - /// assert!(abs_difference_x < 1e-10); - /// assert!(abs_difference_y < 1e-10); - /// ``` - fn fract(self) -> Self; - - /// Computes the absolute value of `self`. Returns `Float::nan()` if the - /// number is `Float::nan()`. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let x = 3.5; - /// let y = -3.5; - /// - /// let abs_difference_x = (x.abs() - x).abs(); - /// let abs_difference_y = (y.abs() - (-y)).abs(); - /// - /// assert!(abs_difference_x < 1e-10); - /// assert!(abs_difference_y < 1e-10); - /// - /// assert!(f64::NAN.abs().is_nan()); - /// ``` - fn abs(self) -> Self; - - /// Returns a number that represents the sign of `self`. - /// - /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()` - /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()` - /// - `Float::nan()` if the number is `Float::nan()` - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let f = 3.5; - /// - /// assert_eq!(f.signum(), 1.0); - /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0); - /// - /// assert!(f64::NAN.signum().is_nan()); - /// ``` - fn signum(self) -> Self; - - /// Returns `true` if `self` is positive, including `+0.0` and - /// `Float::infinity()`. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let nan: f64 = f64::NAN; - /// - /// let f = 7.0; - /// let g = -7.0; - /// - /// assert!(f.is_sign_positive()); - /// assert!(!g.is_sign_positive()); - /// // Requires both tests to determine if is `NaN` - /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative()); - /// ``` - fn is_sign_positive(self) -> bool; - - /// Returns `true` if `self` is negative, including `-0.0` and - /// `Float::neg_infinity()`. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let nan = f64::NAN; - /// - /// let f = 7.0; - /// let g = -7.0; - /// - /// assert!(!f.is_sign_negative()); - /// assert!(g.is_sign_negative()); - /// // Requires both tests to determine if is `NaN`. - /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative()); - /// ``` - fn is_sign_negative(self) -> bool; - - /// Fused multiply-add. Computes `(self * a) + b` with only one rounding - /// error. This produces a more accurate result with better performance than - /// a separate multiplication operation followed by an add. - /// - /// ``` - /// use num::traits::Float; - /// - /// let m = 10.0; - /// let x = 4.0; - /// let b = 60.0; - /// - /// // 100.0 - /// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn mul_add(self, a: Self, b: Self) -> Self; - /// Take the reciprocal (inverse) of a number, `1/x`. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 2.0; - /// let abs_difference = (x.recip() - (1.0/x)).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn recip(self) -> Self; - - /// Raise a number to an integer power. - /// - /// Using this function is generally faster than using `powf` - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 2.0; - /// let abs_difference = (x.powi(2) - x*x).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn powi(self, n: i32) -> Self; - - /// Raise a number to a floating point power. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 2.0; - /// let abs_difference = (x.powf(2.0) - x*x).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn powf(self, n: Self) -> Self; - - /// Take the square root of a number. - /// - /// Returns NaN if `self` is a negative number. - /// - /// ``` - /// use num::traits::Float; - /// - /// let positive = 4.0; - /// let negative = -4.0; - /// - /// let abs_difference = (positive.sqrt() - 2.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// assert!(negative.sqrt().is_nan()); - /// ``` - fn sqrt(self) -> Self; - - /// Returns `e^(self)`, (the exponential function). - /// - /// ``` - /// use num::traits::Float; - /// - /// let one = 1.0; - /// // e^1 - /// let e = one.exp(); - /// - /// // ln(e) - 1 == 0 - /// let abs_difference = (e.ln() - 1.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn exp(self) -> Self; - - /// Returns `2^(self)`. - /// - /// ``` - /// use num::traits::Float; - /// - /// let f = 2.0; - /// - /// // 2^2 - 4 == 0 - /// let abs_difference = (f.exp2() - 4.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn exp2(self) -> Self; - - /// Returns the natural logarithm of the number. - /// - /// ``` - /// use num::traits::Float; - /// - /// let one = 1.0; - /// // e^1 - /// let e = one.exp(); - /// - /// // ln(e) - 1 == 0 - /// let abs_difference = (e.ln() - 1.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn ln(self) -> Self; - - /// Returns the logarithm of the number with respect to an arbitrary base. - /// - /// ``` - /// use num::traits::Float; - /// - /// let ten = 10.0; - /// let two = 2.0; - /// - /// // log10(10) - 1 == 0 - /// let abs_difference_10 = (ten.log(10.0) - 1.0).abs(); - /// - /// // log2(2) - 1 == 0 - /// let abs_difference_2 = (two.log(2.0) - 1.0).abs(); - /// - /// assert!(abs_difference_10 < 1e-10); - /// assert!(abs_difference_2 < 1e-10); - /// ``` - fn log(self, base: Self) -> Self; - - /// Returns the base 2 logarithm of the number. - /// - /// ``` - /// use num::traits::Float; - /// - /// let two = 2.0; - /// - /// // log2(2) - 1 == 0 - /// let abs_difference = (two.log2() - 1.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn log2(self) -> Self; - - /// Returns the base 10 logarithm of the number. - /// - /// ``` - /// use num::traits::Float; - /// - /// let ten = 10.0; - /// - /// // log10(10) - 1 == 0 - /// let abs_difference = (ten.log10() - 1.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn log10(self) -> Self; - - /// Returns the maximum of the two numbers. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 1.0; - /// let y = 2.0; - /// - /// assert_eq!(x.max(y), y); - /// ``` - fn max(self, other: Self) -> Self; - - /// Returns the minimum of the two numbers. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 1.0; - /// let y = 2.0; - /// - /// assert_eq!(x.min(y), x); - /// ``` - fn min(self, other: Self) -> Self; - - /// The positive difference of two numbers. - /// - /// * If `self <= other`: `0:0` - /// * Else: `self - other` - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 3.0; - /// let y = -3.0; - /// - /// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs(); - /// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs(); - /// - /// assert!(abs_difference_x < 1e-10); - /// assert!(abs_difference_y < 1e-10); - /// ``` - fn abs_sub(self, other: Self) -> Self; - - /// Take the cubic root of a number. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 8.0; - /// - /// // x^(1/3) - 2 == 0 - /// let abs_difference = (x.cbrt() - 2.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn cbrt(self) -> Self; - - /// Calculate the length of the hypotenuse of a right-angle triangle given - /// legs of length `x` and `y`. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 2.0; - /// let y = 3.0; - /// - /// // sqrt(x^2 + y^2) - /// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn hypot(self, other: Self) -> Self; - - /// Computes the sine of a number (in radians). - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let x = f64::consts::PI/2.0; - /// - /// let abs_difference = (x.sin() - 1.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn sin(self) -> Self; - - /// Computes the cosine of a number (in radians). - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let x = 2.0*f64::consts::PI; - /// - /// let abs_difference = (x.cos() - 1.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn cos(self) -> Self; - - /// Computes the tangent of a number (in radians). - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let x = f64::consts::PI/4.0; - /// let abs_difference = (x.tan() - 1.0).abs(); - /// - /// assert!(abs_difference < 1e-14); - /// ``` - fn tan(self) -> Self; - - /// Computes the arcsine of a number. Return value is in radians in - /// the range [-pi/2, pi/2] or NaN if the number is outside the range - /// [-1, 1]. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let f = f64::consts::PI / 2.0; - /// - /// // asin(sin(pi/2)) - /// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn asin(self) -> Self; - - /// Computes the arccosine of a number. Return value is in radians in - /// the range [0, pi] or NaN if the number is outside the range - /// [-1, 1]. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let f = f64::consts::PI / 4.0; - /// - /// // acos(cos(pi/4)) - /// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn acos(self) -> Self; - - /// Computes the arctangent of a number. Return value is in radians in the - /// range [-pi/2, pi/2]; - /// - /// ``` - /// use num::traits::Float; - /// - /// let f = 1.0; - /// - /// // atan(tan(1)) - /// let abs_difference = (f.tan().atan() - 1.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn atan(self) -> Self; - - /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`). - /// - /// * `x = 0`, `y = 0`: `0` - /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]` - /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]` - /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)` - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let pi = f64::consts::PI; - /// // All angles from horizontal right (+x) - /// // 45 deg counter-clockwise - /// let x1 = 3.0; - /// let y1 = -3.0; - /// - /// // 135 deg clockwise - /// let x2 = -3.0; - /// let y2 = 3.0; - /// - /// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs(); - /// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs(); - /// - /// assert!(abs_difference_1 < 1e-10); - /// assert!(abs_difference_2 < 1e-10); - /// ``` - fn atan2(self, other: Self) -> Self; - - /// Simultaneously computes the sine and cosine of the number, `x`. Returns - /// `(sin(x), cos(x))`. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let x = f64::consts::PI/4.0; - /// let f = x.sin_cos(); - /// - /// let abs_difference_0 = (f.0 - x.sin()).abs(); - /// let abs_difference_1 = (f.1 - x.cos()).abs(); - /// - /// assert!(abs_difference_0 < 1e-10); - /// assert!(abs_difference_0 < 1e-10); - /// ``` - fn sin_cos(self) -> (Self, Self); - - /// Returns `e^(self) - 1` in a way that is accurate even if the - /// number is close to zero. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 7.0; - /// - /// // e^(ln(7)) - 1 - /// let abs_difference = (x.ln().exp_m1() - 6.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn exp_m1(self) -> Self; - - /// Returns `ln(1+n)` (natural logarithm) more accurately than if - /// the operations were performed separately. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let x = f64::consts::E - 1.0; - /// - /// // ln(1 + (e - 1)) == ln(e) == 1 - /// let abs_difference = (x.ln_1p() - 1.0).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn ln_1p(self) -> Self; - - /// Hyperbolic sine function. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let e = f64::consts::E; - /// let x = 1.0; - /// - /// let f = x.sinh(); - /// // Solving sinh() at 1 gives `(e^2-1)/(2e)` - /// let g = (e*e - 1.0)/(2.0*e); - /// let abs_difference = (f - g).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - fn sinh(self) -> Self; - - /// Hyperbolic cosine function. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let e = f64::consts::E; - /// let x = 1.0; - /// let f = x.cosh(); - /// // Solving cosh() at 1 gives this result - /// let g = (e*e + 1.0)/(2.0*e); - /// let abs_difference = (f - g).abs(); - /// - /// // Same result - /// assert!(abs_difference < 1.0e-10); - /// ``` - fn cosh(self) -> Self; - - /// Hyperbolic tangent function. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let e = f64::consts::E; - /// let x = 1.0; - /// - /// let f = x.tanh(); - /// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))` - /// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2)); - /// let abs_difference = (f - g).abs(); - /// - /// assert!(abs_difference < 1.0e-10); - /// ``` - fn tanh(self) -> Self; - - /// Inverse hyperbolic sine function. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 1.0; - /// let f = x.sinh().asinh(); - /// - /// let abs_difference = (f - x).abs(); - /// - /// assert!(abs_difference < 1.0e-10); - /// ``` - fn asinh(self) -> Self; - - /// Inverse hyperbolic cosine function. - /// - /// ``` - /// use num::traits::Float; - /// - /// let x = 1.0; - /// let f = x.cosh().acosh(); - /// - /// let abs_difference = (f - x).abs(); - /// - /// assert!(abs_difference < 1.0e-10); - /// ``` - fn acosh(self) -> Self; - - /// Inverse hyperbolic tangent function. - /// - /// ``` - /// use num::traits::Float; - /// use std::f64; - /// - /// let e = f64::consts::E; - /// let f = e.tanh().atanh(); - /// - /// let abs_difference = (f - e).abs(); - /// - /// assert!(abs_difference < 1.0e-10); - /// ``` - fn atanh(self) -> Self; - - - /// Returns the mantissa, base 2 exponent, and sign as integers, respectively. - /// The original number can be recovered by `sign * mantissa * 2 ^ exponent`. - /// The floating point encoding is documented in the [Reference][floating-point]. - /// - /// ``` - /// use num::traits::Float; - /// - /// let num = 2.0f32; - /// - /// // (8388608, -22, 1) - /// let (mantissa, exponent, sign) = Float::integer_decode(num); - /// let sign_f = sign as f32; - /// let mantissa_f = mantissa as f32; - /// let exponent_f = num.powf(exponent as f32); - /// - /// // 1 * 8388608 * 2^(-22) == 2 - /// let abs_difference = (sign_f * mantissa_f * exponent_f - num).abs(); - /// - /// assert!(abs_difference < 1e-10); - /// ``` - /// [floating-point]: ../../../../../reference.html#machine-types - fn integer_decode(self) -> (u64, i16, i8); -} - -macro_rules! float_impl { - ($T:ident $decode:ident) => ( - impl Float for $T { - fn nan() -> Self { - ::std::$T::NAN - } - - fn infinity() -> Self { - ::std::$T::INFINITY - } - - fn neg_infinity() -> Self { - ::std::$T::NEG_INFINITY - } - - fn neg_zero() -> Self { - -0.0 - } - - fn min_value() -> Self { - ::std::$T::MIN - } - - fn min_positive_value() -> Self { - ::std::$T::MIN_POSITIVE - } - - fn max_value() -> Self { - ::std::$T::MAX - } - - fn is_nan(self) -> bool { - <$T>::is_nan(self) - } - - fn is_infinite(self) -> bool { - <$T>::is_infinite(self) - } - - fn is_finite(self) -> bool { - <$T>::is_finite(self) - } - - fn is_normal(self) -> bool { - <$T>::is_normal(self) - } - - fn classify(self) -> FpCategory { - <$T>::classify(self) - } - - fn floor(self) -> Self { - <$T>::floor(self) - } - - fn ceil(self) -> Self { - <$T>::ceil(self) - } - - fn round(self) -> Self { - <$T>::round(self) - } - - fn trunc(self) -> Self { - <$T>::trunc(self) - } - - fn fract(self) -> Self { - <$T>::fract(self) - } - - fn abs(self) -> Self { - <$T>::abs(self) - } - - fn signum(self) -> Self { - <$T>::signum(self) - } - - fn is_sign_positive(self) -> bool { - <$T>::is_sign_positive(self) - } - - fn is_sign_negative(self) -> bool { - <$T>::is_sign_negative(self) - } - - fn mul_add(self, a: Self, b: Self) -> Self { - <$T>::mul_add(self, a, b) - } - - fn recip(self) -> Self { - <$T>::recip(self) - } - - fn powi(self, n: i32) -> Self { - <$T>::powi(self, n) - } - - fn powf(self, n: Self) -> Self { - <$T>::powf(self, n) - } - - fn sqrt(self) -> Self { - <$T>::sqrt(self) - } - - fn exp(self) -> Self { - <$T>::exp(self) - } - - fn exp2(self) -> Self { - <$T>::exp2(self) - } - - fn ln(self) -> Self { - <$T>::ln(self) - } - - fn log(self, base: Self) -> Self { - <$T>::log(self, base) - } - - fn log2(self) -> Self { - <$T>::log2(self) - } - - fn log10(self) -> Self { - <$T>::log10(self) - } - - fn max(self, other: Self) -> Self { - <$T>::max(self, other) - } - - fn min(self, other: Self) -> Self { - <$T>::min(self, other) - } - - fn abs_sub(self, other: Self) -> Self { - <$T>::abs_sub(self, other) - } - - fn cbrt(self) -> Self { - <$T>::cbrt(self) - } - - fn hypot(self, other: Self) -> Self { - <$T>::hypot(self, other) - } - - fn sin(self) -> Self { - <$T>::sin(self) - } - - fn cos(self) -> Self { - <$T>::cos(self) - } - - fn tan(self) -> Self { - <$T>::tan(self) - } - - fn asin(self) -> Self { - <$T>::asin(self) - } - - fn acos(self) -> Self { - <$T>::acos(self) - } - - fn atan(self) -> Self { - <$T>::atan(self) - } - - fn atan2(self, other: Self) -> Self { - <$T>::atan2(self, other) - } - - fn sin_cos(self) -> (Self, Self) { - <$T>::sin_cos(self) - } - - fn exp_m1(self) -> Self { - <$T>::exp_m1(self) - } - - fn ln_1p(self) -> Self { - <$T>::ln_1p(self) - } - - fn sinh(self) -> Self { - <$T>::sinh(self) - } - - fn cosh(self) -> Self { - <$T>::cosh(self) - } - - fn tanh(self) -> Self { - <$T>::tanh(self) - } - - fn asinh(self) -> Self { - <$T>::asinh(self) - } - - fn acosh(self) -> Self { - <$T>::acosh(self) - } - - fn atanh(self) -> Self { - <$T>::atanh(self) - } - - fn integer_decode(self) -> (u64, i16, i8) { - $decode(self) - } - } - ) -} - -fn integer_decode_f32(f: f32) -> (u64, i16, i8) { - let bits: u32 = unsafe { mem::transmute(f) }; - let sign: i8 = if bits >> 31 == 0 { 1 } else { -1 }; - let mut exponent: i16 = ((bits >> 23) & 0xff) as i16; - let mantissa = if exponent == 0 { - (bits & 0x7fffff) << 1 - } else { - (bits & 0x7fffff) | 0x800000 - }; - // Exponent bias + mantissa shift - exponent -= 127 + 23; - (mantissa as u64, exponent, sign) -} - -fn integer_decode_f64(f: f64) -> (u64, i16, i8) { - let bits: u64 = unsafe { mem::transmute(f) }; - let sign: i8 = if bits >> 63 == 0 { 1 } else { -1 }; - let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16; - let mantissa = if exponent == 0 { - (bits & 0xfffffffffffff) << 1 - } else { - (bits & 0xfffffffffffff) | 0x10000000000000 - }; - // Exponent bias + mantissa shift - exponent -= 1023 + 52; - (mantissa, exponent, sign) -} - -float_impl!(f32 integer_decode_f32); -float_impl!(f64 integer_decode_f64); - - -#[test] -fn from_str_radix_unwrap() { - // The Result error must impl Debug to allow unwrap() - - let i: i32 = Num::from_str_radix("0", 10).unwrap(); - assert_eq!(i, 0); - - let f: f32 = Num::from_str_radix("0.0", 10).unwrap(); - assert_eq!(f, 0.0); -} diff --git a/traits/Cargo.toml b/traits/Cargo.toml new file mode 100644 index 0000000..0bfa8ac --- /dev/null +++ b/traits/Cargo.toml @@ -0,0 +1,12 @@ +[package] +authors = ["The Rust Project Developers"] +description = "Numeric traits for generic mathematics" +documentation = "http://rust-num.github.io/num" +homepage = "https://github.com/rust-num/num" +keywords = ["mathematics", "numerics"] +license = "MIT/Apache-2.0" +repository = "https://github.com/rust-num/num" +name = "num-traits" +version = "0.1.0" + +[dependencies] diff --git a/traits/src/bounds.rs b/traits/src/bounds.rs new file mode 100644 index 0000000..9f527d7 --- /dev/null +++ b/traits/src/bounds.rs @@ -0,0 +1,69 @@ +use std::{usize, u8, u16, u32, u64}; +use std::{isize, i8, i16, i32, i64}; +use std::{f32, f64}; + +/// Numbers which have upper and lower bounds +pub trait Bounded { + // FIXME (#5527): These should be associated constants + /// returns the smallest finite number this type can represent + fn min_value() -> Self; + /// returns the largest finite number this type can represent + fn max_value() -> Self; +} + +macro_rules! bounded_impl { + ($t:ty, $min:expr, $max:expr) => { + impl Bounded for $t { + #[inline] + fn min_value() -> $t { $min } + + #[inline] + fn max_value() -> $t { $max } + } + } +} + +bounded_impl!(usize, usize::MIN, usize::MAX); +bounded_impl!(u8, u8::MIN, u8::MAX); +bounded_impl!(u16, u16::MIN, u16::MAX); +bounded_impl!(u32, u32::MIN, u32::MAX); +bounded_impl!(u64, u64::MIN, u64::MAX); + +bounded_impl!(isize, isize::MIN, isize::MAX); +bounded_impl!(i8, i8::MIN, i8::MAX); +bounded_impl!(i16, i16::MIN, i16::MAX); +bounded_impl!(i32, i32::MIN, i32::MAX); +bounded_impl!(i64, i64::MIN, i64::MAX); + +bounded_impl!(f32, f32::MIN, f32::MAX); + +macro_rules! for_each_tuple_ { + ( $m:ident !! ) => ( + $m! { } + ); + ( $m:ident !! $h:ident, $($t:ident,)* ) => ( + $m! { $h $($t)* } + for_each_tuple_! { $m !! $($t,)* } + ); +} +macro_rules! for_each_tuple { + ( $m:ident ) => ( + for_each_tuple_! { $m !! A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, } + ); +} + +macro_rules! bounded_tuple { + ( $($name:ident)* ) => ( + impl<$($name: Bounded,)*> Bounded for ($($name,)*) { + fn min_value() -> Self { + ($($name::min_value(),)*) + } + fn max_value() -> Self { + ($($name::max_value(),)*) + } + } + ); +} + +for_each_tuple!(bounded_tuple); +bounded_impl!(f64, f64::MIN, f64::MAX); diff --git a/traits/src/cast.rs b/traits/src/cast.rs new file mode 100644 index 0000000..cefa7ff --- /dev/null +++ b/traits/src/cast.rs @@ -0,0 +1,433 @@ +use std::mem::size_of; + +use identities::Zero; +use bounds::Bounded; + +/// A generic trait for converting a value to a number. +pub trait ToPrimitive { + /// Converts the value of `self` to an `isize`. + #[inline] + fn to_isize(&self) -> Option { + self.to_i64().and_then(|x| x.to_isize()) + } + + /// Converts the value of `self` to an `i8`. + #[inline] + fn to_i8(&self) -> Option { + self.to_i64().and_then(|x| x.to_i8()) + } + + /// Converts the value of `self` to an `i16`. + #[inline] + fn to_i16(&self) -> Option { + self.to_i64().and_then(|x| x.to_i16()) + } + + /// Converts the value of `self` to an `i32`. + #[inline] + fn to_i32(&self) -> Option { + self.to_i64().and_then(|x| x.to_i32()) + } + + /// Converts the value of `self` to an `i64`. + fn to_i64(&self) -> Option; + + /// Converts the value of `self` to a `usize`. + #[inline] + fn to_usize(&self) -> Option { + self.to_u64().and_then(|x| x.to_usize()) + } + + /// Converts the value of `self` to an `u8`. + #[inline] + fn to_u8(&self) -> Option { + self.to_u64().and_then(|x| x.to_u8()) + } + + /// Converts the value of `self` to an `u16`. + #[inline] + fn to_u16(&self) -> Option { + self.to_u64().and_then(|x| x.to_u16()) + } + + /// Converts the value of `self` to an `u32`. + #[inline] + fn to_u32(&self) -> Option { + self.to_u64().and_then(|x| x.to_u32()) + } + + /// Converts the value of `self` to an `u64`. + #[inline] + fn to_u64(&self) -> Option; + + /// Converts the value of `self` to an `f32`. + #[inline] + fn to_f32(&self) -> Option { + self.to_f64().and_then(|x| x.to_f32()) + } + + /// Converts the value of `self` to an `f64`. + #[inline] + fn to_f64(&self) -> Option { + self.to_i64().and_then(|x| x.to_f64()) + } +} + +macro_rules! impl_to_primitive_int_to_int { + ($SrcT:ty, $DstT:ty, $slf:expr) => ( + { + if size_of::<$SrcT>() <= size_of::<$DstT>() { + Some($slf as $DstT) + } else { + let n = $slf as i64; + let min_value: $DstT = Bounded::min_value(); + let max_value: $DstT = Bounded::max_value(); + if min_value as i64 <= n && n <= max_value as i64 { + Some($slf as $DstT) + } else { + None + } + } + } + ) +} + +macro_rules! impl_to_primitive_int_to_uint { + ($SrcT:ty, $DstT:ty, $slf:expr) => ( + { + let zero: $SrcT = Zero::zero(); + let max_value: $DstT = Bounded::max_value(); + if zero <= $slf && $slf as u64 <= max_value as u64 { + Some($slf as $DstT) + } else { + None + } + } + ) +} + +macro_rules! impl_to_primitive_int { + ($T:ty) => ( + impl ToPrimitive for $T { + #[inline] + fn to_isize(&self) -> Option { impl_to_primitive_int_to_int!($T, isize, *self) } + #[inline] + fn to_i8(&self) -> Option { impl_to_primitive_int_to_int!($T, i8, *self) } + #[inline] + fn to_i16(&self) -> Option { impl_to_primitive_int_to_int!($T, i16, *self) } + #[inline] + fn to_i32(&self) -> Option { impl_to_primitive_int_to_int!($T, i32, *self) } + #[inline] + fn to_i64(&self) -> Option { impl_to_primitive_int_to_int!($T, i64, *self) } + + #[inline] + fn to_usize(&self) -> Option { impl_to_primitive_int_to_uint!($T, usize, *self) } + #[inline] + fn to_u8(&self) -> Option { impl_to_primitive_int_to_uint!($T, u8, *self) } + #[inline] + fn to_u16(&self) -> Option { impl_to_primitive_int_to_uint!($T, u16, *self) } + #[inline] + fn to_u32(&self) -> Option { impl_to_primitive_int_to_uint!($T, u32, *self) } + #[inline] + fn to_u64(&self) -> Option { impl_to_primitive_int_to_uint!($T, u64, *self) } + + #[inline] + fn to_f32(&self) -> Option { Some(*self as f32) } + #[inline] + fn to_f64(&self) -> Option { Some(*self as f64) } + } + ) +} + +impl_to_primitive_int!(isize); +impl_to_primitive_int!(i8); +impl_to_primitive_int!(i16); +impl_to_primitive_int!(i32); +impl_to_primitive_int!(i64); + +macro_rules! impl_to_primitive_uint_to_int { + ($DstT:ty, $slf:expr) => ( + { + let max_value: $DstT = Bounded::max_value(); + if $slf as u64 <= max_value as u64 { + Some($slf as $DstT) + } else { + None + } + } + ) +} + +macro_rules! impl_to_primitive_uint_to_uint { + ($SrcT:ty, $DstT:ty, $slf:expr) => ( + { + if size_of::<$SrcT>() <= size_of::<$DstT>() { + Some($slf as $DstT) + } else { + let zero: $SrcT = Zero::zero(); + let max_value: $DstT = Bounded::max_value(); + if zero <= $slf && $slf as u64 <= max_value as u64 { + Some($slf as $DstT) + } else { + None + } + } + } + ) +} + +macro_rules! impl_to_primitive_uint { + ($T:ty) => ( + impl ToPrimitive for $T { + #[inline] + fn to_isize(&self) -> Option { impl_to_primitive_uint_to_int!(isize, *self) } + #[inline] + fn to_i8(&self) -> Option { impl_to_primitive_uint_to_int!(i8, *self) } + #[inline] + fn to_i16(&self) -> Option { impl_to_primitive_uint_to_int!(i16, *self) } + #[inline] + fn to_i32(&self) -> Option { impl_to_primitive_uint_to_int!(i32, *self) } + #[inline] + fn to_i64(&self) -> Option { impl_to_primitive_uint_to_int!(i64, *self) } + + #[inline] + fn to_usize(&self) -> Option { + impl_to_primitive_uint_to_uint!($T, usize, *self) + } + #[inline] + fn to_u8(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u8, *self) } + #[inline] + fn to_u16(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u16, *self) } + #[inline] + fn to_u32(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u32, *self) } + #[inline] + fn to_u64(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u64, *self) } + + #[inline] + fn to_f32(&self) -> Option { Some(*self as f32) } + #[inline] + fn to_f64(&self) -> Option { Some(*self as f64) } + } + ) +} + +impl_to_primitive_uint!(usize); +impl_to_primitive_uint!(u8); +impl_to_primitive_uint!(u16); +impl_to_primitive_uint!(u32); +impl_to_primitive_uint!(u64); + +macro_rules! impl_to_primitive_float_to_float { + ($SrcT:ident, $DstT:ident, $slf:expr) => ( + if size_of::<$SrcT>() <= size_of::<$DstT>() { + Some($slf as $DstT) + } else { + let n = $slf as f64; + let max_value: $SrcT = ::std::$SrcT::MAX; + if -max_value as f64 <= n && n <= max_value as f64 { + Some($slf as $DstT) + } else { + None + } + } + ) +} + +macro_rules! impl_to_primitive_float { + ($T:ident) => ( + impl ToPrimitive for $T { + #[inline] + fn to_isize(&self) -> Option { Some(*self as isize) } + #[inline] + fn to_i8(&self) -> Option { Some(*self as i8) } + #[inline] + fn to_i16(&self) -> Option { Some(*self as i16) } + #[inline] + fn to_i32(&self) -> Option { Some(*self as i32) } + #[inline] + fn to_i64(&self) -> Option { Some(*self as i64) } + + #[inline] + fn to_usize(&self) -> Option { Some(*self as usize) } + #[inline] + fn to_u8(&self) -> Option { Some(*self as u8) } + #[inline] + fn to_u16(&self) -> Option { Some(*self as u16) } + #[inline] + fn to_u32(&self) -> Option { Some(*self as u32) } + #[inline] + fn to_u64(&self) -> Option { Some(*self as u64) } + + #[inline] + fn to_f32(&self) -> Option { impl_to_primitive_float_to_float!($T, f32, *self) } + #[inline] + fn to_f64(&self) -> Option { impl_to_primitive_float_to_float!($T, f64, *self) } + } + ) +} + +impl_to_primitive_float!(f32); +impl_to_primitive_float!(f64); + +/// A generic trait for converting a number to a value. +pub trait FromPrimitive: Sized { + /// Convert an `isize` to return an optional value of this type. If the + /// value cannot be represented by this value, the `None` is returned. + #[inline] + fn from_isize(n: isize) -> Option { + FromPrimitive::from_i64(n as i64) + } + + /// Convert an `i8` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_i8(n: i8) -> Option { + FromPrimitive::from_i64(n as i64) + } + + /// Convert an `i16` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_i16(n: i16) -> Option { + FromPrimitive::from_i64(n as i64) + } + + /// Convert an `i32` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_i32(n: i32) -> Option { + FromPrimitive::from_i64(n as i64) + } + + /// Convert an `i64` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + fn from_i64(n: i64) -> Option; + + /// Convert a `usize` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_usize(n: usize) -> Option { + FromPrimitive::from_u64(n as u64) + } + + /// Convert an `u8` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_u8(n: u8) -> Option { + FromPrimitive::from_u64(n as u64) + } + + /// Convert an `u16` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_u16(n: u16) -> Option { + FromPrimitive::from_u64(n as u64) + } + + /// Convert an `u32` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_u32(n: u32) -> Option { + FromPrimitive::from_u64(n as u64) + } + + /// Convert an `u64` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + fn from_u64(n: u64) -> Option; + + /// Convert a `f32` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_f32(n: f32) -> Option { + FromPrimitive::from_f64(n as f64) + } + + /// Convert a `f64` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_f64(n: f64) -> Option { + FromPrimitive::from_i64(n as i64) + } +} + +macro_rules! impl_from_primitive { + ($T:ty, $to_ty:ident) => ( + #[allow(deprecated)] + impl FromPrimitive for $T { + #[inline] fn from_i8(n: i8) -> Option<$T> { n.$to_ty() } + #[inline] fn from_i16(n: i16) -> Option<$T> { n.$to_ty() } + #[inline] fn from_i32(n: i32) -> Option<$T> { n.$to_ty() } + #[inline] fn from_i64(n: i64) -> Option<$T> { n.$to_ty() } + + #[inline] fn from_u8(n: u8) -> Option<$T> { n.$to_ty() } + #[inline] fn from_u16(n: u16) -> Option<$T> { n.$to_ty() } + #[inline] fn from_u32(n: u32) -> Option<$T> { n.$to_ty() } + #[inline] fn from_u64(n: u64) -> Option<$T> { n.$to_ty() } + + #[inline] fn from_f32(n: f32) -> Option<$T> { n.$to_ty() } + #[inline] fn from_f64(n: f64) -> Option<$T> { n.$to_ty() } + } + ) +} + +impl_from_primitive!(isize, to_isize); +impl_from_primitive!(i8, to_i8); +impl_from_primitive!(i16, to_i16); +impl_from_primitive!(i32, to_i32); +impl_from_primitive!(i64, to_i64); +impl_from_primitive!(usize, to_usize); +impl_from_primitive!(u8, to_u8); +impl_from_primitive!(u16, to_u16); +impl_from_primitive!(u32, to_u32); +impl_from_primitive!(u64, to_u64); +impl_from_primitive!(f32, to_f32); +impl_from_primitive!(f64, to_f64); + +/// Cast from one machine scalar to another. +/// +/// # Examples +/// +/// ``` +/// # use num_traits as num; +/// let twenty: f32 = num::cast(0x14).unwrap(); +/// assert_eq!(twenty, 20f32); +/// ``` +/// +#[inline] +pub fn cast(n: T) -> Option { + NumCast::from(n) +} + +/// An interface for casting between machine scalars. +pub trait NumCast: Sized + ToPrimitive { + /// Creates a number from another value that can be converted into + /// a primitive via the `ToPrimitive` trait. + fn from(n: T) -> Option; +} + +macro_rules! impl_num_cast { + ($T:ty, $conv:ident) => ( + impl NumCast for $T { + #[inline] + #[allow(deprecated)] + fn from(n: N) -> Option<$T> { + // `$conv` could be generated using `concat_idents!`, but that + // macro seems to be broken at the moment + n.$conv() + } + } + ) +} + +impl_num_cast!(u8, to_u8); +impl_num_cast!(u16, to_u16); +impl_num_cast!(u32, to_u32); +impl_num_cast!(u64, to_u64); +impl_num_cast!(usize, to_usize); +impl_num_cast!(i8, to_i8); +impl_num_cast!(i16, to_i16); +impl_num_cast!(i32, to_i32); +impl_num_cast!(i64, to_i64); +impl_num_cast!(isize, to_isize); +impl_num_cast!(f32, to_f32); +impl_num_cast!(f64, to_f64); diff --git a/traits/src/float.rs b/traits/src/float.rs new file mode 100644 index 0000000..f8c19ae --- /dev/null +++ b/traits/src/float.rs @@ -0,0 +1,1126 @@ +use std::mem; +use std::ops::Neg; +use std::num::FpCategory; + +use {Num, NumCast}; + +pub trait Float + : Num + + Copy + + NumCast + + PartialOrd + + Neg +{ + /// Returns the `NaN` value. + /// + /// ``` + /// use num_traits::Float; + /// + /// let nan: f32 = Float::nan(); + /// + /// assert!(nan.is_nan()); + /// ``` + fn nan() -> Self; + /// Returns the infinite value. + /// + /// ``` + /// use num_traits::Float; + /// use std::f32; + /// + /// let infinity: f32 = Float::infinity(); + /// + /// assert!(infinity.is_infinite()); + /// assert!(!infinity.is_finite()); + /// assert!(infinity > f32::MAX); + /// ``` + fn infinity() -> Self; + /// Returns the negative infinite value. + /// + /// ``` + /// use num_traits::Float; + /// use std::f32; + /// + /// let neg_infinity: f32 = Float::neg_infinity(); + /// + /// assert!(neg_infinity.is_infinite()); + /// assert!(!neg_infinity.is_finite()); + /// assert!(neg_infinity < f32::MIN); + /// ``` + fn neg_infinity() -> Self; + /// Returns `-0.0`. + /// + /// ``` + /// use num_traits::{Zero, Float}; + /// + /// let inf: f32 = Float::infinity(); + /// let zero: f32 = Zero::zero(); + /// let neg_zero: f32 = Float::neg_zero(); + /// + /// assert_eq!(zero, neg_zero); + /// assert_eq!(7.0f32/inf, zero); + /// assert_eq!(zero * 10.0, zero); + /// ``` + fn neg_zero() -> Self; + + /// Returns the smallest finite value that this type can represent. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let x: f64 = Float::min_value(); + /// + /// assert_eq!(x, f64::MIN); + /// ``` + fn min_value() -> Self; + + /// Returns the smallest positive, normalized value that this type can represent. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let x: f64 = Float::min_positive_value(); + /// + /// assert_eq!(x, f64::MIN_POSITIVE); + /// ``` + fn min_positive_value() -> Self; + + /// Returns the largest finite value that this type can represent. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let x: f64 = Float::max_value(); + /// assert_eq!(x, f64::MAX); + /// ``` + fn max_value() -> Self; + + /// Returns `true` if this value is `NaN` and false otherwise. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let nan = f64::NAN; + /// let f = 7.0; + /// + /// assert!(nan.is_nan()); + /// assert!(!f.is_nan()); + /// ``` + fn is_nan(self) -> bool; + + /// Returns `true` if this value is positive infinity or negative infinity and + /// false otherwise. + /// + /// ``` + /// use num_traits::Float; + /// use std::f32; + /// + /// let f = 7.0f32; + /// let inf: f32 = Float::infinity(); + /// let neg_inf: f32 = Float::neg_infinity(); + /// let nan: f32 = f32::NAN; + /// + /// assert!(!f.is_infinite()); + /// assert!(!nan.is_infinite()); + /// + /// assert!(inf.is_infinite()); + /// assert!(neg_inf.is_infinite()); + /// ``` + fn is_infinite(self) -> bool; + + /// Returns `true` if this number is neither infinite nor `NaN`. + /// + /// ``` + /// use num_traits::Float; + /// use std::f32; + /// + /// let f = 7.0f32; + /// let inf: f32 = Float::infinity(); + /// let neg_inf: f32 = Float::neg_infinity(); + /// let nan: f32 = f32::NAN; + /// + /// assert!(f.is_finite()); + /// + /// assert!(!nan.is_finite()); + /// assert!(!inf.is_finite()); + /// assert!(!neg_inf.is_finite()); + /// ``` + fn is_finite(self) -> bool; + + /// Returns `true` if the number is neither zero, infinite, + /// [subnormal][subnormal], or `NaN`. + /// + /// ``` + /// use num_traits::Float; + /// use std::f32; + /// + /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32 + /// let max = f32::MAX; + /// let lower_than_min = 1.0e-40_f32; + /// let zero = 0.0f32; + /// + /// assert!(min.is_normal()); + /// assert!(max.is_normal()); + /// + /// assert!(!zero.is_normal()); + /// assert!(!f32::NAN.is_normal()); + /// assert!(!f32::INFINITY.is_normal()); + /// // Values between `0` and `min` are Subnormal. + /// assert!(!lower_than_min.is_normal()); + /// ``` + /// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number + fn is_normal(self) -> bool; + + /// Returns the floating point category of the number. If only one property + /// is going to be tested, it is generally faster to use the specific + /// predicate instead. + /// + /// ``` + /// use num_traits::Float; + /// use std::num::FpCategory; + /// use std::f32; + /// + /// let num = 12.4f32; + /// let inf = f32::INFINITY; + /// + /// assert_eq!(num.classify(), FpCategory::Normal); + /// assert_eq!(inf.classify(), FpCategory::Infinite); + /// ``` + fn classify(self) -> FpCategory; + + /// Returns the largest integer less than or equal to a number. + /// + /// ``` + /// use num_traits::Float; + /// + /// let f = 3.99; + /// let g = 3.0; + /// + /// assert_eq!(f.floor(), 3.0); + /// assert_eq!(g.floor(), 3.0); + /// ``` + fn floor(self) -> Self; + + /// Returns the smallest integer greater than or equal to a number. + /// + /// ``` + /// use num_traits::Float; + /// + /// let f = 3.01; + /// let g = 4.0; + /// + /// assert_eq!(f.ceil(), 4.0); + /// assert_eq!(g.ceil(), 4.0); + /// ``` + fn ceil(self) -> Self; + + /// Returns the nearest integer to a number. Round half-way cases away from + /// `0.0`. + /// + /// ``` + /// use num_traits::Float; + /// + /// let f = 3.3; + /// let g = -3.3; + /// + /// assert_eq!(f.round(), 3.0); + /// assert_eq!(g.round(), -3.0); + /// ``` + fn round(self) -> Self; + + /// Return the integer part of a number. + /// + /// ``` + /// use num_traits::Float; + /// + /// let f = 3.3; + /// let g = -3.7; + /// + /// assert_eq!(f.trunc(), 3.0); + /// assert_eq!(g.trunc(), -3.0); + /// ``` + fn trunc(self) -> Self; + + /// Returns the fractional part of a number. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 3.5; + /// let y = -3.5; + /// let abs_difference_x = (x.fract() - 0.5).abs(); + /// let abs_difference_y = (y.fract() - (-0.5)).abs(); + /// + /// assert!(abs_difference_x < 1e-10); + /// assert!(abs_difference_y < 1e-10); + /// ``` + fn fract(self) -> Self; + + /// Computes the absolute value of `self`. Returns `Float::nan()` if the + /// number is `Float::nan()`. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let x = 3.5; + /// let y = -3.5; + /// + /// let abs_difference_x = (x.abs() - x).abs(); + /// let abs_difference_y = (y.abs() - (-y)).abs(); + /// + /// assert!(abs_difference_x < 1e-10); + /// assert!(abs_difference_y < 1e-10); + /// + /// assert!(f64::NAN.abs().is_nan()); + /// ``` + fn abs(self) -> Self; + + /// Returns a number that represents the sign of `self`. + /// + /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()` + /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()` + /// - `Float::nan()` if the number is `Float::nan()` + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let f = 3.5; + /// + /// assert_eq!(f.signum(), 1.0); + /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0); + /// + /// assert!(f64::NAN.signum().is_nan()); + /// ``` + fn signum(self) -> Self; + + /// Returns `true` if `self` is positive, including `+0.0` and + /// `Float::infinity()`. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let nan: f64 = f64::NAN; + /// + /// let f = 7.0; + /// let g = -7.0; + /// + /// assert!(f.is_sign_positive()); + /// assert!(!g.is_sign_positive()); + /// // Requires both tests to determine if is `NaN` + /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative()); + /// ``` + fn is_sign_positive(self) -> bool; + + /// Returns `true` if `self` is negative, including `-0.0` and + /// `Float::neg_infinity()`. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let nan = f64::NAN; + /// + /// let f = 7.0; + /// let g = -7.0; + /// + /// assert!(!f.is_sign_negative()); + /// assert!(g.is_sign_negative()); + /// // Requires both tests to determine if is `NaN`. + /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative()); + /// ``` + fn is_sign_negative(self) -> bool; + + /// Fused multiply-add. Computes `(self * a) + b` with only one rounding + /// error. This produces a more accurate result with better performance than + /// a separate multiplication operation followed by an add. + /// + /// ``` + /// use num_traits::Float; + /// + /// let m = 10.0; + /// let x = 4.0; + /// let b = 60.0; + /// + /// // 100.0 + /// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn mul_add(self, a: Self, b: Self) -> Self; + /// Take the reciprocal (inverse) of a number, `1/x`. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 2.0; + /// let abs_difference = (x.recip() - (1.0/x)).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn recip(self) -> Self; + + /// Raise a number to an integer power. + /// + /// Using this function is generally faster than using `powf` + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 2.0; + /// let abs_difference = (x.powi(2) - x*x).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn powi(self, n: i32) -> Self; + + /// Raise a number to a floating point power. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 2.0; + /// let abs_difference = (x.powf(2.0) - x*x).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn powf(self, n: Self) -> Self; + + /// Take the square root of a number. + /// + /// Returns NaN if `self` is a negative number. + /// + /// ``` + /// use num_traits::Float; + /// + /// let positive = 4.0; + /// let negative = -4.0; + /// + /// let abs_difference = (positive.sqrt() - 2.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// assert!(negative.sqrt().is_nan()); + /// ``` + fn sqrt(self) -> Self; + + /// Returns `e^(self)`, (the exponential function). + /// + /// ``` + /// use num_traits::Float; + /// + /// let one = 1.0; + /// // e^1 + /// let e = one.exp(); + /// + /// // ln(e) - 1 == 0 + /// let abs_difference = (e.ln() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn exp(self) -> Self; + + /// Returns `2^(self)`. + /// + /// ``` + /// use num_traits::Float; + /// + /// let f = 2.0; + /// + /// // 2^2 - 4 == 0 + /// let abs_difference = (f.exp2() - 4.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn exp2(self) -> Self; + + /// Returns the natural logarithm of the number. + /// + /// ``` + /// use num_traits::Float; + /// + /// let one = 1.0; + /// // e^1 + /// let e = one.exp(); + /// + /// // ln(e) - 1 == 0 + /// let abs_difference = (e.ln() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn ln(self) -> Self; + + /// Returns the logarithm of the number with respect to an arbitrary base. + /// + /// ``` + /// use num_traits::Float; + /// + /// let ten = 10.0; + /// let two = 2.0; + /// + /// // log10(10) - 1 == 0 + /// let abs_difference_10 = (ten.log(10.0) - 1.0).abs(); + /// + /// // log2(2) - 1 == 0 + /// let abs_difference_2 = (two.log(2.0) - 1.0).abs(); + /// + /// assert!(abs_difference_10 < 1e-10); + /// assert!(abs_difference_2 < 1e-10); + /// ``` + fn log(self, base: Self) -> Self; + + /// Returns the base 2 logarithm of the number. + /// + /// ``` + /// use num_traits::Float; + /// + /// let two = 2.0; + /// + /// // log2(2) - 1 == 0 + /// let abs_difference = (two.log2() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn log2(self) -> Self; + + /// Returns the base 10 logarithm of the number. + /// + /// ``` + /// use num_traits::Float; + /// + /// let ten = 10.0; + /// + /// // log10(10) - 1 == 0 + /// let abs_difference = (ten.log10() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn log10(self) -> Self; + + /// Returns the maximum of the two numbers. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 1.0; + /// let y = 2.0; + /// + /// assert_eq!(x.max(y), y); + /// ``` + fn max(self, other: Self) -> Self; + + /// Returns the minimum of the two numbers. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 1.0; + /// let y = 2.0; + /// + /// assert_eq!(x.min(y), x); + /// ``` + fn min(self, other: Self) -> Self; + + /// The positive difference of two numbers. + /// + /// * If `self <= other`: `0:0` + /// * Else: `self - other` + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 3.0; + /// let y = -3.0; + /// + /// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs(); + /// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs(); + /// + /// assert!(abs_difference_x < 1e-10); + /// assert!(abs_difference_y < 1e-10); + /// ``` + fn abs_sub(self, other: Self) -> Self; + + /// Take the cubic root of a number. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 8.0; + /// + /// // x^(1/3) - 2 == 0 + /// let abs_difference = (x.cbrt() - 2.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn cbrt(self) -> Self; + + /// Calculate the length of the hypotenuse of a right-angle triangle given + /// legs of length `x` and `y`. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 2.0; + /// let y = 3.0; + /// + /// // sqrt(x^2 + y^2) + /// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn hypot(self, other: Self) -> Self; + + /// Computes the sine of a number (in radians). + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let x = f64::consts::PI/2.0; + /// + /// let abs_difference = (x.sin() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn sin(self) -> Self; + + /// Computes the cosine of a number (in radians). + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let x = 2.0*f64::consts::PI; + /// + /// let abs_difference = (x.cos() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn cos(self) -> Self; + + /// Computes the tangent of a number (in radians). + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let x = f64::consts::PI/4.0; + /// let abs_difference = (x.tan() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-14); + /// ``` + fn tan(self) -> Self; + + /// Computes the arcsine of a number. Return value is in radians in + /// the range [-pi/2, pi/2] or NaN if the number is outside the range + /// [-1, 1]. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let f = f64::consts::PI / 2.0; + /// + /// // asin(sin(pi/2)) + /// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn asin(self) -> Self; + + /// Computes the arccosine of a number. Return value is in radians in + /// the range [0, pi] or NaN if the number is outside the range + /// [-1, 1]. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let f = f64::consts::PI / 4.0; + /// + /// // acos(cos(pi/4)) + /// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn acos(self) -> Self; + + /// Computes the arctangent of a number. Return value is in radians in the + /// range [-pi/2, pi/2]; + /// + /// ``` + /// use num_traits::Float; + /// + /// let f = 1.0; + /// + /// // atan(tan(1)) + /// let abs_difference = (f.tan().atan() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn atan(self) -> Self; + + /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`). + /// + /// * `x = 0`, `y = 0`: `0` + /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]` + /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]` + /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)` + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let pi = f64::consts::PI; + /// // All angles from horizontal right (+x) + /// // 45 deg counter-clockwise + /// let x1 = 3.0; + /// let y1 = -3.0; + /// + /// // 135 deg clockwise + /// let x2 = -3.0; + /// let y2 = 3.0; + /// + /// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs(); + /// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs(); + /// + /// assert!(abs_difference_1 < 1e-10); + /// assert!(abs_difference_2 < 1e-10); + /// ``` + fn atan2(self, other: Self) -> Self; + + /// Simultaneously computes the sine and cosine of the number, `x`. Returns + /// `(sin(x), cos(x))`. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let x = f64::consts::PI/4.0; + /// let f = x.sin_cos(); + /// + /// let abs_difference_0 = (f.0 - x.sin()).abs(); + /// let abs_difference_1 = (f.1 - x.cos()).abs(); + /// + /// assert!(abs_difference_0 < 1e-10); + /// assert!(abs_difference_0 < 1e-10); + /// ``` + fn sin_cos(self) -> (Self, Self); + + /// Returns `e^(self) - 1` in a way that is accurate even if the + /// number is close to zero. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 7.0; + /// + /// // e^(ln(7)) - 1 + /// let abs_difference = (x.ln().exp_m1() - 6.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn exp_m1(self) -> Self; + + /// Returns `ln(1+n)` (natural logarithm) more accurately than if + /// the operations were performed separately. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let x = f64::consts::E - 1.0; + /// + /// // ln(1 + (e - 1)) == ln(e) == 1 + /// let abs_difference = (x.ln_1p() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn ln_1p(self) -> Self; + + /// Hyperbolic sine function. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let e = f64::consts::E; + /// let x = 1.0; + /// + /// let f = x.sinh(); + /// // Solving sinh() at 1 gives `(e^2-1)/(2e)` + /// let g = (e*e - 1.0)/(2.0*e); + /// let abs_difference = (f - g).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn sinh(self) -> Self; + + /// Hyperbolic cosine function. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let e = f64::consts::E; + /// let x = 1.0; + /// let f = x.cosh(); + /// // Solving cosh() at 1 gives this result + /// let g = (e*e + 1.0)/(2.0*e); + /// let abs_difference = (f - g).abs(); + /// + /// // Same result + /// assert!(abs_difference < 1.0e-10); + /// ``` + fn cosh(self) -> Self; + + /// Hyperbolic tangent function. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let e = f64::consts::E; + /// let x = 1.0; + /// + /// let f = x.tanh(); + /// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))` + /// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2)); + /// let abs_difference = (f - g).abs(); + /// + /// assert!(abs_difference < 1.0e-10); + /// ``` + fn tanh(self) -> Self; + + /// Inverse hyperbolic sine function. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 1.0; + /// let f = x.sinh().asinh(); + /// + /// let abs_difference = (f - x).abs(); + /// + /// assert!(abs_difference < 1.0e-10); + /// ``` + fn asinh(self) -> Self; + + /// Inverse hyperbolic cosine function. + /// + /// ``` + /// use num_traits::Float; + /// + /// let x = 1.0; + /// let f = x.cosh().acosh(); + /// + /// let abs_difference = (f - x).abs(); + /// + /// assert!(abs_difference < 1.0e-10); + /// ``` + fn acosh(self) -> Self; + + /// Inverse hyperbolic tangent function. + /// + /// ``` + /// use num_traits::Float; + /// use std::f64; + /// + /// let e = f64::consts::E; + /// let f = e.tanh().atanh(); + /// + /// let abs_difference = (f - e).abs(); + /// + /// assert!(abs_difference < 1.0e-10); + /// ``` + fn atanh(self) -> Self; + + + /// Returns the mantissa, base 2 exponent, and sign as integers, respectively. + /// The original number can be recovered by `sign * mantissa * 2 ^ exponent`. + /// The floating point encoding is documented in the [Reference][floating-point]. + /// + /// ``` + /// use num_traits::Float; + /// + /// let num = 2.0f32; + /// + /// // (8388608, -22, 1) + /// let (mantissa, exponent, sign) = Float::integer_decode(num); + /// let sign_f = sign as f32; + /// let mantissa_f = mantissa as f32; + /// let exponent_f = num.powf(exponent as f32); + /// + /// // 1 * 8388608 * 2^(-22) == 2 + /// let abs_difference = (sign_f * mantissa_f * exponent_f - num).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + /// [floating-point]: ../../../../../reference.html#machine-types + fn integer_decode(self) -> (u64, i16, i8); +} + +macro_rules! float_impl { + ($T:ident $decode:ident) => ( + impl Float for $T { + fn nan() -> Self { + ::std::$T::NAN + } + + fn infinity() -> Self { + ::std::$T::INFINITY + } + + fn neg_infinity() -> Self { + ::std::$T::NEG_INFINITY + } + + fn neg_zero() -> Self { + -0.0 + } + + fn min_value() -> Self { + ::std::$T::MIN + } + + fn min_positive_value() -> Self { + ::std::$T::MIN_POSITIVE + } + + fn max_value() -> Self { + ::std::$T::MAX + } + + fn is_nan(self) -> bool { + <$T>::is_nan(self) + } + + fn is_infinite(self) -> bool { + <$T>::is_infinite(self) + } + + fn is_finite(self) -> bool { + <$T>::is_finite(self) + } + + fn is_normal(self) -> bool { + <$T>::is_normal(self) + } + + fn classify(self) -> FpCategory { + <$T>::classify(self) + } + + fn floor(self) -> Self { + <$T>::floor(self) + } + + fn ceil(self) -> Self { + <$T>::ceil(self) + } + + fn round(self) -> Self { + <$T>::round(self) + } + + fn trunc(self) -> Self { + <$T>::trunc(self) + } + + fn fract(self) -> Self { + <$T>::fract(self) + } + + fn abs(self) -> Self { + <$T>::abs(self) + } + + fn signum(self) -> Self { + <$T>::signum(self) + } + + fn is_sign_positive(self) -> bool { + <$T>::is_sign_positive(self) + } + + fn is_sign_negative(self) -> bool { + <$T>::is_sign_negative(self) + } + + fn mul_add(self, a: Self, b: Self) -> Self { + <$T>::mul_add(self, a, b) + } + + fn recip(self) -> Self { + <$T>::recip(self) + } + + fn powi(self, n: i32) -> Self { + <$T>::powi(self, n) + } + + fn powf(self, n: Self) -> Self { + <$T>::powf(self, n) + } + + fn sqrt(self) -> Self { + <$T>::sqrt(self) + } + + fn exp(self) -> Self { + <$T>::exp(self) + } + + fn exp2(self) -> Self { + <$T>::exp2(self) + } + + fn ln(self) -> Self { + <$T>::ln(self) + } + + fn log(self, base: Self) -> Self { + <$T>::log(self, base) + } + + fn log2(self) -> Self { + <$T>::log2(self) + } + + fn log10(self) -> Self { + <$T>::log10(self) + } + + fn max(self, other: Self) -> Self { + <$T>::max(self, other) + } + + fn min(self, other: Self) -> Self { + <$T>::min(self, other) + } + + fn abs_sub(self, other: Self) -> Self { + <$T>::abs_sub(self, other) + } + + fn cbrt(self) -> Self { + <$T>::cbrt(self) + } + + fn hypot(self, other: Self) -> Self { + <$T>::hypot(self, other) + } + + fn sin(self) -> Self { + <$T>::sin(self) + } + + fn cos(self) -> Self { + <$T>::cos(self) + } + + fn tan(self) -> Self { + <$T>::tan(self) + } + + fn asin(self) -> Self { + <$T>::asin(self) + } + + fn acos(self) -> Self { + <$T>::acos(self) + } + + fn atan(self) -> Self { + <$T>::atan(self) + } + + fn atan2(self, other: Self) -> Self { + <$T>::atan2(self, other) + } + + fn sin_cos(self) -> (Self, Self) { + <$T>::sin_cos(self) + } + + fn exp_m1(self) -> Self { + <$T>::exp_m1(self) + } + + fn ln_1p(self) -> Self { + <$T>::ln_1p(self) + } + + fn sinh(self) -> Self { + <$T>::sinh(self) + } + + fn cosh(self) -> Self { + <$T>::cosh(self) + } + + fn tanh(self) -> Self { + <$T>::tanh(self) + } + + fn asinh(self) -> Self { + <$T>::asinh(self) + } + + fn acosh(self) -> Self { + <$T>::acosh(self) + } + + fn atanh(self) -> Self { + <$T>::atanh(self) + } + + fn integer_decode(self) -> (u64, i16, i8) { + $decode(self) + } + } + ) +} + +fn integer_decode_f32(f: f32) -> (u64, i16, i8) { + let bits: u32 = unsafe { mem::transmute(f) }; + let sign: i8 = if bits >> 31 == 0 { + 1 + } else { + -1 + }; + let mut exponent: i16 = ((bits >> 23) & 0xff) as i16; + let mantissa = if exponent == 0 { + (bits & 0x7fffff) << 1 + } else { + (bits & 0x7fffff) | 0x800000 + }; + // Exponent bias + mantissa shift + exponent -= 127 + 23; + (mantissa as u64, exponent, sign) +} + +fn integer_decode_f64(f: f64) -> (u64, i16, i8) { + let bits: u64 = unsafe { mem::transmute(f) }; + let sign: i8 = if bits >> 63 == 0 { + 1 + } else { + -1 + }; + let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16; + let mantissa = if exponent == 0 { + (bits & 0xfffffffffffff) << 1 + } else { + (bits & 0xfffffffffffff) | 0x10000000000000 + }; + // Exponent bias + mantissa shift + exponent -= 1023 + 52; + (mantissa, exponent, sign) +} + +float_impl!(f32 integer_decode_f32); +float_impl!(f64 integer_decode_f64); diff --git a/traits/src/identities.rs b/traits/src/identities.rs new file mode 100644 index 0000000..0fee84a --- /dev/null +++ b/traits/src/identities.rs @@ -0,0 +1,95 @@ +use std::ops::{Add, Mul}; + +/// Defines an additive identity element for `Self`. +pub trait Zero: Sized + Add { + /// Returns the additive identity element of `Self`, `0`. + /// + /// # Laws + /// + /// ```{.text} + /// a + 0 = a ∀ a ∈ Self + /// 0 + a = a ∀ a ∈ Self + /// ``` + /// + /// # Purity + /// + /// This function should return the same result at all times regardless of + /// external mutable state, for example values stored in TLS or in + /// `static mut`s. + // FIXME (#5527): This should be an associated constant + fn zero() -> Self; + + /// Returns `true` if `self` is equal to the additive identity. + #[inline] + fn is_zero(&self) -> bool; +} + +macro_rules! zero_impl { + ($t:ty, $v:expr) => { + impl Zero for $t { + #[inline] + fn zero() -> $t { $v } + #[inline] + fn is_zero(&self) -> bool { *self == $v } + } + } +} + +zero_impl!(usize, 0usize); +zero_impl!(u8, 0u8); +zero_impl!(u16, 0u16); +zero_impl!(u32, 0u32); +zero_impl!(u64, 0u64); + +zero_impl!(isize, 0isize); +zero_impl!(i8, 0i8); +zero_impl!(i16, 0i16); +zero_impl!(i32, 0i32); +zero_impl!(i64, 0i64); + +zero_impl!(f32, 0.0f32); +zero_impl!(f64, 0.0f64); + +/// Defines a multiplicative identity element for `Self`. +pub trait One: Sized + Mul { + /// Returns the multiplicative identity element of `Self`, `1`. + /// + /// # Laws + /// + /// ```{.text} + /// a * 1 = a ∀ a ∈ Self + /// 1 * a = a ∀ a ∈ Self + /// ``` + /// + /// # Purity + /// + /// This function should return the same result at all times regardless of + /// external mutable state, for example values stored in TLS or in + /// `static mut`s. + // FIXME (#5527): This should be an associated constant + fn one() -> Self; +} + +macro_rules! one_impl { + ($t:ty, $v:expr) => { + impl One for $t { + #[inline] + fn one() -> $t { $v } + } + } +} + +one_impl!(usize, 1usize); +one_impl!(u8, 1u8); +one_impl!(u16, 1u16); +one_impl!(u32, 1u32); +one_impl!(u64, 1u64); + +one_impl!(isize, 1isize); +one_impl!(i8, 1i8); +one_impl!(i16, 1i16); +one_impl!(i32, 1i32); +one_impl!(i64, 1i64); + +one_impl!(f32, 1.0f32); +one_impl!(f64, 1.0f64); diff --git a/traits/src/int.rs b/traits/src/int.rs new file mode 100644 index 0000000..6cc90ca --- /dev/null +++ b/traits/src/int.rs @@ -0,0 +1,360 @@ +use std::ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr}; + +use {Num, NumCast}; +use bounds::Bounded; +use ops::checked::*; +use ops::saturating::Saturating; + +pub trait PrimInt + : Sized + + Copy + + Num + NumCast + + Bounded + + PartialOrd + Ord + Eq + + Not + + BitAnd + + BitOr + + BitXor + + Shl + + Shr + + CheckedAdd + + CheckedSub + + CheckedMul + + CheckedDiv + + Saturating +{ + /// Returns the number of ones in the binary representation of `self`. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0b01001100u8; + /// + /// assert_eq!(n.count_ones(), 3); + /// ``` + fn count_ones(self) -> u32; + + /// Returns the number of zeros in the binary representation of `self`. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0b01001100u8; + /// + /// assert_eq!(n.count_zeros(), 5); + /// ``` + fn count_zeros(self) -> u32; + + /// Returns the number of leading zeros in the binary representation + /// of `self`. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0b0101000u16; + /// + /// assert_eq!(n.leading_zeros(), 10); + /// ``` + fn leading_zeros(self) -> u32; + + /// Returns the number of trailing zeros in the binary representation + /// of `self`. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0b0101000u16; + /// + /// assert_eq!(n.trailing_zeros(), 3); + /// ``` + fn trailing_zeros(self) -> u32; + + /// Shifts the bits to the left by a specified amount amount, `n`, wrapping + /// the truncated bits to the end of the resulting integer. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0x3456789ABCDEF012u64; + /// + /// assert_eq!(n.rotate_left(12), m); + /// ``` + fn rotate_left(self, n: u32) -> Self; + + /// Shifts the bits to the right by a specified amount amount, `n`, wrapping + /// the truncated bits to the beginning of the resulting integer. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0xDEF0123456789ABCu64; + /// + /// assert_eq!(n.rotate_right(12), m); + /// ``` + fn rotate_right(self, n: u32) -> Self; + + /// Shifts the bits to the left by a specified amount amount, `n`, filling + /// zeros in the least significant bits. + /// + /// This is bitwise equivalent to signed `Shl`. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0x3456789ABCDEF000u64; + /// + /// assert_eq!(n.signed_shl(12), m); + /// ``` + fn signed_shl(self, n: u32) -> Self; + + /// Shifts the bits to the right by a specified amount amount, `n`, copying + /// the "sign bit" in the most significant bits even for unsigned types. + /// + /// This is bitwise equivalent to signed `Shr`. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0xFEDCBA9876543210u64; + /// let m = 0xFFFFEDCBA9876543u64; + /// + /// assert_eq!(n.signed_shr(12), m); + /// ``` + fn signed_shr(self, n: u32) -> Self; + + /// Shifts the bits to the left by a specified amount amount, `n`, filling + /// zeros in the least significant bits. + /// + /// This is bitwise equivalent to unsigned `Shl`. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0x0123456789ABCDEFi64; + /// let m = 0x3456789ABCDEF000i64; + /// + /// assert_eq!(n.unsigned_shl(12), m); + /// ``` + fn unsigned_shl(self, n: u32) -> Self; + + /// Shifts the bits to the right by a specified amount amount, `n`, filling + /// zeros in the most significant bits. + /// + /// This is bitwise equivalent to unsigned `Shr`. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0xFEDCBA9876543210i64; + /// let m = 0x000FEDCBA9876543i64; + /// + /// assert_eq!(n.unsigned_shr(12), m); + /// ``` + fn unsigned_shr(self, n: u32) -> Self; + + /// Reverses the byte order of the integer. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0xEFCDAB8967452301u64; + /// + /// assert_eq!(n.swap_bytes(), m); + /// ``` + fn swap_bytes(self) -> Self; + + /// Convert an integer from big endian to the target's endianness. + /// + /// On big endian this is a no-op. On little endian the bytes are swapped. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "big") { + /// assert_eq!(u64::from_be(n), n) + /// } else { + /// assert_eq!(u64::from_be(n), n.swap_bytes()) + /// } + /// ``` + fn from_be(x: Self) -> Self; + + /// Convert an integer from little endian to the target's endianness. + /// + /// On little endian this is a no-op. On big endian the bytes are swapped. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "little") { + /// assert_eq!(u64::from_le(n), n) + /// } else { + /// assert_eq!(u64::from_le(n), n.swap_bytes()) + /// } + /// ``` + fn from_le(x: Self) -> Self; + + /// Convert `self` to big endian from the target's endianness. + /// + /// On big endian this is a no-op. On little endian the bytes are swapped. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "big") { + /// assert_eq!(n.to_be(), n) + /// } else { + /// assert_eq!(n.to_be(), n.swap_bytes()) + /// } + /// ``` + fn to_be(self) -> Self; + + /// Convert `self` to little endian from the target's endianness. + /// + /// On little endian this is a no-op. On big endian the bytes are swapped. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "little") { + /// assert_eq!(n.to_le(), n) + /// } else { + /// assert_eq!(n.to_le(), n.swap_bytes()) + /// } + /// ``` + fn to_le(self) -> Self; + + /// Raises self to the power of `exp`, using exponentiation by squaring. + /// + /// # Examples + /// + /// ``` + /// use num_traits::PrimInt; + /// + /// assert_eq!(2i32.pow(4), 16); + /// ``` + fn pow(self, mut exp: u32) -> Self; +} + +macro_rules! prim_int_impl { + ($T:ty, $S:ty, $U:ty) => ( + impl PrimInt for $T { + fn count_ones(self) -> u32 { + <$T>::count_ones(self) + } + + fn count_zeros(self) -> u32 { + <$T>::count_zeros(self) + } + + fn leading_zeros(self) -> u32 { + <$T>::leading_zeros(self) + } + + fn trailing_zeros(self) -> u32 { + <$T>::trailing_zeros(self) + } + + fn rotate_left(self, n: u32) -> Self { + <$T>::rotate_left(self, n) + } + + fn rotate_right(self, n: u32) -> Self { + <$T>::rotate_right(self, n) + } + + fn signed_shl(self, n: u32) -> Self { + ((self as $S) << n) as $T + } + + fn signed_shr(self, n: u32) -> Self { + ((self as $S) >> n) as $T + } + + fn unsigned_shl(self, n: u32) -> Self { + ((self as $U) << n) as $T + } + + fn unsigned_shr(self, n: u32) -> Self { + ((self as $U) >> n) as $T + } + + fn swap_bytes(self) -> Self { + <$T>::swap_bytes(self) + } + + fn from_be(x: Self) -> Self { + <$T>::from_be(x) + } + + fn from_le(x: Self) -> Self { + <$T>::from_le(x) + } + + fn to_be(self) -> Self { + <$T>::to_be(self) + } + + fn to_le(self) -> Self { + <$T>::to_le(self) + } + + fn pow(self, exp: u32) -> Self { + <$T>::pow(self, exp) + } + } + ) +} + +// prim_int_impl!(type, signed, unsigned); +prim_int_impl!(u8, i8, u8); +prim_int_impl!(u16, i16, u16); +prim_int_impl!(u32, i32, u32); +prim_int_impl!(u64, i64, u64); +prim_int_impl!(usize, isize, usize); +prim_int_impl!(i8, i8, u8); +prim_int_impl!(i16, i16, u16); +prim_int_impl!(i32, i32, u32); +prim_int_impl!(i64, i64, u64); +prim_int_impl!(isize, isize, usize); diff --git a/traits/src/lib.rs b/traits/src/lib.rs new file mode 100644 index 0000000..d89abe6 --- /dev/null +++ b/traits/src/lib.rs @@ -0,0 +1,233 @@ +// 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. + +//! Numeric traits for generic mathematics + +use std::ops::{Add, Sub, Mul, Div, Rem}; + +pub use bounds::Bounded; +pub use float::Float; +pub use identities::{Zero, One}; +pub use ops::checked::*; +pub use ops::saturating::Saturating; +pub use sign::{Signed, Unsigned}; +pub use cast::*; +pub use int::PrimInt; + +pub mod identities; +pub mod sign; +pub mod ops; +pub mod bounds; +pub mod float; +pub mod cast; +pub mod int; + +/// The base trait for numeric types +pub trait Num: PartialEq + Zero + One + + Add + Sub + + Mul + Div + Rem +{ + type FromStrRadixErr; + + /// Convert from a string and radix <= 36. + fn from_str_radix(str: &str, radix: u32) -> Result; +} + +macro_rules! int_trait_impl { + ($name:ident for $($t:ty)*) => ($( + impl $name for $t { + type FromStrRadixErr = ::std::num::ParseIntError; + fn from_str_radix(s: &str, radix: u32) + -> Result + { + <$t>::from_str_radix(s, radix) + } + } + )*) +} +int_trait_impl!(Num for usize u8 u16 u32 u64 isize i8 i16 i32 i64); + +#[derive(Debug)] +pub enum FloatErrorKind { + Empty, + Invalid, +} +// FIXME: std::num::ParseFloatError is stable in 1.0, but opaque to us, +// so there's not really any way for us to reuse it. +#[derive(Debug)] +pub struct ParseFloatError { + pub kind: FloatErrorKind, +} + +// FIXME: The standard library from_str_radix on floats was deprecated, so we're stuck +// with this implementation ourselves until we want to make a breaking change. +// (would have to drop it from `Num` though) +macro_rules! float_trait_impl { + ($name:ident for $($t:ty)*) => ($( + impl $name for $t { + type FromStrRadixErr = ParseFloatError; + + fn from_str_radix(src: &str, radix: u32) + -> Result + { + use self::FloatErrorKind::*; + use self::ParseFloatError as PFE; + + // Special values + match src { + "inf" => return Ok(Float::infinity()), + "-inf" => return Ok(Float::neg_infinity()), + "NaN" => return Ok(Float::nan()), + _ => {}, + } + + fn slice_shift_char(src: &str) -> Option<(char, &str)> { + src.chars().nth(0).map(|ch| (ch, &src[1..])) + } + + let (is_positive, src) = match slice_shift_char(src) { + None => return Err(PFE { kind: Empty }), + Some(('-', "")) => return Err(PFE { kind: Empty }), + Some(('-', src)) => (false, src), + Some((_, _)) => (true, src), + }; + + // The significand to accumulate + let mut sig = if is_positive { 0.0 } else { -0.0 }; + // Necessary to detect overflow + let mut prev_sig = sig; + let mut cs = src.chars().enumerate(); + // Exponent prefix and exponent index offset + let mut exp_info = None::<(char, usize)>; + + // Parse the integer part of the significand + for (i, c) in cs.by_ref() { + match c.to_digit(radix) { + Some(digit) => { + // shift significand one digit left + sig = sig * (radix as $t); + + // add/subtract current digit depending on sign + if is_positive { + sig = sig + ((digit as isize) as $t); + } else { + sig = sig - ((digit as isize) as $t); + } + + // Detect overflow by comparing to last value, except + // if we've not seen any non-zero digits. + if prev_sig != 0.0 { + if is_positive && sig <= prev_sig + { return Ok(Float::infinity()); } + if !is_positive && sig >= prev_sig + { return Ok(Float::neg_infinity()); } + + // Detect overflow by reversing the shift-and-add process + if is_positive && (prev_sig != (sig - digit as $t) / radix as $t) + { return Ok(Float::infinity()); } + if !is_positive && (prev_sig != (sig + digit as $t) / radix as $t) + { return Ok(Float::neg_infinity()); } + } + prev_sig = sig; + }, + None => match c { + 'e' | 'E' | 'p' | 'P' => { + exp_info = Some((c, i + 1)); + break; // start of exponent + }, + '.' => { + break; // start of fractional part + }, + _ => { + return Err(PFE { kind: Invalid }); + }, + }, + } + } + + // If we are not yet at the exponent parse the fractional + // part of the significand + if exp_info.is_none() { + let mut power = 1.0; + for (i, c) in cs.by_ref() { + match c.to_digit(radix) { + Some(digit) => { + // Decrease power one order of magnitude + power = power / (radix as $t); + // add/subtract current digit depending on sign + sig = if is_positive { + sig + (digit as $t) * power + } else { + sig - (digit as $t) * power + }; + // Detect overflow by comparing to last value + if is_positive && sig < prev_sig + { return Ok(Float::infinity()); } + if !is_positive && sig > prev_sig + { return Ok(Float::neg_infinity()); } + prev_sig = sig; + }, + None => match c { + 'e' | 'E' | 'p' | 'P' => { + exp_info = Some((c, i + 1)); + break; // start of exponent + }, + _ => { + return Err(PFE { kind: Invalid }); + }, + }, + } + } + } + + // Parse and calculate the exponent + let exp = match exp_info { + Some((c, offset)) => { + let base = match c { + 'E' | 'e' if radix == 10 => 10.0, + 'P' | 'p' if radix == 16 => 2.0, + _ => return Err(PFE { kind: Invalid }), + }; + + // Parse the exponent as decimal integer + let src = &src[offset..]; + let (is_positive, exp) = match slice_shift_char(src) { + Some(('-', src)) => (false, src.parse::()), + Some(('+', src)) => (true, src.parse::()), + Some((_, _)) => (true, src.parse::()), + None => return Err(PFE { kind: Invalid }), + }; + + match (is_positive, exp) { + (true, Ok(exp)) => base.powi(exp as i32), + (false, Ok(exp)) => 1.0 / base.powi(exp as i32), + (_, Err(_)) => return Err(PFE { kind: Invalid }), + } + }, + None => 1.0, // no exponent + }; + + Ok(sig * exp) + } + } + )*) +} +float_trait_impl!(Num for f32 f64); + +#[test] +fn from_str_radix_unwrap() { + // The Result error must impl Debug to allow unwrap() + + let i: i32 = Num::from_str_radix("0", 10).unwrap(); + assert_eq!(i, 0); + + let f: f32 = Num::from_str_radix("0.0", 10).unwrap(); + assert_eq!(f, 0.0); +} diff --git a/traits/src/ops/checked.rs b/traits/src/ops/checked.rs new file mode 100644 index 0000000..b6bf0d6 --- /dev/null +++ b/traits/src/ops/checked.rs @@ -0,0 +1,91 @@ +use std::ops::{Add, Sub, Mul, Div}; + +/// Performs addition that returns `None` instead of wrapping around on +/// overflow. +pub trait CheckedAdd: Sized + Add { + /// Adds two numbers, checking for overflow. If overflow happens, `None` is + /// returned. + fn checked_add(&self, v: &Self) -> Option; +} + +macro_rules! checked_impl { + ($trait_name:ident, $method:ident, $t:ty) => { + impl $trait_name for $t { + #[inline] + fn $method(&self, v: &$t) -> Option<$t> { + <$t>::$method(*self, *v) + } + } + } +} + +checked_impl!(CheckedAdd, checked_add, u8); +checked_impl!(CheckedAdd, checked_add, u16); +checked_impl!(CheckedAdd, checked_add, u32); +checked_impl!(CheckedAdd, checked_add, u64); +checked_impl!(CheckedAdd, checked_add, usize); + +checked_impl!(CheckedAdd, checked_add, i8); +checked_impl!(CheckedAdd, checked_add, i16); +checked_impl!(CheckedAdd, checked_add, i32); +checked_impl!(CheckedAdd, checked_add, i64); +checked_impl!(CheckedAdd, checked_add, isize); + +/// Performs subtraction that returns `None` instead of wrapping around on underflow. +pub trait CheckedSub: Sized + Sub { + /// Subtracts two numbers, checking for underflow. If underflow happens, + /// `None` is returned. + fn checked_sub(&self, v: &Self) -> Option; +} + +checked_impl!(CheckedSub, checked_sub, u8); +checked_impl!(CheckedSub, checked_sub, u16); +checked_impl!(CheckedSub, checked_sub, u32); +checked_impl!(CheckedSub, checked_sub, u64); +checked_impl!(CheckedSub, checked_sub, usize); + +checked_impl!(CheckedSub, checked_sub, i8); +checked_impl!(CheckedSub, checked_sub, i16); +checked_impl!(CheckedSub, checked_sub, i32); +checked_impl!(CheckedSub, checked_sub, i64); +checked_impl!(CheckedSub, checked_sub, isize); + +/// Performs multiplication that returns `None` instead of wrapping around on underflow or +/// overflow. +pub trait CheckedMul: Sized + Mul { + /// Multiplies two numbers, checking for underflow or overflow. If underflow + /// or overflow happens, `None` is returned. + fn checked_mul(&self, v: &Self) -> Option; +} + +checked_impl!(CheckedMul, checked_mul, u8); +checked_impl!(CheckedMul, checked_mul, u16); +checked_impl!(CheckedMul, checked_mul, u32); +checked_impl!(CheckedMul, checked_mul, u64); +checked_impl!(CheckedMul, checked_mul, usize); + +checked_impl!(CheckedMul, checked_mul, i8); +checked_impl!(CheckedMul, checked_mul, i16); +checked_impl!(CheckedMul, checked_mul, i32); +checked_impl!(CheckedMul, checked_mul, i64); +checked_impl!(CheckedMul, checked_mul, isize); + +/// Performs division that returns `None` instead of panicking on division by zero and instead of +/// wrapping around on underflow and overflow. +pub trait CheckedDiv: Sized + Div { + /// Divides two numbers, checking for underflow, overflow and division by + /// zero. If any of that happens, `None` is returned. + fn checked_div(&self, v: &Self) -> Option; +} + +checked_impl!(CheckedDiv, checked_div, u8); +checked_impl!(CheckedDiv, checked_div, u16); +checked_impl!(CheckedDiv, checked_div, u32); +checked_impl!(CheckedDiv, checked_div, u64); +checked_impl!(CheckedDiv, checked_div, usize); + +checked_impl!(CheckedDiv, checked_div, i8); +checked_impl!(CheckedDiv, checked_div, i16); +checked_impl!(CheckedDiv, checked_div, i32); +checked_impl!(CheckedDiv, checked_div, i64); +checked_impl!(CheckedDiv, checked_div, isize); diff --git a/traits/src/ops/mod.rs b/traits/src/ops/mod.rs new file mode 100644 index 0000000..2632a0f --- /dev/null +++ b/traits/src/ops/mod.rs @@ -0,0 +1,2 @@ +pub mod saturating; +pub mod checked; diff --git a/traits/src/ops/saturating.rs b/traits/src/ops/saturating.rs new file mode 100644 index 0000000..15f06b7 --- /dev/null +++ b/traits/src/ops/saturating.rs @@ -0,0 +1,26 @@ +/// Saturating math operations +pub trait Saturating { + /// Saturating addition operator. + /// Returns a+b, saturating at the numeric bounds instead of overflowing. + fn saturating_add(self, v: Self) -> Self; + + /// Saturating subtraction operator. + /// Returns a-b, saturating at the numeric bounds instead of overflowing. + fn saturating_sub(self, v: Self) -> Self; +} + +macro_rules! saturating_impl { + ($trait_name:ident for $($t:ty)*) => {$( + impl $trait_name for $t { + fn saturating_add(self, v: Self) -> Self { + Self::saturating_add(self, v) + } + + fn saturating_sub(self, v: Self) -> Self { + Self::saturating_sub(self, v) + } + } + )*} +} + +saturating_impl!(Saturating for isize usize i8 u8 i16 u16 i32 u32 i64 u64); diff --git a/traits/src/sign.rs b/traits/src/sign.rs new file mode 100644 index 0000000..ae1d38c --- /dev/null +++ b/traits/src/sign.rs @@ -0,0 +1,126 @@ +use std::ops::Neg; +use std::{f32, f64}; + +use Num; + +/// Useful functions for signed numbers (i.e. numbers that can be negative). +pub trait Signed: Sized + Num + Neg { + /// Computes the absolute value. + /// + /// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`. + /// + /// For signed integers, `::MIN` will be returned if the number is `::MIN`. + fn abs(&self) -> Self; + + /// The positive difference of two numbers. + /// + /// Returns `zero` if the number is less than or equal to `other`, otherwise the difference + /// between `self` and `other` is returned. + fn abs_sub(&self, other: &Self) -> Self; + + /// Returns the sign of the number. + /// + /// For `f32` and `f64`: + /// + /// * `1.0` if the number is positive, `+0.0` or `INFINITY` + /// * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` + /// * `NaN` if the number is `NaN` + /// + /// For signed integers: + /// + /// * `0` if the number is zero + /// * `1` if the number is positive + /// * `-1` if the number is negative + fn signum(&self) -> Self; + + /// Returns true if the number is positive and false if the number is zero or negative. + fn is_positive(&self) -> bool; + + /// Returns true if the number is negative and false if the number is zero or positive. + fn is_negative(&self) -> bool; +} + +macro_rules! signed_impl { + ($($t:ty)*) => ($( + impl Signed for $t { + #[inline] + fn abs(&self) -> $t { + if self.is_negative() { -*self } else { *self } + } + + #[inline] + fn abs_sub(&self, other: &$t) -> $t { + if *self <= *other { 0 } else { *self - *other } + } + + #[inline] + fn signum(&self) -> $t { + match *self { + n if n > 0 => 1, + 0 => 0, + _ => -1, + } + } + + #[inline] + fn is_positive(&self) -> bool { *self > 0 } + + #[inline] + fn is_negative(&self) -> bool { *self < 0 } + } + )*) +} + +signed_impl!(isize i8 i16 i32 i64); + +macro_rules! signed_float_impl { + ($t:ty, $nan:expr, $inf:expr, $neg_inf:expr) => { + impl Signed for $t { + /// Computes the absolute value. Returns `NAN` if the number is `NAN`. + #[inline] + fn abs(&self) -> $t { + <$t>::abs(*self) + } + + /// The positive difference of two numbers. Returns `0.0` if the number is + /// less than or equal to `other`, otherwise the difference between`self` + /// and `other` is returned. + #[inline] + fn abs_sub(&self, other: &$t) -> $t { + <$t>::abs_sub(*self, *other) + } + + /// # Returns + /// + /// - `1.0` if the number is positive, `+0.0` or `INFINITY` + /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` + /// - `NAN` if the number is NaN + #[inline] + fn signum(&self) -> $t { + <$t>::signum(*self) + } + + /// Returns `true` if the number is positive, including `+0.0` and `INFINITY` + #[inline] + fn is_positive(&self) -> bool { *self > 0.0 || (1.0 / *self) == $inf } + + /// Returns `true` if the number is negative, including `-0.0` and `NEG_INFINITY` + #[inline] + fn is_negative(&self) -> bool { *self < 0.0 || (1.0 / *self) == $neg_inf } + } + } +} + +signed_float_impl!(f32, f32::NAN, f32::INFINITY, f32::NEG_INFINITY); +signed_float_impl!(f64, f64::NAN, f64::INFINITY, f64::NEG_INFINITY); + +/// A trait for values which cannot be negative +pub trait Unsigned: Num {} + +macro_rules! empty_trait_impl { + ($name:ident for $($t:ty)*) => ($( + impl $name for $t {} + )*) +} + +empty_trait_impl!(Unsigned for usize u8 u16 u32 u64);