xeos
/
num-traits
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Auto merge of #164 - rust-num:split-into-crates, r=cuviper 

Move segments of library to separate crates

Issue #102

- [x] traits
- [x] bigint
- [x] integer
- [x] complex
- [x] iter
- [x] rational
This commit is contained in:
Homu 2016-04-14 05:30:34 +09:00
parent 7eb666f6b8 58b5fe5883
commit 095738e7de
32 changed files with 3829 additions and 3355 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.multirust.sh
View File

@ -7,7 +7,7 @@ set -ex
for toolchain in 1.0.0 beta nightly; do for toolchain in 1.0.0 beta nightly; do
run="multirust run $toolchain" run="multirust run $toolchain"
$run cargo build --verbose $run cargo build --verbose
$run cargo test --verbose $run make test
$run .travis/test_features.sh $run .travis/test_features.sh
if [ $toolchain = nightly ]; then if [ $toolchain = nightly ]; then
$run .travis/test_nightly.sh $run .travis/test_nightly.sh

5
.travis.yml
View File

@ -6,11 +6,10 @@ rust:
sudo: false sudo: false
script: script:
- cargo build --verbose - cargo build --verbose
- cargo test --verbose - make test
- .travis/test_features.sh - .travis/test_features.sh
- | - |
[ $TRAVIS_RUST_VERSION != nightly ] || [ $TRAVIS_RUST_VERSION != nightly ] || .travis/test_nightly.sh
.travis/test_nightly.sh
- cargo doc - cargo doc
after_success: | after_success: |
[ $TRAVIS_BRANCH = master ] && [ $TRAVIS_BRANCH = master ] &&

2
.travis/test_features.sh
View File

@ -4,6 +4,4 @@ set -ex
for feature in '' bigint rational complex; do for feature in '' bigint rational complex; do
cargo build --verbose --no-default-features --features="$feature" cargo build --verbose --no-default-features --features="$feature"
cargo test --verbose --no-default-features --features="$feature"
done done

2
.travis/test_nightly.sh
View File

@ -4,4 +4,4 @@ set -ex
cargo bench --verbose cargo bench --verbose
cargo test --verbose --manifest-path=num-macros/Cargo.toml cargo test --verbose --manifest-path=macros/Cargo.toml

83
Cargo.toml
View File

@ -1,38 +1,63 @@
[package] [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" name = "num"
version = "0.1.31" 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]] [[bench]]
name = "bigint" name = "bigint"
[[bench]] [[bench]]
name = "shootout-pidigits"
harness = false 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"
]

14
Makefile Normal file
View File

@ -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

33
bigint/Cargo.toml Normal file
View File

@ -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"]

1278
src/bigint.rs → bigint/src/lib.rs
View File

File diff suppressed because it is too large Load Diff

28
complex/Cargo.toml Normal file
View File

@ -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 = []

25
src/complex.rs → complex/src/lib.rs
View File

@ -8,16 +8,25 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
//! Complex numbers. //! 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; use std::fmt;
#[cfg(test)]
use std::hash;
use std::ops::{Add, Div, Mul, Neg, Sub}; use std::ops::{Add, Div, Mul, Neg, Sub};
#[cfg(feature = "serde")] #[cfg(feature = "serde")]
use serde; use serde;
use {Zero, One, Num, Float}; use traits::{Zero, One, Num, Float};
// FIXME #1284: handle complex NaN & infinity etc. This // FIXME #1284: handle complex NaN & infinity etc. This
// probably doesn't map to C's _Complex correctly. // probably doesn't map to C's _Complex correctly.
@ -593,6 +602,14 @@ impl<T> serde::Deserialize for Complex<T> where
} }
} }
#[cfg(test)]
fn hash<T: hash::Hash>(x: &T) -> u64 {
use std::hash::Hasher;
let mut hasher = hash::SipHasher::new();
x.hash(&mut hasher);
hasher.finish()
}
#[cfg(test)] #[cfg(test)]
mod test { mod test {
#![allow(non_upper_case_globals)] #![allow(non_upper_case_globals)]
@ -600,7 +617,7 @@ mod test {
use super::{Complex64, Complex}; use super::{Complex64, Complex};
use std::f64; 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 _0_0i : Complex64 = Complex { re: 0.0, im: 0.0 };
pub const _1_0i : Complex64 = Complex { re: 1.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 { mod complex_arithmetic {
use super::{_0_0i, _1_0i, _1_1i, _0_1i, _neg1_1i, _05_05i, all_consts}; use super::{_0_0i, _1_0i, _1_1i, _0_1i, _neg1_1i, _05_05i, all_consts};
use Zero; use traits::Zero;
#[test] #[test]
fn test_add() { fn test_add() {

13
integer/Cargo.toml Normal file
View File

@ -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"

130
src/integer.rs → integer/src/lib.rs
View File

@ -10,17 +10,17 @@
//! Integer trait and functions. //! Integer trait and functions.
use {Num, Signed}; extern crate num_traits as traits;
pub trait Integer use traits::{Num, Signed};
: Sized + Num + Ord
{ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
/// Floored integer division. /// Floored integer division.
/// ///
/// # Examples /// # Examples
/// ///
/// ~~~ /// ~~~
/// # use num::Integer; /// # use num_integer::Integer;
/// assert!(( 8).div_floor(& 3) == 2); /// assert!(( 8).div_floor(& 3) == 2);
/// assert!(( 8).div_floor(&-3) == -3); /// assert!(( 8).div_floor(&-3) == -3);
/// assert!((-8).div_floor(& 3) == -3); /// assert!((-8).div_floor(& 3) == -3);
@ -36,7 +36,7 @@ pub trait Integer
/// Floored integer modulo, satisfying: /// Floored integer modulo, satisfying:
/// ///
/// ~~~ /// ~~~
/// # use num::Integer; /// # use num_integer::Integer;
/// # let n = 1; let d = 1; /// # let n = 1; let d = 1;
/// assert!(n.div_floor(&d) * d + n.mod_floor(&d) == n) /// assert!(n.div_floor(&d) * d + n.mod_floor(&d) == n)
/// ~~~ /// ~~~
@ -44,7 +44,7 @@ pub trait Integer
/// # Examples /// # Examples
/// ///
/// ~~~ /// ~~~
/// # use num::Integer; /// # use num_integer::Integer;
/// assert!(( 8).mod_floor(& 3) == 2); /// assert!(( 8).mod_floor(& 3) == 2);
/// assert!(( 8).mod_floor(&-3) == -1); /// assert!(( 8).mod_floor(&-3) == -1);
/// assert!((-8).mod_floor(& 3) == 1); /// assert!((-8).mod_floor(& 3) == 1);
@ -62,7 +62,7 @@ pub trait Integer
/// # Examples /// # Examples
/// ///
/// ~~~ /// ~~~
/// # use num::Integer; /// # use num_integer::Integer;
/// assert_eq!(6.gcd(&8), 2); /// assert_eq!(6.gcd(&8), 2);
/// assert_eq!(7.gcd(&3), 1); /// assert_eq!(7.gcd(&3), 1);
/// ~~~ /// ~~~
@ -73,7 +73,7 @@ pub trait Integer
/// # Examples /// # Examples
/// ///
/// ~~~ /// ~~~
/// # use num::Integer; /// # use num_integer::Integer;
/// assert_eq!(7.lcm(&3), 21); /// assert_eq!(7.lcm(&3), 21);
/// assert_eq!(2.lcm(&4), 4); /// assert_eq!(2.lcm(&4), 4);
/// ~~~ /// ~~~
@ -87,7 +87,7 @@ pub trait Integer
/// # Examples /// # Examples
/// ///
/// ~~~ /// ~~~
/// # use num::Integer; /// # use num_integer::Integer;
/// assert_eq!(9.is_multiple_of(&3), true); /// assert_eq!(9.is_multiple_of(&3), true);
/// assert_eq!(3.is_multiple_of(&9), false); /// assert_eq!(3.is_multiple_of(&9), false);
/// ~~~ /// ~~~
@ -98,7 +98,7 @@ pub trait Integer
/// # Examples /// # Examples
/// ///
/// ~~~ /// ~~~
/// # use num::Integer; /// # use num_integer::Integer;
/// assert_eq!(3.is_even(), false); /// assert_eq!(3.is_even(), false);
/// assert_eq!(4.is_even(), true); /// assert_eq!(4.is_even(), true);
/// ~~~ /// ~~~
@ -109,7 +109,7 @@ pub trait Integer
/// # Examples /// # Examples
/// ///
/// ~~~ /// ~~~
/// # use num::Integer; /// # use num_integer::Integer;
/// assert_eq!(3.is_odd(), true); /// assert_eq!(3.is_odd(), true);
/// assert_eq!(4.is_odd(), false); /// assert_eq!(4.is_odd(), false);
/// ~~~ /// ~~~
@ -121,7 +121,7 @@ pub trait Integer
/// # Examples /// # 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)); /// 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 /// # Examples
/// ///
/// ~~~ /// ~~~
/// # use num::Integer; /// # use num_integer::Integer;
/// assert_eq!(( 8).div_mod_floor( &3), ( 2, 2)); /// 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));
/// 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 /// Simultaneous integer division and modulus
#[inline] pub fn div_rem<T: Integer>(x: T, y: T) -> (T, T) { x.div_rem(&y) } #[inline]
pub fn div_rem<T: Integer>(x: T, y: T) -> (T, T) {
x.div_rem(&y)
}
/// Floored integer division /// Floored integer division
#[inline] pub fn div_floor<T: Integer>(x: T, y: T) -> T { x.div_floor(&y) } #[inline]
pub fn div_floor<T: Integer>(x: T, y: T) -> T {
x.div_floor(&y)
}
/// Floored integer modulus /// Floored integer modulus
#[inline] pub fn mod_floor<T: Integer>(x: T, y: T) -> T { x.mod_floor(&y) } #[inline]
pub fn mod_floor<T: Integer>(x: T, y: T) -> T {
x.mod_floor(&y)
}
/// Simultaneous floored integer division and modulus /// Simultaneous floored integer division and modulus
#[inline] pub fn div_mod_floor<T: Integer>(x: T, y: T) -> (T, T) { x.div_mod_floor(&y) } #[inline]
pub fn div_mod_floor<T: Integer>(x: T, y: T) -> (T, T) {
x.div_mod_floor(&y)
}
/// Calculates the Greatest Common Divisor (GCD) of the number and `other`. The /// Calculates the Greatest Common Divisor (GCD) of the number and `other`. The
/// result is always positive. /// result is always positive.
#[inline(always)] pub fn gcd<T: Integer>(x: T, y: T) -> T { x.gcd(&y) } #[inline(always)]
pub fn gcd<T: Integer>(x: T, y: T) -> T {
x.gcd(&y)
}
/// Calculates the Lowest Common Multiple (LCM) of the number and `other`. /// Calculates the Lowest Common Multiple (LCM) of the number and `other`.
#[inline(always)] pub fn lcm<T: Integer>(x: T, y: T) -> T { x.lcm(&y) } #[inline(always)]
pub fn lcm<T: Integer>(x: T, y: T) -> T {
x.lcm(&y)
}
macro_rules! impl_integer_for_isize { macro_rules! impl_integer_for_isize {
($T:ty, $test_mod:ident) => ( ($T:ty, $test_mod:ident) => (
impl Integer for $T { impl Integer for $T {
/// Floored integer division /// Floored integer division
#[inline] #[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_, // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_,
// December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf) // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf)
match self.div_rem(other) { match self.div_rem(other) {
@ -189,7 +207,7 @@ macro_rules! impl_integer_for_isize {
/// Floored integer modulo /// Floored integer modulo
#[inline] #[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_, // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_,
// December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf) // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf)
match *self % *other { match *self % *other {
@ -201,7 +219,7 @@ macro_rules! impl_integer_for_isize {
/// Calculates `div_floor` and `mod_floor` simultaneously /// Calculates `div_floor` and `mod_floor` simultaneously
#[inline] #[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_, // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_,
// December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf) // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf)
match self.div_rem(other) { 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 /// Calculates the Greatest Common Divisor (GCD) of the number and
/// `other`. The result is always positive. /// `other`. The result is always positive.
#[inline] #[inline]
fn gcd(&self, other: &$T) -> $T { fn gcd(&self, other: &Self) -> Self {
// Use Stein's algorithm // Use Stein's algorithm
let mut m = *self; let mut m = *self;
let mut n = *other; let mut n = *other;
@ -231,7 +249,7 @@ macro_rules! impl_integer_for_isize {
// Assuming two's complement, the number created by the shift // Assuming two's complement, the number created by the shift
// is positive for all numbers except gcd = abs(min value) // is positive for all numbers except gcd = abs(min value)
// The call to .abs() causes a panic in debug mode // 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() return (1 << shift).abs()
} }
@ -255,18 +273,22 @@ macro_rules! impl_integer_for_isize {
/// Calculates the Lowest Common Multiple (LCM) of the number and /// Calculates the Lowest Common Multiple (LCM) of the number and
/// `other`. /// `other`.
#[inline] #[inline]
fn lcm(&self, other: &$T) -> $T { fn lcm(&self, other: &Self) -> Self {
// should not have to recalculate abs // should not have to recalculate abs
(*self * (*other / self.gcd(other))).abs() (*self * (*other / self.gcd(other))).abs()
} }
/// Deprecated, use `is_multiple_of` instead. /// Deprecated, use `is_multiple_of` instead.
#[inline] #[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`. /// Returns `true` if the number is a multiple of `other`.
#[inline] #[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` /// Returns `true` if the number is divisible by `2`
#[inline] #[inline]
@ -278,7 +300,7 @@ macro_rules! impl_integer_for_isize {
/// Simultaneous truncated integer division and modulus. /// Simultaneous truncated integer division and modulus.
#[inline] #[inline]
fn div_rem(&self, other: &$T) -> ($T, $T) { fn div_rem(&self, other: &Self) -> (Self, Self) {
(*self / *other, *self % *other) (*self / *other, *self % *other)
} }
} }
@ -293,7 +315,7 @@ macro_rules! impl_integer_for_isize {
/// - `d`: denominator (divisor) /// - `d`: denominator (divisor)
/// - `qr`: quotient and remainder /// - `qr`: quotient and remainder
#[cfg(test)] #[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); 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!(i8, test_integer_i8);
impl_integer_for_isize!(i16, test_integer_i16); impl_integer_for_isize!(i16, test_integer_i16);
impl_integer_for_isize!(i32, test_integer_i32); impl_integer_for_isize!(i32, test_integer_i32);
impl_integer_for_isize!(i64, test_integer_i64); impl_integer_for_isize!(i64, test_integer_i64);
impl_integer_for_isize!(isize, test_integer_isize); impl_integer_for_isize!(isize, test_integer_isize);
macro_rules! impl_integer_for_usize { macro_rules! impl_integer_for_usize {
($T:ty, $test_mod:ident) => ( ($T:ty, $test_mod:ident) => (
impl Integer for $T { impl Integer for $T {
/// Unsigned integer division. Returns the same result as `div` (`/`). /// Unsigned integer division. Returns the same result as `div` (`/`).
#[inline] #[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` (`%`). /// Unsigned integer modulo operation. Returns the same result as `rem` (`%`).
#[inline] #[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` /// Calculates the Greatest Common Divisor (GCD) of the number and `other`
#[inline] #[inline]
fn gcd(&self, other: &$T) -> $T { fn gcd(&self, other: &Self) -> Self {
// Use Stein's algorithm // Use Stein's algorithm
let mut m = *self; let mut m = *self;
let mut n = *other; 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`. /// Calculates the Lowest Common Multiple (LCM) of the number and `other`.
#[inline] #[inline]
fn lcm(&self, other: &$T) -> $T { fn lcm(&self, other: &Self) -> Self {
*self * (*other / self.gcd(other)) *self * (*other / self.gcd(other))
} }
/// Deprecated, use `is_multiple_of` instead. /// Deprecated, use `is_multiple_of` instead.
#[inline] #[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`. /// Returns `true` if the number is a multiple of `other`.
#[inline] #[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`. /// Returns `true` if the number is divisible by `2`.
#[inline] #[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`. /// Returns `true` if the number is not divisible by `2`.
#[inline] #[inline]
fn is_odd(&self) -> bool { !(*self).is_even() } fn is_odd(&self) -> bool {
!self.is_even()
}
/// Simultaneous truncated integer division and modulus. /// Simultaneous truncated integer division and modulus.
#[inline] #[inline]
fn div_rem(&self, other: &$T) -> ($T, $T) { fn div_rem(&self, other: &Self) -> (Self, Self) {
(*self / *other, *self % *other) (*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!(u8, test_integer_u8);
impl_integer_for_usize!(u16, test_integer_u16); impl_integer_for_usize!(u16, test_integer_u16);
impl_integer_for_usize!(u32, test_integer_u32); impl_integer_for_usize!(u32, test_integer_u32);
impl_integer_for_usize!(u64, test_integer_u64); impl_integer_for_usize!(u64, test_integer_u64);
impl_integer_for_usize!(usize, test_integer_usize); impl_integer_for_usize!(usize, test_integer_usize);
#[test] #[test]

20
iter/Cargo.toml Normal file
View File

@ -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"

12
src/iter.rs → iter/src/lib.rs
View File

@ -10,7 +10,11 @@
//! External iterators for generic mathematics //! 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}; use std::ops::{Add, Sub};
/// An iterator over the range [start, stop) /// An iterator over the range [start, stop)
@ -27,11 +31,9 @@ pub struct Range<A> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// use num::iter;
///
/// let array = [0, 1, 2, 3, 4]; /// let array = [0, 1, 2, 3, 4];
/// ///
/// for i in iter::range(0, 5) { /// for i in num_iter::range(0, 5) {
/// println!("{}", i); /// println!("{}", i);
/// assert_eq!(i, array[i]); /// assert_eq!(i, array[i]);
/// } /// }
@ -261,7 +263,7 @@ mod tests {
use std::usize; use std::usize;
use std::ops::{Add, Mul}; use std::ops::{Add, Mul};
use std::cmp::Ordering; use std::cmp::Ordering;
use {One, ToPrimitive}; use traits::{One, ToPrimitive};
#[test] #[test]
fn test_range() { fn test_range() {

4
num-macros/Cargo.toml → macros/Cargo.toml
View File

@ -7,9 +7,7 @@ homepage = "https://github.com/rust-num/num"
repository = "https://github.com/rust-num/num" repository = "https://github.com/rust-num/num"
documentation = "http://rust-num.github.io/num" documentation = "http://rust-num.github.io/num"
keywords = ["mathematics", "numerics"] keywords = ["mathematics", "numerics"]
description = """ description = "Numeric syntax extensions"
Numeric syntax extensions.
"""
[lib] [lib]
name = "num_macros" name = "num_macros"

0
num-macros/src/lib.rs → macros/src/lib.rs
View File

0
num-macros/tests/test_macro.rs → macros/tests/test_macro.rs
View File

34
rational/Cargo.toml Normal file
View File

@ -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"]

301
src/rational.rs → rational/src/lib.rs
View File

@ -10,21 +10,32 @@
//! Rational numbers //! 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::cmp;
use std::error::Error; use std::error::Error;
use std::fmt; use std::fmt;
#[cfg(test)]
use std::hash;
use std::ops::{Add, Div, Mul, Neg, Rem, Sub}; use std::ops::{Add, Div, Mul, Neg, Rem, Sub};
use std::str::FromStr; use std::str::FromStr;
#[cfg(feature = "serde")] #[cfg(feature = "serde")]
use serde; use serde;
#[cfg(feature = "bigint")] #[cfg(feature = "num-bigint")]
use bigint::{BigInt, BigUint, Sign}; 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. /// Represents the ratio between 2 numbers.
#[derive(Copy, Clone, Hash, Debug)] #[derive(Copy, Clone, Hash, Debug)]
@ -32,7 +43,7 @@ use {Num, Signed, Zero, One};
#[allow(missing_docs)] #[allow(missing_docs)]
pub struct Ratio<T> { pub struct Ratio<T> {
numer: T, numer: T,
denom: T denom: T,
} }
/// Alias for a `Ratio` of machine-sized integers. /// Alias for a `Ratio` of machine-sized integers.
@ -40,7 +51,7 @@ pub type Rational = Ratio<isize>;
pub type Rational32 = Ratio<i32>; pub type Rational32 = Ratio<i32>;
pub type Rational64 = Ratio<i64>; pub type Rational64 = Ratio<i64>;
#[cfg(feature = "bigint")] #[cfg(feature = "num-bigint")]
/// Alias for arbitrary precision rationals. /// Alias for arbitrary precision rationals.
pub type BigRational = Ratio<BigInt>; pub type BigRational = Ratio<BigInt>;
@ -54,7 +65,10 @@ impl<T: Clone + Integer> Ratio<T> {
/// Creates a ratio without checking for `denom == 0` or reducing. /// Creates a ratio without checking for `denom == 0` or reducing.
#[inline] #[inline]
pub fn new_raw(numer: T, denom: T) -> Ratio<T> { pub fn new_raw(numer: T, denom: T) -> Ratio<T> {
Ratio { numer: numer, denom: denom } Ratio {
numer: numer,
denom: denom,
}
} }
/// Create a new Ratio. Fails if `denom == 0`. /// Create a new Ratio. Fails if `denom == 0`.
@ -94,7 +108,7 @@ impl<T: Clone + Integer> Ratio<T> {
/// Put self into lowest terms, with denom > 0. /// Put self into lowest terms, with denom > 0.
fn reduce(&mut self) { 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 // FIXME(#5992): assignment operator overloads
// self.numer /= g; // self.numer /= g;
@ -128,7 +142,8 @@ impl<T: Clone + Integer> Ratio<T> {
pub fn floor(&self) -> Ratio<T> { pub fn floor(&self) -> Ratio<T> {
if *self < Zero::zero() { if *self < Zero::zero() {
let one: T = One::one(); 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 { } else {
Ratio::from_integer(self.numer.clone() / self.denom.clone()) Ratio::from_integer(self.numer.clone() / self.denom.clone())
} }
@ -141,7 +156,8 @@ impl<T: Clone + Integer> Ratio<T> {
Ratio::from_integer(self.numer.clone() / self.denom.clone()) Ratio::from_integer(self.numer.clone() / self.denom.clone())
} else { } else {
let one: T = One::one(); 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<T: Clone + Integer> Ratio<T> {
// Find unsigned fractional part of rational number // Find unsigned fractional part of rational number
let mut fractional = self.fract(); 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 // 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 // is, a/b >= 1/2, or a >= b/2. For odd denominators, we use
@ -197,13 +215,14 @@ impl<T: Clone + Integer + PrimInt> Ratio<T> {
match expon.cmp(&0) { match expon.cmp(&0) {
cmp::Ordering::Equal => One::one(), cmp::Ordering::Equal => One::one(),
cmp::Ordering::Less => self.recip().pow(-expon), cmp::Ordering::Less => self.recip().pow(-expon),
cmp::Ordering::Greater => Ratio::new_raw(self.numer.pow(expon as u32), cmp::Ordering::Greater => {
self.denom.pow(expon as u32)), Ratio::new_raw(self.numer.pow(expon as u32), self.denom.pow(expon as u32))
}
} }
} }
} }
#[cfg(feature = "bigint")] #[cfg(feature = "num-bigint")]
impl Ratio<BigInt> { impl Ratio<BigInt> {
/// Converts a float into a rational number. /// Converts a float into a rational number.
pub fn from_float<T: Float>(f: T) -> Option<BigRational> { pub fn from_float<T: Float>(f: T) -> Option<BigRational> {
@ -211,7 +230,11 @@ impl Ratio<BigInt> {
return None; return None;
} }
let (mantissa, exponent, sign) = f.integer_decode(); 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 { if exponent < 0 {
let one: BigInt = One::one(); let one: BigInt = One::one();
let denom: BigInt = one << ((-exponent) as usize); let denom: BigInt = one << ((-exponent) as usize);
@ -225,7 +248,7 @@ impl Ratio<BigInt> {
} }
} }
/* Comparisons */ // Comparisons
// Mathematically, comparing a/b and c/d is the same as comparing a*d and b*c, but it's very easy // 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. // for those multiplications to overflow fixed-size integers, so we need to take care.
@ -236,13 +259,21 @@ impl<T: Clone + Integer> Ord for Ratio<T> {
// With equal denominators, the numerators can be directly compared // With equal denominators, the numerators can be directly compared
if self.denom == other.denom { if self.denom == other.denom {
let ord = self.numer.cmp(&other.numer); 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 // With equal numerators, the denominators can be inversely compared
if self.numer == other.numer { if self.numer == other.numer {
let ord = self.denom.cmp(&other.denom); 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 // Unfortunately, we don't have CheckedMul to try. That could sometimes avoid all the
@ -267,7 +298,7 @@ impl<T: Clone + Integer> Ord for Ratio<T> {
self_recip.cmp(&other_recip).reverse() self_recip.cmp(&other_recip).reverse()
} }
} }
}, }
} }
} }
} }
@ -340,17 +371,17 @@ macro_rules! forward_all_binop {
}; };
} }
/* Arithmetic */ // Arithmetic
forward_all_binop!(impl Mul, mul); forward_all_binop!(impl Mul, mul);
// a/b * c/d = (a*c)/(b*d) // a/b * c/d = (a*c)/(b*d)
impl<'a, 'b, T> Mul<&'b Ratio<T>> for &'a Ratio<T> impl<'a, 'b, T> Mul<&'b Ratio<T>> for &'a Ratio<T>
where T: Clone + Integer where T: Clone + Integer
{ {
type Output = Ratio<T>;
type Output = Ratio<T>;
#[inline] #[inline]
fn mul(self, rhs: &Ratio<T>) -> Ratio<T> { fn mul(self, rhs: &Ratio<T>) -> Ratio<T> {
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<T>> for &'a Ratio<T>
#[inline] #[inline]
fn div(self, rhs: &Ratio<T>) -> Ratio<T> { fn div(self, rhs: &Ratio<T>) -> Ratio<T> {
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<T>
} }
} }
/* Constants */ // Constants
impl<T: Clone + Integer> impl<T: Clone + Integer> Zero for Ratio<T> {
Zero for Ratio<T> {
#[inline] #[inline]
fn zero() -> Ratio<T> { fn zero() -> Ratio<T> {
Ratio::new_raw(Zero::zero(), One::one()) Ratio::new_raw(Zero::zero(), One::one())
@ -428,8 +459,7 @@ impl<T: Clone + Integer>
} }
} }
impl<T: Clone + Integer> impl<T: Clone + Integer> One for Ratio<T> {
One for Ratio<T> {
#[inline] #[inline]
fn one() -> Ratio<T> { fn one() -> Ratio<T> {
Ratio::new_raw(One::one(), One::one()) Ratio::new_raw(One::one(), One::one())
@ -443,19 +473,21 @@ impl<T: Clone + Integer> Num for Ratio<T> {
fn from_str_radix(s: &str, radix: u32) -> Result<Ratio<T>, ParseRatioError> { fn from_str_radix(s: &str, radix: u32) -> Result<Ratio<T>, ParseRatioError> {
let split: Vec<&str> = s.splitn(2, '/').collect(); let split: Vec<&str> = s.splitn(2, '/').collect();
if split.len() < 2 { if split.len() < 2 {
Err(ParseRatioError{kind: RatioErrorKind::ParseError}) Err(ParseRatioError { kind: RatioErrorKind::ParseError })
} else { } else {
let a_result: Result<T, _> = T::from_str_radix( let a_result: Result<T, _> = T::from_str_radix(split[0], radix).map_err(|_| {
split[0], ParseRatioError { kind: RatioErrorKind::ParseError }
radix).map_err(|_| ParseRatioError{kind: RatioErrorKind::ParseError}); });
a_result.and_then(|a| { a_result.and_then(|a| {
let b_result: Result<T, _> = let b_result: Result<T, _> = T::from_str_radix(split[1], radix).map_err(|_| {
T::from_str_radix(split[1], radix).map_err( ParseRatioError { kind: RatioErrorKind::ParseError }
|_| ParseRatioError{kind: RatioErrorKind::ParseError}); });
b_result.and_then(|b| if b.is_zero() { b_result.and_then(|b| {
Err(ParseRatioError{kind: RatioErrorKind::ZeroDenominator}) if b.is_zero() {
} else { Err(ParseRatioError { kind: RatioErrorKind::ZeroDenominator })
Ok(Ratio::new(a.clone(), b.clone())) } else {
Ok(Ratio::new(a.clone(), b.clone()))
}
}) })
}) })
} }
@ -465,12 +497,20 @@ impl<T: Clone + Integer> Num for Ratio<T> {
impl<T: Clone + Integer + Signed> Signed for Ratio<T> { impl<T: Clone + Integer + Signed> Signed for Ratio<T> {
#[inline] #[inline]
fn abs(&self) -> Ratio<T> { fn abs(&self) -> Ratio<T> {
if self.is_negative() { -self.clone() } else { self.clone() } if self.is_negative() {
-self.clone()
} else {
self.clone()
}
} }
#[inline] #[inline]
fn abs_sub(&self, other: &Ratio<T>) -> Ratio<T> { fn abs_sub(&self, other: &Ratio<T>) -> Ratio<T> {
if *self <= *other { Zero::zero() } else { self - other } if *self <= *other {
Zero::zero()
} else {
self - other
}
} }
#[inline] #[inline]
@ -480,12 +520,14 @@ impl<T: Clone + Integer + Signed> Signed for Ratio<T> {
} else if self.is_zero() { } else if self.is_zero() {
Self::zero() Self::zero()
} else { } else {
- Self::one() -Self::one()
} }
} }
#[inline] #[inline]
fn is_positive(&self) -> bool { !self.is_negative() } fn is_positive(&self) -> bool {
!self.is_negative()
}
#[inline] #[inline]
fn is_negative(&self) -> bool { fn is_negative(&self) -> bool {
@ -493,9 +535,9 @@ impl<T: Clone + Integer + Signed> Signed for Ratio<T> {
} }
} }
/* String conversions */ // String conversions
impl<T> fmt::Display for Ratio<T> where impl<T> fmt::Display for Ratio<T>
T: fmt::Display + Eq + One where T: fmt::Display + Eq + One
{ {
/// Renders as `numer/denom`. If denom=1, renders as numer. /// Renders as `numer/denom`. If denom=1, renders as numer.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@ -514,17 +556,16 @@ impl<T: FromStr + Clone + Integer> FromStr for Ratio<T> {
fn from_str(s: &str) -> Result<Ratio<T>, ParseRatioError> { fn from_str(s: &str) -> Result<Ratio<T>, ParseRatioError> {
let mut split = s.splitn(2, '/'); let mut split = s.splitn(2, '/');
let n = try!(split.next().ok_or( let n = try!(split.next().ok_or(ParseRatioError { kind: RatioErrorKind::ParseError }));
ParseRatioError{kind: RatioErrorKind::ParseError})); let num = try!(FromStr::from_str(n)
let num = try!(FromStr::from_str(n).map_err( .map_err(|_| ParseRatioError { kind: RatioErrorKind::ParseError }));
|_| ParseRatioError{kind: RatioErrorKind::ParseError}));
let d = split.next().unwrap_or("1"); let d = split.next().unwrap_or("1");
let den = try!(FromStr::from_str(d).map_err( let den = try!(FromStr::from_str(d)
|_| ParseRatioError{kind: RatioErrorKind::ParseError})); .map_err(|_| ParseRatioError { kind: RatioErrorKind::ParseError }));
if Zero::is_zero(&den) { if Zero::is_zero(&den) {
Err(ParseRatioError{kind: RatioErrorKind::ZeroDenominator}) Err(ParseRatioError { kind: RatioErrorKind::ZeroDenominator })
} else { } else {
Ok(Ratio::new(num, den)) Ok(Ratio::new(num, den))
} }
@ -535,8 +576,8 @@ impl<T: FromStr + Clone + Integer> FromStr for Ratio<T> {
impl<T> serde::Serialize for Ratio<T> impl<T> serde::Serialize for Ratio<T>
where T: serde::Serialize + Clone + Integer + PartialOrd where T: serde::Serialize + Clone + Integer + PartialOrd
{ {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
S: serde::Serializer where S: serde::Serializer
{ {
(self.numer(), self.denom()).serialize(serializer) (self.numer(), self.denom()).serialize(serializer)
} }
@ -546,8 +587,8 @@ impl<T> serde::Serialize for Ratio<T>
impl<T> serde::Deserialize for Ratio<T> impl<T> serde::Deserialize for Ratio<T>
where T: serde::Deserialize + Clone + Integer + PartialOrd where T: serde::Deserialize + Clone + Integer + PartialOrd
{ {
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
D: serde::Deserializer, where D: serde::Deserializer
{ {
let (numer, denom) = try!(serde::Deserialize::deserialize(deserializer)); let (numer, denom) = try!(serde::Deserialize::deserialize(deserializer));
if denom == Zero::zero() { if denom == Zero::zero() {
@ -560,7 +601,9 @@ impl<T> serde::Deserialize for Ratio<T>
// FIXME: Bubble up specific errors // FIXME: Bubble up specific errors
#[derive(Copy, Clone, Debug, PartialEq)] #[derive(Copy, Clone, Debug, PartialEq)]
pub struct ParseRatioError { kind: RatioErrorKind } pub struct ParseRatioError {
kind: RatioErrorKind,
}
#[derive(Copy, Clone, Debug, PartialEq)] #[derive(Copy, Clone, Debug, PartialEq)]
enum RatioErrorKind { enum RatioErrorKind {
@ -575,7 +618,9 @@ impl fmt::Display for ParseRatioError {
} }
impl Error for ParseRatioError { impl Error for ParseRatioError {
fn description(&self) -> &str { self.kind.description() } fn description(&self) -> &str {
self.kind.description()
}
} }
impl RatioErrorKind { impl RatioErrorKind {
@ -588,39 +633,73 @@ impl RatioErrorKind {
} }
#[cfg(test)] #[cfg(test)]
mod test { fn hash<T: hash::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}; use super::{Ratio, Rational};
#[cfg(feature = "bigint")] #[cfg(feature = "num-bigint")]
use super::BigRational; use super::BigRational;
use std::str::FromStr; use std::str::FromStr;
use std::i32; 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 _0: Rational = Ratio {
pub const _1 : Rational = Ratio { numer: 1, denom: 1}; numer: 0,
pub const _2: Rational = Ratio { numer: 2, denom: 1}; denom: 1,
pub const _1_2: Rational = Ratio { numer: 1, denom: 2}; };
pub const _3_2: Rational = Ratio { numer: 3, denom: 2}; pub const _1: Rational = Ratio {
pub const _NEG1_2: Rational = Ratio { numer: -1, denom: 2}; numer: 1,
pub const _1_3: Rational = Ratio { numer: 1, denom: 3}; denom: 1,
pub const _NEG1_3: Rational = Ratio { numer: -1, denom: 3}; };
pub const _2_3: Rational = Ratio { numer: 2, denom: 3}; pub const _2: Rational = Ratio {
pub const _NEG2_3: Rational = Ratio { numer: -2, denom: 3}; 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 { pub fn to_big(n: Rational) -> BigRational {
Ratio::new( Ratio::new(FromPrimitive::from_isize(n.numer).unwrap(),
FromPrimitive::from_isize(n.numer).unwrap(), FromPrimitive::from_isize(n.denom).unwrap())
FromPrimitive::from_isize(n.denom).unwrap()
)
} }
#[cfg(not(feature = "bigint"))] #[cfg(not(feature = "num-bigint"))]
pub fn to_big(n: Rational) -> Rational { pub fn to_big(n: Rational) -> Rational {
Ratio::new( Ratio::new(FromPrimitive::from_isize(n.numer).unwrap(),
FromPrimitive::from_isize(n.numer).unwrap(), FromPrimitive::from_isize(n.denom).unwrap())
FromPrimitive::from_isize(n.denom).unwrap()
)
} }
#[test] #[test]
@ -629,21 +708,21 @@ mod test {
assert_eq!(_0, Zero::zero()); assert_eq!(_0, Zero::zero());
assert_eq!(_1, One::one()); assert_eq!(_1, One::one());
assert_eq!(_2, Ratio::from_integer(2)); assert_eq!(_2, Ratio::from_integer(2));
assert_eq!(_1_2, Ratio::new(1,2)); assert_eq!(_1_2, Ratio::new(1, 2));
assert_eq!(_3_2, Ratio::new(3,2)); assert_eq!(_3_2, Ratio::new(3, 2));
assert_eq!(_NEG1_2, Ratio::new(-1,2)); assert_eq!(_NEG1_2, Ratio::new(-1, 2));
} }
#[test] #[test]
fn test_new_reduce() { fn test_new_reduce() {
let one22 = Ratio::new(2,2); let one22 = Ratio::new(2, 2);
assert_eq!(one22, One::one()); assert_eq!(one22, One::one());
} }
#[test] #[test]
#[should_panic] #[should_panic]
fn test_new_zero() { 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() { for (i, &a) in ratios.iter().enumerate() {
check_cmp(a, a, Ordering::Equal); check_cmp(a, a, Ordering::Equal);
check_cmp(-a, a, Ordering::Less); 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::Less);
check_cmp(-a, -b, Ordering::Greater); check_cmp(-a, -b, Ordering::Greater);
check_cmp(a.recip(), b.recip(), Ordering::Greater); check_cmp(a.recip(), b.recip(), Ordering::Greater);
@ -785,7 +864,7 @@ mod test {
} }
test(_1, _1_2, _1_2); 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)); test(_1_2, _NEG1_2, Ratio::new(-1, 4));
} }
@ -810,7 +889,7 @@ mod test {
test(_3_2, _1, _1_2); test(_3_2, _1, _1_2);
test(_2, _NEG1_2, _0); test(_2, _NEG1_2, _0);
test(_1_2, _2, _1_2); test(_1_2, _2, _1_2);
} }
#[test] #[test]
@ -835,7 +914,7 @@ mod test {
#[test] #[test]
#[should_panic] #[should_panic]
fn test_div_0() { fn test_div_0() {
let _a = _1 / _0; let _a = _1 / _0;
} }
} }
@ -879,13 +958,13 @@ mod test {
// Overflow checks // Overflow checks
let _neg1 = Ratio::from_integer(-1); let _neg1 = Ratio::from_integer(-1);
let _large_rat1 = Ratio::new(i32::MAX, i32::MAX-1); let _large_rat1 = Ratio::new(i32::MAX, i32::MAX - 1);
let _large_rat2 = Ratio::new(i32::MAX-1, i32::MAX); let _large_rat2 = Ratio::new(i32::MAX - 1, i32::MAX);
let _large_rat3 = Ratio::new(i32::MIN+2, i32::MIN+1); let _large_rat3 = Ratio::new(i32::MIN + 2, i32::MIN + 1);
let _large_rat4 = Ratio::new(i32::MIN+1, i32::MIN+2); let _large_rat4 = Ratio::new(i32::MIN + 1, i32::MIN + 2);
let _large_rat5 = Ratio::new(i32::MIN+2, i32::MAX); let _large_rat5 = Ratio::new(i32::MIN + 2, i32::MAX);
let _large_rat6 = Ratio::new(i32::MAX, i32::MIN+2); let _large_rat6 = Ratio::new(i32::MAX, i32::MIN + 2);
let _large_rat7 = Ratio::new(1, i32::MIN+1); let _large_rat7 = Ratio::new(1, i32::MIN + 1);
let _large_rat8 = Ratio::new(1, i32::MAX); let _large_rat8 = Ratio::new(1, i32::MAX);
assert_eq!(_large_rat1.round(), One::one()); assert_eq!(_large_rat1.round(), One::one());
@ -947,27 +1026,28 @@ mod test {
assert!(rational.is_err()); 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() { for &s in xs.iter() {
test(s); test(s);
} }
} }
#[cfg(feature = "bigint")] #[cfg(feature = "num-bigint")]
#[test] #[test]
fn test_from_float() { fn test_from_float() {
fn test<T: Float>(given: T, (numer, denom): (&str, &str)) { fn test<T: Float>(given: T, (numer, denom): (&str, &str)) {
let ratio: BigRational = Ratio::from_float(given).unwrap(); let ratio: BigRational = Ratio::from_float(given).unwrap();
assert_eq!(ratio, Ratio::new( assert_eq!(ratio,
FromStr::from_str(numer).unwrap(), Ratio::new(FromStr::from_str(numer).unwrap(),
FromStr::from_str(denom).unwrap())); FromStr::from_str(denom).unwrap()));
} }
// f32 // f32
test(3.14159265359f32, ("13176795", "4194304")); test(3.14159265359f32, ("13176795", "4194304"));
test(2f32.powf(100.), ("1267650600228229401496703205376", "1")); test(2f32.powf(100.), ("1267650600228229401496703205376", "1"));
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(684729.48391f32, ("1369459", "2"));
test(-8573.5918555f32, ("-4389679", "512")); test(-8573.5918555f32, ("-4389679", "512"));
@ -977,10 +1057,11 @@ mod test {
test(-2f64.powf(100.), ("-1267650600228229401496703205376", "1")); test(-2f64.powf(100.), ("-1267650600228229401496703205376", "1"));
test(684729.48391f64, ("367611342500051", "536870912")); test(684729.48391f64, ("367611342500051", "536870912"));
test(-8573.5918555f64, ("-4713381968463931", "549755813888")); 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] #[test]
fn test_from_float_fail() { fn test_from_float_fail() {
use std::{f32, f64}; use std::{f32, f64};
@ -999,10 +1080,10 @@ mod test {
assert_eq!(_3_2.abs_sub(&_1_2), _1); assert_eq!(_3_2.abs_sub(&_1_2), _1);
assert_eq!(_1_2.abs_sub(&_3_2), Zero::zero()); assert_eq!(_1_2.abs_sub(&_3_2), Zero::zero());
assert_eq!(_1_2.signum(), One::one()); assert_eq!(_1_2.signum(), One::one());
assert_eq!(_NEG1_2.signum(), - ::one::<Ratio<isize>>()); assert_eq!(_NEG1_2.signum(), -<Ratio<isize>>::one());
assert!(_NEG1_2.is_negative()); assert!(_NEG1_2.is_negative());
assert!(! _NEG1_2.is_positive()); assert!(!_NEG1_2.is_positive());
assert!(! _1_2.is_negative()); assert!(!_1_2.is_negative());
} }
#[test] #[test]

73
src/lib.rs
View File

@ -57,44 +57,41 @@
html_root_url = "http://rust-num.github.io/num/", html_root_url = "http://rust-num.github.io/num/",
html_playground_url = "http://play.rust-lang.org/")] html_playground_url = "http://play.rust-lang.org/")]
#[cfg(feature = "rustc-serialize")] pub extern crate num_traits;
extern crate rustc_serialize; 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 #[cfg(feature = "num-bigint")]
// RNG-based functionality, so the RNG-based functionality needs to be enabled pub use num_bigint::{BigInt, BigUint};
// for tests. #[cfg(feature = "num-rational")]
#[cfg(any(feature = "rand", all(feature = "bigint", test)))] pub use num_rational::Rational;
extern crate rand; #[cfg(all(feature = "num-rational", feature="num-bigint"))]
pub use num_rational::BigRational;
#[cfg(feature = "serde")] #[cfg(feature = "num-complex")]
extern crate serde; pub use num_complex::Complex;
pub use num_integer::Integer;
#[cfg(feature = "bigint")] pub use num_iter::{range, range_inclusive, range_step, range_step_inclusive};
pub use bigint::{BigInt, BigUint}; pub use num_traits::{Num, Zero, One, Signed, Unsigned, Bounded,
#[cfg(feature = "rational")] Saturating, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv,
pub use rational::Rational; PrimInt, Float, ToPrimitive, FromPrimitive, NumCast, cast};
#[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;
use std::ops::{Mul}; use std::ops::{Mul};
#[cfg(feature = "bigint")] #[cfg(feature = "num-bigint")]
pub mod bigint; pub use num_bigint as bigint;
pub mod complex; #[cfg(feature = "num-complex")]
pub mod integer; pub use num_complex as complex;
pub mod iter; pub use num_integer as integer;
pub mod traits; pub use num_iter as iter;
#[cfg(feature = "rational")] pub use num_traits as traits;
pub mod rational; #[cfg(feature = "num-rational")]
pub use num_rational as rational;
/// Returns the additive identity, `0`. /// Returns the additive identity, `0`.
#[inline(always)] pub fn zero<T: Zero>() -> T { Zero::zero() } #[inline(always)] pub fn zero<T: Zero>() -> T { Zero::zero() }
@ -206,11 +203,3 @@ pub fn checked_pow<T: Clone + One + CheckedMul>(mut base: T, mut exp: usize) ->
} }
Some(acc) Some(acc)
} }
#[cfg(test)]
fn hash<T: hash::Hash>(x: &T) -> u64 {
use std::hash::Hasher;
let mut hasher = hash::SipHasher::new();
x.hash(&mut hasher);
hasher.finish()
}

2552
src/traits.rs
View File

File diff suppressed because it is too large Load Diff

12
traits/Cargo.toml Normal file
View File

@ -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]

69
traits/src/bounds.rs Normal file
View File

@ -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);

433
traits/src/cast.rs Normal file
View File

@ -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<isize> {
self.to_i64().and_then(|x| x.to_isize())
}
/// Converts the value of `self` to an `i8`.
#[inline]
fn to_i8(&self) -> Option<i8> {
self.to_i64().and_then(|x| x.to_i8())
}
/// Converts the value of `self` to an `i16`.
#[inline]
fn to_i16(&self) -> Option<i16> {
self.to_i64().and_then(|x| x.to_i16())
}
/// Converts the value of `self` to an `i32`.
#[inline]
fn to_i32(&self) -> Option<i32> {
self.to_i64().and_then(|x| x.to_i32())
}
/// Converts the value of `self` to an `i64`.
fn to_i64(&self) -> Option<i64>;
/// Converts the value of `self` to a `usize`.
#[inline]
fn to_usize(&self) -> Option<usize> {
self.to_u64().and_then(|x| x.to_usize())
}
/// Converts the value of `self` to an `u8`.
#[inline]
fn to_u8(&self) -> Option<u8> {
self.to_u64().and_then(|x| x.to_u8())
}
/// Converts the value of `self` to an `u16`.
#[inline]
fn to_u16(&self) -> Option<u16> {
self.to_u64().and_then(|x| x.to_u16())
}
/// Converts the value of `self` to an `u32`.
#[inline]
fn to_u32(&self) -> Option<u32> {
self.to_u64().and_then(|x| x.to_u32())
}
/// Converts the value of `self` to an `u64`.
#[inline]
fn to_u64(&self) -> Option<u64>;
/// Converts the value of `self` to an `f32`.
#[inline]
fn to_f32(&self) -> Option<f32> {
self.to_f64().and_then(|x| x.to_f32())
}
/// Converts the value of `self` to an `f64`.
#[inline]
fn to_f64(&self) -> Option<f64> {
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<isize> { impl_to_primitive_int_to_int!($T, isize, *self) }
#[inline]
fn to_i8(&self) -> Option<i8> { impl_to_primitive_int_to_int!($T, i8, *self) }
#[inline]
fn to_i16(&self) -> Option<i16> { impl_to_primitive_int_to_int!($T, i16, *self) }
#[inline]
fn to_i32(&self) -> Option<i32> { impl_to_primitive_int_to_int!($T, i32, *self) }
#[inline]
fn to_i64(&self) -> Option<i64> { impl_to_primitive_int_to_int!($T, i64, *self) }
#[inline]
fn to_usize(&self) -> Option<usize> { impl_to_primitive_int_to_uint!($T, usize, *self) }
#[inline]
fn to_u8(&self) -> Option<u8> { impl_to_primitive_int_to_uint!($T, u8, *self) }
#[inline]
fn to_u16(&self) -> Option<u16> { impl_to_primitive_int_to_uint!($T, u16, *self) }
#[inline]
fn to_u32(&self) -> Option<u32> { impl_to_primitive_int_to_uint!($T, u32, *self) }
#[inline]
fn to_u64(&self) -> Option<u64> { impl_to_primitive_int_to_uint!($T, u64, *self) }
#[inline]
fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
#[inline]
fn to_f64(&self) -> Option<f64> { 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<isize> { impl_to_primitive_uint_to_int!(isize, *self) }
#[inline]
fn to_i8(&self) -> Option<i8> { impl_to_primitive_uint_to_int!(i8, *self) }
#[inline]
fn to_i16(&self) -> Option<i16> { impl_to_primitive_uint_to_int!(i16, *self) }
#[inline]
fn to_i32(&self) -> Option<i32> { impl_to_primitive_uint_to_int!(i32, *self) }
#[inline]
fn to_i64(&self) -> Option<i64> { impl_to_primitive_uint_to_int!(i64, *self) }
#[inline]
fn to_usize(&self) -> Option<usize> {
impl_to_primitive_uint_to_uint!($T, usize, *self)
}
#[inline]
fn to_u8(&self) -> Option<u8> { impl_to_primitive_uint_to_uint!($T, u8, *self) }
#[inline]
fn to_u16(&self) -> Option<u16> { impl_to_primitive_uint_to_uint!($T, u16, *self) }
#[inline]
fn to_u32(&self) -> Option<u32> { impl_to_primitive_uint_to_uint!($T, u32, *self) }
#[inline]
fn to_u64(&self) -> Option<u64> { impl_to_primitive_uint_to_uint!($T, u64, *self) }
#[inline]
fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
#[inline]
fn to_f64(&self) -> Option<f64> { 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<isize> { Some(*self as isize) }
#[inline]
fn to_i8(&self) -> Option<i8> { Some(*self as i8) }
#[inline]
fn to_i16(&self) -> Option<i16> { Some(*self as i16) }
#[inline]
fn to_i32(&self) -> Option<i32> { Some(*self as i32) }
#[inline]
fn to_i64(&self) -> Option<i64> { Some(*self as i64) }
#[inline]
fn to_usize(&self) -> Option<usize> { Some(*self as usize) }
#[inline]
fn to_u8(&self) -> Option<u8> { Some(*self as u8) }
#[inline]
fn to_u16(&self) -> Option<u16> { Some(*self as u16) }
#[inline]
fn to_u32(&self) -> Option<u32> { Some(*self as u32) }
#[inline]
fn to_u64(&self) -> Option<u64> { Some(*self as u64) }
#[inline]
fn to_f32(&self) -> Option<f32> { impl_to_primitive_float_to_float!($T, f32, *self) }
#[inline]
fn to_f64(&self) -> Option<f64> { 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<Self> {
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<Self> {
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<Self> {
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<Self> {
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<Self>;
/// 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<Self> {
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<Self> {
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<Self> {
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<Self> {
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<Self>;
/// 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<Self> {
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<Self> {
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<T: NumCast, U: NumCast>(n: T) -> Option<U> {
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<T: ToPrimitive>(n: T) -> Option<Self>;
}
macro_rules! impl_num_cast {
($T:ty, $conv:ident) => (
impl NumCast for $T {
#[inline]
#[allow(deprecated)]
fn from<N: ToPrimitive>(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);

1126
traits/src/float.rs Normal file
View File

File diff suppressed because it is too large Load Diff

95
traits/src/identities.rs Normal file
View File

@ -0,0 +1,95 @@
use std::ops::{Add, Mul};
/// Defines an additive identity element for `Self`.
pub trait Zero: Sized + Add<Self, Output = Self> {
/// 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<Self, Output = Self> {
/// 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);

360
traits/src/int.rs Normal file
View File

@ -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<Output=Self>
+ BitAnd<Output=Self>
+ BitOr<Output=Self>
+ BitXor<Output=Self>
+ Shl<usize, Output=Self>
+ Shr<usize, Output=Self>
+ CheckedAdd<Output=Self>
+ CheckedSub<Output=Self>
+ CheckedMul<Output=Self>
+ CheckedDiv<Output=Self>
+ 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);

233
traits/src/lib.rs Normal file
View File

@ -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 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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<Output = Self> + Sub<Output = Self>
+ Mul<Output = Self> + Div<Output = Self> + Rem<Output = Self>
{
type FromStrRadixErr;
/// Convert from a string and radix <= 36.
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>;
}
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<Self, ::std::num::ParseIntError>
{
<$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<Self, Self::FromStrRadixErr>
{
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::<usize>()),
Some(('+', src)) => (true, src.parse::<usize>()),
Some((_, _)) => (true, src.parse::<usize>()),
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);
}

91
traits/src/ops/checked.rs Normal file
View File

@ -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<Self, Output=Self> {
/// Adds two numbers, checking for overflow. If overflow happens, `None` is
/// returned.
fn checked_add(&self, v: &Self) -> Option<Self>;
}
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<Self, Output=Self> {
/// Subtracts two numbers, checking for underflow. If underflow happens,
/// `None` is returned.
fn checked_sub(&self, v: &Self) -> Option<Self>;
}
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<Self, Output=Self> {
/// Multiplies two numbers, checking for underflow or overflow. If underflow
/// or overflow happens, `None` is returned.
fn checked_mul(&self, v: &Self) -> Option<Self>;
}
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<Self, Output=Self> {
/// 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<Self>;
}
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);

2
traits/src/ops/mod.rs Normal file
View File

@ -0,0 +1,2 @@
pub mod saturating;
pub mod checked;

26
traits/src/ops/saturating.rs Normal file
View File

@ -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);

126
traits/src/sign.rs Normal file
View File

@ -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<Output = Self> {
/// 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);