Move num-traits to its own repo
All the prior `num` history is kept, so old `num-traits` tags are still valid, but future development here will be just for `num-traits`.
This commit is contained in:
parent
f172ef3a6b
commit
42a610d323
16
.travis.yml
16
.travis.yml
|
@ -1,25 +1,13 @@
|
||||||
language: rust
|
language: rust
|
||||||
rust:
|
rust:
|
||||||
- 1.15.0
|
- 1.8.0
|
||||||
|
- stable
|
||||||
- beta
|
- beta
|
||||||
- nightly
|
- nightly
|
||||||
matrix:
|
|
||||||
include:
|
|
||||||
- rust: 1.8.0
|
|
||||||
before_script:
|
|
||||||
# libc 0.2.34 started using #[deprecated]
|
|
||||||
- cargo generate-lockfile
|
|
||||||
- cargo update --package libc --precise 0.2.33
|
|
||||||
sudo: false
|
sudo: false
|
||||||
script:
|
script:
|
||||||
- cargo build --verbose
|
- cargo build --verbose
|
||||||
- ./ci/test_full.sh
|
- ./ci/test_full.sh
|
||||||
- cargo doc
|
|
||||||
after_success: |
|
|
||||||
[ $TRAVIS_BRANCH = master ] &&
|
|
||||||
[ $TRAVIS_PULL_REQUEST = false ] &&
|
|
||||||
[ $TRAVIS_RUST_VERSION = nightly ] &&
|
|
||||||
ssh-agent ./ci/deploy.sh
|
|
||||||
notifications:
|
notifications:
|
||||||
email:
|
email:
|
||||||
on_success: never
|
on_success: never
|
||||||
|
|
75
Cargo.toml
75
Cargo.toml
|
@ -1,73 +1,14 @@
|
||||||
[package]
|
[package]
|
||||||
authors = ["The Rust Project Developers"]
|
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"
|
description = "Numeric traits for generic mathematics"
|
||||||
documentation = "http://rust-num.github.io/num"
|
documentation = "https://docs.rs/num-traits"
|
||||||
homepage = "https://github.com/rust-num/num"
|
homepage = "https://github.com/rust-num/num-traits"
|
||||||
keywords = ["mathematics", "numerics", "bignum"]
|
keywords = ["mathematics", "numerics"]
|
||||||
categories = [ "algorithms", "data-structures", "science" ]
|
categories = [ "algorithms", "science" ]
|
||||||
license = "MIT/Apache-2.0"
|
license = "MIT/Apache-2.0"
|
||||||
repository = "https://github.com/rust-num/num"
|
repository = "https://github.com/rust-num/num-traits"
|
||||||
name = "num"
|
name = "num-traits"
|
||||||
version = "0.1.41"
|
version = "0.1.41"
|
||||||
|
readme = "README.md"
|
||||||
[badges]
|
|
||||||
travis-ci = { repository = "rust-num/num" }
|
|
||||||
|
|
||||||
[[bench]]
|
|
||||||
name = "bigint"
|
|
||||||
|
|
||||||
[[bench]]
|
|
||||||
harness = false
|
|
||||||
name = "shootout-pidigits"
|
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
|
|
||||||
[dependencies.num-bigint]
|
|
||||||
optional = true
|
|
||||||
path = "bigint"
|
|
||||||
version = "0.1.41"
|
|
||||||
|
|
||||||
[dependencies.num-complex]
|
|
||||||
optional = true
|
|
||||||
path = "complex"
|
|
||||||
version = "0.1.41"
|
|
||||||
|
|
||||||
[dependencies.num-integer]
|
|
||||||
path = "./integer"
|
|
||||||
version = "0.1.35"
|
|
||||||
|
|
||||||
[dependencies.num-iter]
|
|
||||||
optional = false
|
|
||||||
path = "iter"
|
|
||||||
version = "0.1.34"
|
|
||||||
|
|
||||||
[dependencies.num-rational]
|
|
||||||
optional = true
|
|
||||||
path = "rational"
|
|
||||||
version = "0.1.40"
|
|
||||||
|
|
||||||
[dependencies.num-traits]
|
|
||||||
path = "./traits"
|
|
||||||
version = "0.1.41"
|
|
||||||
|
|
||||||
[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"
|
|
||||||
]
|
|
||||||
|
|
21
README.md
21
README.md
|
@ -1,14 +1,10 @@
|
||||||
# num
|
# num-traits
|
||||||
|
|
||||||
[![](https://travis-ci.org/rust-num/num.svg)](https://travis-ci.org/rust-num/num)
|
[![crate](https://img.shields.io/crates/v/num-traits.svg)](https://crates.io/crates/num-traits)
|
||||||
|
[![documentation](https://docs.rs/num-traits/badge.svg)](https://docs.rs/num-traits)
|
||||||
|
[![Travis status](https://travis-ci.org/rust-num/num-traits.svg?branch=master)](https://travis-ci.org/rust-num/num-traits)
|
||||||
|
|
||||||
A collection of numeric types and traits for Rust.
|
Numeric traits for generic mathematics in Rust.
|
||||||
|
|
||||||
This includes new types for big integers, rationals, and complex numbers,
|
|
||||||
new traits for generic programming on numeric properties like `Integer`,
|
|
||||||
and generic range iterators.
|
|
||||||
|
|
||||||
[Documentation](http://rust-num.github.io/num)
|
|
||||||
|
|
||||||
## Usage
|
## Usage
|
||||||
|
|
||||||
|
@ -16,16 +12,15 @@ Add this to your `Cargo.toml`:
|
||||||
|
|
||||||
```toml
|
```toml
|
||||||
[dependencies]
|
[dependencies]
|
||||||
num = "0.1"
|
num-traits = "0.1"
|
||||||
```
|
```
|
||||||
|
|
||||||
and this to your crate root:
|
and this to your crate root:
|
||||||
|
|
||||||
```rust
|
```rust
|
||||||
extern crate num;
|
extern crate num_traits;
|
||||||
```
|
```
|
||||||
|
|
||||||
## Compatibility
|
## Compatibility
|
||||||
|
|
||||||
Most of the `num` crates are tested for rustc 1.8 and greater.
|
The `num-traits` crate is tested for rustc 1.8 and greater.
|
||||||
The exception is `num-derive` which requires at least rustc 1.15.
|
|
||||||
|
|
|
@ -1,294 +0,0 @@
|
||||||
#![feature(test)]
|
|
||||||
|
|
||||||
extern crate test;
|
|
||||||
extern crate num;
|
|
||||||
extern crate rand;
|
|
||||||
|
|
||||||
use std::mem::replace;
|
|
||||||
use test::Bencher;
|
|
||||||
use num::{BigInt, BigUint, Zero, One, FromPrimitive, Num};
|
|
||||||
use num::bigint::RandBigInt;
|
|
||||||
use rand::{SeedableRng, StdRng};
|
|
||||||
|
|
||||||
fn get_rng() -> StdRng {
|
|
||||||
let seed: &[_] = &[1, 2, 3, 4];
|
|
||||||
SeedableRng::from_seed(seed)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn multiply_bench(b: &mut Bencher, xbits: usize, ybits: usize) {
|
|
||||||
let mut rng = get_rng();
|
|
||||||
let x = rng.gen_bigint(xbits);
|
|
||||||
let y = rng.gen_bigint(ybits);
|
|
||||||
|
|
||||||
b.iter(|| &x * &y);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn divide_bench(b: &mut Bencher, xbits: usize, ybits: usize) {
|
|
||||||
let mut rng = get_rng();
|
|
||||||
let x = rng.gen_bigint(xbits);
|
|
||||||
let y = rng.gen_bigint(ybits);
|
|
||||||
|
|
||||||
b.iter(|| &x / &y);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn factorial(n: usize) -> BigUint {
|
|
||||||
let mut f: BigUint = One::one();
|
|
||||||
for i in 1..(n+1) {
|
|
||||||
let bu: BigUint = FromPrimitive::from_usize(i).unwrap();
|
|
||||||
f = f * bu;
|
|
||||||
}
|
|
||||||
f
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Compute Fibonacci numbers
|
|
||||||
fn fib(n: usize) -> BigUint {
|
|
||||||
let mut f0: BigUint = Zero::zero();
|
|
||||||
let mut f1: BigUint = One::one();
|
|
||||||
for _ in 0..n {
|
|
||||||
let f2 = f0 + &f1;
|
|
||||||
f0 = replace(&mut f1, f2);
|
|
||||||
}
|
|
||||||
f0
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Compute Fibonacci numbers with two ops per iteration
|
|
||||||
/// (add and subtract, like issue #200)
|
|
||||||
fn fib2(n: usize) -> BigUint {
|
|
||||||
let mut f0: BigUint = Zero::zero();
|
|
||||||
let mut f1: BigUint = One::one();
|
|
||||||
for _ in 0..n {
|
|
||||||
f1 = f1 + &f0;
|
|
||||||
f0 = &f1 - f0;
|
|
||||||
}
|
|
||||||
f0
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn multiply_0(b: &mut Bencher) {
|
|
||||||
multiply_bench(b, 1 << 8, 1 << 8);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn multiply_1(b: &mut Bencher) {
|
|
||||||
multiply_bench(b, 1 << 8, 1 << 16);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn multiply_2(b: &mut Bencher) {
|
|
||||||
multiply_bench(b, 1 << 16, 1 << 16);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn multiply_3(b: &mut Bencher) {
|
|
||||||
multiply_bench(b, 1 << 16, 1 << 17);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn divide_0(b: &mut Bencher) {
|
|
||||||
divide_bench(b, 1 << 8, 1 << 6);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn divide_1(b: &mut Bencher) {
|
|
||||||
divide_bench(b, 1 << 12, 1 << 8);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn divide_2(b: &mut Bencher) {
|
|
||||||
divide_bench(b, 1 << 16, 1 << 12);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn factorial_100(b: &mut Bencher) {
|
|
||||||
b.iter(|| factorial(100));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn fib_100(b: &mut Bencher) {
|
|
||||||
b.iter(|| fib(100));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn fib_1000(b: &mut Bencher) {
|
|
||||||
b.iter(|| fib(1000));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn fib_10000(b: &mut Bencher) {
|
|
||||||
b.iter(|| fib(10000));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn fib2_100(b: &mut Bencher) {
|
|
||||||
b.iter(|| fib2(100));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn fib2_1000(b: &mut Bencher) {
|
|
||||||
b.iter(|| fib2(1000));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn fib2_10000(b: &mut Bencher) {
|
|
||||||
b.iter(|| fib2(10000));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn fac_to_string(b: &mut Bencher) {
|
|
||||||
let fac = factorial(100);
|
|
||||||
b.iter(|| fac.to_string());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn fib_to_string(b: &mut Bencher) {
|
|
||||||
let fib = fib(100);
|
|
||||||
b.iter(|| fib.to_string());
|
|
||||||
}
|
|
||||||
|
|
||||||
fn to_str_radix_bench(b: &mut Bencher, radix: u32) {
|
|
||||||
let mut rng = get_rng();
|
|
||||||
let x = rng.gen_bigint(1009);
|
|
||||||
b.iter(|| x.to_str_radix(radix));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn to_str_radix_02(b: &mut Bencher) {
|
|
||||||
to_str_radix_bench(b, 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn to_str_radix_08(b: &mut Bencher) {
|
|
||||||
to_str_radix_bench(b, 8);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn to_str_radix_10(b: &mut Bencher) {
|
|
||||||
to_str_radix_bench(b, 10);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn to_str_radix_16(b: &mut Bencher) {
|
|
||||||
to_str_radix_bench(b, 16);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn to_str_radix_36(b: &mut Bencher) {
|
|
||||||
to_str_radix_bench(b, 36);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn from_str_radix_bench(b: &mut Bencher, radix: u32) {
|
|
||||||
use num::Num;
|
|
||||||
let mut rng = get_rng();
|
|
||||||
let x = rng.gen_bigint(1009);
|
|
||||||
let s = x.to_str_radix(radix);
|
|
||||||
assert_eq!(x, BigInt::from_str_radix(&s, radix).unwrap());
|
|
||||||
b.iter(|| BigInt::from_str_radix(&s, radix));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn from_str_radix_02(b: &mut Bencher) {
|
|
||||||
from_str_radix_bench(b, 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn from_str_radix_08(b: &mut Bencher) {
|
|
||||||
from_str_radix_bench(b, 8);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn from_str_radix_10(b: &mut Bencher) {
|
|
||||||
from_str_radix_bench(b, 10);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn from_str_radix_16(b: &mut Bencher) {
|
|
||||||
from_str_radix_bench(b, 16);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn from_str_radix_36(b: &mut Bencher) {
|
|
||||||
from_str_radix_bench(b, 36);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn shl(b: &mut Bencher) {
|
|
||||||
let n = BigUint::one() << 1000;
|
|
||||||
b.iter(|| {
|
|
||||||
let mut m = n.clone();
|
|
||||||
for i in 0..50 {
|
|
||||||
m = m << i;
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn shr(b: &mut Bencher) {
|
|
||||||
let n = BigUint::one() << 2000;
|
|
||||||
b.iter(|| {
|
|
||||||
let mut m = n.clone();
|
|
||||||
for i in 0..50 {
|
|
||||||
m = m >> i;
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn hash(b: &mut Bencher) {
|
|
||||||
use std::collections::HashSet;
|
|
||||||
let mut rng = get_rng();
|
|
||||||
let v: Vec<BigInt> = (1000..2000).map(|bits| rng.gen_bigint(bits)).collect();
|
|
||||||
b.iter(|| {
|
|
||||||
let h: HashSet<&BigInt> = v.iter().collect();
|
|
||||||
assert_eq!(h.len(), v.len());
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn pow_bench(b: &mut Bencher) {
|
|
||||||
b.iter(|| {
|
|
||||||
let upper = 100_usize;
|
|
||||||
for i in 2..upper + 1 {
|
|
||||||
for j in 2..upper + 1 {
|
|
||||||
let i_big = BigUint::from_usize(i).unwrap();
|
|
||||||
num::pow(i_big, j);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/// This modulus is the prime from the 2048-bit MODP DH group:
|
|
||||||
/// https://tools.ietf.org/html/rfc3526#section-3
|
|
||||||
const RFC3526_2048BIT_MODP_GROUP: &'static str = "\
|
|
||||||
FFFFFFFF_FFFFFFFF_C90FDAA2_2168C234_C4C6628B_80DC1CD1\
|
|
||||||
29024E08_8A67CC74_020BBEA6_3B139B22_514A0879_8E3404DD\
|
|
||||||
EF9519B3_CD3A431B_302B0A6D_F25F1437_4FE1356D_6D51C245\
|
|
||||||
E485B576_625E7EC6_F44C42E9_A637ED6B_0BFF5CB6_F406B7ED\
|
|
||||||
EE386BFB_5A899FA5_AE9F2411_7C4B1FE6_49286651_ECE45B3D\
|
|
||||||
C2007CB8_A163BF05_98DA4836_1C55D39A_69163FA8_FD24CF5F\
|
|
||||||
83655D23_DCA3AD96_1C62F356_208552BB_9ED52907_7096966D\
|
|
||||||
670C354E_4ABC9804_F1746C08_CA18217C_32905E46_2E36CE3B\
|
|
||||||
E39E772C_180E8603_9B2783A2_EC07A28F_B5C55DF0_6F4C52C9\
|
|
||||||
DE2BCBF6_95581718_3995497C_EA956AE5_15D22618_98FA0510\
|
|
||||||
15728E5A_8AACAA68_FFFFFFFF_FFFFFFFF";
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn modpow(b: &mut Bencher) {
|
|
||||||
let mut rng = get_rng();
|
|
||||||
let base = rng.gen_biguint(2048);
|
|
||||||
let e = rng.gen_biguint(2048);
|
|
||||||
let m = BigUint::from_str_radix(RFC3526_2048BIT_MODP_GROUP, 16).unwrap();
|
|
||||||
|
|
||||||
b.iter(|| base.modpow(&e, &m));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn modpow_even(b: &mut Bencher) {
|
|
||||||
let mut rng = get_rng();
|
|
||||||
let base = rng.gen_biguint(2048);
|
|
||||||
let e = rng.gen_biguint(2048);
|
|
||||||
// Make the modulus even, so monty (base-2^32) doesn't apply.
|
|
||||||
let m = BigUint::from_str_radix(RFC3526_2048BIT_MODP_GROUP, 16).unwrap() - 1u32;
|
|
||||||
|
|
||||||
b.iter(|| base.modpow(&e, &m));
|
|
||||||
}
|
|
|
@ -1,131 +0,0 @@
|
||||||
// The Computer Language Benchmarks Game
|
|
||||||
// http://benchmarksgame.alioth.debian.org/
|
|
||||||
//
|
|
||||||
// contributed by the Rust Project Developers
|
|
||||||
|
|
||||||
// Copyright (c) 2013-2014 The Rust Project Developers
|
|
||||||
//
|
|
||||||
// All rights reserved.
|
|
||||||
//
|
|
||||||
// Redistribution and use in source and binary forms, with or without
|
|
||||||
// modification, are permitted provided that the following conditions
|
|
||||||
// are met:
|
|
||||||
//
|
|
||||||
// - Redistributions of source code must retain the above copyright
|
|
||||||
// notice, this list of conditions and the following disclaimer.
|
|
||||||
//
|
|
||||||
// - Redistributions in binary form must reproduce the above copyright
|
|
||||||
// notice, this list of conditions and the following disclaimer in
|
|
||||||
// the documentation and/or other materials provided with the
|
|
||||||
// distribution.
|
|
||||||
//
|
|
||||||
// - Neither the name of "The Computer Language Benchmarks Game" nor
|
|
||||||
// the name of "The Computer Language Shootout Benchmarks" nor the
|
|
||||||
// names of its contributors may be used to endorse or promote
|
|
||||||
// products derived from this software without specific prior
|
|
||||||
// written permission.
|
|
||||||
//
|
|
||||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
||||||
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
||||||
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
||||||
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
||||||
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
||||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
||||||
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
||||||
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
||||||
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
||||||
// OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||||
|
|
||||||
extern crate num;
|
|
||||||
|
|
||||||
use std::str::FromStr;
|
|
||||||
use std::io;
|
|
||||||
|
|
||||||
use num::traits::{FromPrimitive, ToPrimitive};
|
|
||||||
use num::{BigInt, Integer, One, Zero};
|
|
||||||
|
|
||||||
struct Context {
|
|
||||||
numer: BigInt,
|
|
||||||
accum: BigInt,
|
|
||||||
denom: BigInt,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Context {
|
|
||||||
fn new() -> Context {
|
|
||||||
Context {
|
|
||||||
numer: One::one(),
|
|
||||||
accum: Zero::zero(),
|
|
||||||
denom: One::one(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn from_i32(i: i32) -> BigInt {
|
|
||||||
FromPrimitive::from_i32(i).unwrap()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn extract_digit(&self) -> i32 {
|
|
||||||
if self.numer > self.accum {return -1;}
|
|
||||||
let (q, r) =
|
|
||||||
(&self.numer * Context::from_i32(3) + &self.accum)
|
|
||||||
.div_rem(&self.denom);
|
|
||||||
if r + &self.numer >= self.denom {return -1;}
|
|
||||||
q.to_i32().unwrap()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn next_term(&mut self, k: i32) {
|
|
||||||
let y2 = Context::from_i32(k * 2 + 1);
|
|
||||||
self.accum = (&self.accum + (&self.numer << 1)) * &y2;
|
|
||||||
self.numer = &self.numer * Context::from_i32(k);
|
|
||||||
self.denom = &self.denom * y2;
|
|
||||||
}
|
|
||||||
|
|
||||||
fn eliminate_digit(&mut self, d: i32) {
|
|
||||||
let d = Context::from_i32(d);
|
|
||||||
let ten = Context::from_i32(10);
|
|
||||||
self.accum = (&self.accum - &self.denom * d) * &ten;
|
|
||||||
self.numer = &self.numer * ten;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn pidigits(n: isize, out: &mut io::Write) -> io::Result<()> {
|
|
||||||
let mut k = 0;
|
|
||||||
let mut context = Context::new();
|
|
||||||
|
|
||||||
for i in 1..(n+1) {
|
|
||||||
let mut d;
|
|
||||||
loop {
|
|
||||||
k += 1;
|
|
||||||
context.next_term(k);
|
|
||||||
d = context.extract_digit();
|
|
||||||
if d != -1 {break;}
|
|
||||||
}
|
|
||||||
|
|
||||||
try!(write!(out, "{}", d));
|
|
||||||
if i % 10 == 0 { try!(write!(out, "\t:{}\n", i)); }
|
|
||||||
|
|
||||||
context.eliminate_digit(d);
|
|
||||||
}
|
|
||||||
|
|
||||||
let m = n % 10;
|
|
||||||
if m != 0 {
|
|
||||||
for _ in m..10 { try!(write!(out, " ")); }
|
|
||||||
try!(write!(out, "\t:{}\n", n));
|
|
||||||
}
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
const DEFAULT_DIGITS: isize = 512;
|
|
||||||
|
|
||||||
fn main() {
|
|
||||||
let args = std::env::args().collect::<Vec<_>>();
|
|
||||||
let n = if args.len() < 2 {
|
|
||||||
DEFAULT_DIGITS
|
|
||||||
} else if args[1] == "--bench" {
|
|
||||||
return pidigits(DEFAULT_DIGITS, &mut std::io::sink()).unwrap()
|
|
||||||
} else {
|
|
||||||
FromStr::from_str(&args[1]).unwrap()
|
|
||||||
};
|
|
||||||
pidigits(n, &mut std::io::stdout()).unwrap();
|
|
||||||
}
|
|
|
@ -1,39 +0,0 @@
|
||||||
[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", "bignum"]
|
|
||||||
categories = [ "algorithms", "data-structures", "science" ]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
name = "num-bigint"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
version = "0.1.41"
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
|
|
||||||
[dependencies.num-integer]
|
|
||||||
path = "../integer"
|
|
||||||
version = "0.1.32"
|
|
||||||
|
|
||||||
[dependencies.num-traits]
|
|
||||||
path = "../traits"
|
|
||||||
version = "0.1.32"
|
|
||||||
|
|
||||||
[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, < 0.9.0"
|
|
||||||
|
|
||||||
[dev-dependencies.rand]
|
|
||||||
version = "0.3.14"
|
|
||||||
|
|
||||||
[features]
|
|
||||||
default = ["rand", "rustc-serialize"]
|
|
|
@ -1,201 +0,0 @@
|
||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
http://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
APPENDIX: How to apply the Apache License to your work.
|
|
||||||
|
|
||||||
To apply the Apache License to your work, attach the following
|
|
||||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
|
||||||
replaced with your own identifying information. (Don't include
|
|
||||||
the brackets!) The text should be enclosed in the appropriate
|
|
||||||
comment syntax for the file format. We also recommend that a
|
|
||||||
file or class name and description of purpose be included on the
|
|
||||||
same "printed page" as the copyright notice for easier
|
|
||||||
identification within third-party archives.
|
|
||||||
|
|
||||||
Copyright [yyyy] [name of copyright owner]
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
|
@ -1,25 +0,0 @@
|
||||||
Copyright (c) 2014 The Rust Project Developers
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any
|
|
||||||
person obtaining a copy of this software and associated
|
|
||||||
documentation files (the "Software"), to deal in the
|
|
||||||
Software without restriction, including without
|
|
||||||
limitation the rights to use, copy, modify, merge,
|
|
||||||
publish, distribute, sublicense, and/or sell copies of
|
|
||||||
the Software, and to permit persons to whom the Software
|
|
||||||
is furnished to do so, subject to the following
|
|
||||||
conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice
|
|
||||||
shall be included in all copies or substantial portions
|
|
||||||
of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
|
||||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
|
||||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
||||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
||||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
||||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
|
||||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
DEALINGS IN THE SOFTWARE.
|
|
|
@ -1,658 +0,0 @@
|
||||||
use std::borrow::Cow;
|
|
||||||
use std::cmp;
|
|
||||||
use std::cmp::Ordering::{self, Less, Greater, Equal};
|
|
||||||
use std::iter::repeat;
|
|
||||||
use std::mem;
|
|
||||||
use traits;
|
|
||||||
use traits::{Zero, One};
|
|
||||||
|
|
||||||
use biguint::BigUint;
|
|
||||||
|
|
||||||
use bigint::BigInt;
|
|
||||||
use bigint::Sign;
|
|
||||||
use bigint::Sign::{Minus, NoSign, Plus};
|
|
||||||
|
|
||||||
#[allow(non_snake_case)]
|
|
||||||
pub mod big_digit {
|
|
||||||
/// A `BigDigit` is a `BigUint`'s composing element.
|
|
||||||
pub type BigDigit = u32;
|
|
||||||
|
|
||||||
/// A `DoubleBigDigit` is the internal type used to do the computations. Its
|
|
||||||
/// size is the double of the size of `BigDigit`.
|
|
||||||
pub type DoubleBigDigit = u64;
|
|
||||||
|
|
||||||
pub const ZERO_BIG_DIGIT: BigDigit = 0;
|
|
||||||
|
|
||||||
// `DoubleBigDigit` size dependent
|
|
||||||
pub const BITS: usize = 32;
|
|
||||||
|
|
||||||
pub const BASE: DoubleBigDigit = 1 << BITS;
|
|
||||||
const LO_MASK: DoubleBigDigit = (-1i32 as DoubleBigDigit) >> BITS;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn get_hi(n: DoubleBigDigit) -> BigDigit {
|
|
||||||
(n >> BITS) as BigDigit
|
|
||||||
}
|
|
||||||
#[inline]
|
|
||||||
fn get_lo(n: DoubleBigDigit) -> BigDigit {
|
|
||||||
(n & LO_MASK) as BigDigit
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Split one `DoubleBigDigit` into two `BigDigit`s.
|
|
||||||
#[inline]
|
|
||||||
pub fn from_doublebigdigit(n: DoubleBigDigit) -> (BigDigit, BigDigit) {
|
|
||||||
(get_hi(n), get_lo(n))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Join two `BigDigit`s into one `DoubleBigDigit`
|
|
||||||
#[inline]
|
|
||||||
pub fn to_doublebigdigit(hi: BigDigit, lo: BigDigit) -> DoubleBigDigit {
|
|
||||||
(lo as DoubleBigDigit) | ((hi as DoubleBigDigit) << BITS)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
use big_digit::{BigDigit, DoubleBigDigit};
|
|
||||||
|
|
||||||
// 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));
|
|
||||||
|
|
||||||
*carry = hi;
|
|
||||||
lo
|
|
||||||
}
|
|
||||||
|
|
||||||
// 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 = (hi == 0) as BigDigit;
|
|
||||||
lo
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
pub 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));
|
|
||||||
*carry = hi;
|
|
||||||
lo
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
pub fn mul_with_carry(a: BigDigit, b: BigDigit, carry: &mut BigDigit) -> BigDigit {
|
|
||||||
let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) * (b as DoubleBigDigit) +
|
|
||||||
(*carry as DoubleBigDigit));
|
|
||||||
|
|
||||||
*carry = hi;
|
|
||||||
lo
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Divide a two digit numerator by a one digit divisor, returns quotient and remainder:
|
|
||||||
///
|
|
||||||
/// Note: the caller must ensure that both the quotient and remainder will fit into a single digit.
|
|
||||||
/// This is _not_ true for an arbitrary numerator/denominator.
|
|
||||||
///
|
|
||||||
/// (This function also matches what the x86 divide instruction does).
|
|
||||||
#[inline]
|
|
||||||
fn div_wide(hi: BigDigit, lo: BigDigit, divisor: BigDigit) -> (BigDigit, BigDigit) {
|
|
||||||
debug_assert!(hi < divisor);
|
|
||||||
|
|
||||||
let lhs = big_digit::to_doublebigdigit(hi, lo);
|
|
||||||
let rhs = divisor as DoubleBigDigit;
|
|
||||||
((lhs / rhs) as BigDigit, (lhs % rhs) as BigDigit)
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn div_rem_digit(mut a: BigUint, b: BigDigit) -> (BigUint, BigDigit) {
|
|
||||||
let mut rem = 0;
|
|
||||||
|
|
||||||
for d in a.data.iter_mut().rev() {
|
|
||||||
let (q, r) = div_wide(rem, *d, b);
|
|
||||||
*d = q;
|
|
||||||
rem = r;
|
|
||||||
}
|
|
||||||
|
|
||||||
(a.normalized(), rem)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Only for the Add impl:
|
|
||||||
#[inline]
|
|
||||||
pub fn __add2(a: &mut [BigDigit], b: &[BigDigit]) -> BigDigit {
|
|
||||||
debug_assert!(a.len() >= b.len());
|
|
||||||
|
|
||||||
let mut carry = 0;
|
|
||||||
let (a_lo, a_hi) = a.split_at_mut(b.len());
|
|
||||||
|
|
||||||
for (a, b) in a_lo.iter_mut().zip(b) {
|
|
||||||
*a = adc(*a, *b, &mut carry);
|
|
||||||
}
|
|
||||||
|
|
||||||
if carry != 0 {
|
|
||||||
for a in a_hi {
|
|
||||||
*a = adc(*a, 0, &mut carry);
|
|
||||||
if carry == 0 { break }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
carry
|
|
||||||
}
|
|
||||||
|
|
||||||
/// /Two argument addition of raw slices:
|
|
||||||
/// a += b
|
|
||||||
///
|
|
||||||
/// The caller _must_ ensure that a is big enough to store the result - typically this means
|
|
||||||
/// resizing a to max(a.len(), b.len()) + 1, to fit a possible carry.
|
|
||||||
pub fn add2(a: &mut [BigDigit], b: &[BigDigit]) {
|
|
||||||
let carry = __add2(a, b);
|
|
||||||
|
|
||||||
debug_assert!(carry == 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn sub2(a: &mut [BigDigit], b: &[BigDigit]) {
|
|
||||||
let mut borrow = 0;
|
|
||||||
|
|
||||||
let len = cmp::min(a.len(), b.len());
|
|
||||||
let (a_lo, a_hi) = a.split_at_mut(len);
|
|
||||||
let (b_lo, b_hi) = b.split_at(len);
|
|
||||||
|
|
||||||
for (a, b) in a_lo.iter_mut().zip(b_lo) {
|
|
||||||
*a = sbb(*a, *b, &mut borrow);
|
|
||||||
}
|
|
||||||
|
|
||||||
if borrow != 0 {
|
|
||||||
for a in a_hi {
|
|
||||||
*a = sbb(*a, 0, &mut borrow);
|
|
||||||
if borrow == 0 { break }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// note: we're _required_ to fail on underflow
|
|
||||||
assert!(borrow == 0 && b_hi.iter().all(|x| *x == 0),
|
|
||||||
"Cannot subtract b from a because b is larger than a.");
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn sub2rev(a: &[BigDigit], b: &mut [BigDigit]) {
|
|
||||||
debug_assert!(b.len() >= a.len());
|
|
||||||
|
|
||||||
let mut borrow = 0;
|
|
||||||
|
|
||||||
let len = cmp::min(a.len(), b.len());
|
|
||||||
let (a_lo, a_hi) = a.split_at(len);
|
|
||||||
let (b_lo, b_hi) = b.split_at_mut(len);
|
|
||||||
|
|
||||||
for (a, b) in a_lo.iter().zip(b_lo) {
|
|
||||||
*b = sbb(*a, *b, &mut borrow);
|
|
||||||
}
|
|
||||||
|
|
||||||
assert!(a_hi.is_empty());
|
|
||||||
|
|
||||||
// note: we're _required_ to fail on underflow
|
|
||||||
assert!(borrow == 0 && b_hi.iter().all(|x| *x == 0),
|
|
||||||
"Cannot subtract b from a because b is larger than a.");
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn sub_sign(a: &[BigDigit], b: &[BigDigit]) -> (Sign, BigUint) {
|
|
||||||
// Normalize:
|
|
||||||
let a = &a[..a.iter().rposition(|&x| x != 0).map_or(0, |i| i + 1)];
|
|
||||||
let b = &b[..b.iter().rposition(|&x| x != 0).map_or(0, |i| i + 1)];
|
|
||||||
|
|
||||||
match cmp_slice(a, b) {
|
|
||||||
Greater => {
|
|
||||||
let mut a = a.to_vec();
|
|
||||||
sub2(&mut a, b);
|
|
||||||
(Plus, BigUint::new(a))
|
|
||||||
}
|
|
||||||
Less => {
|
|
||||||
let mut b = b.to_vec();
|
|
||||||
sub2(&mut b, a);
|
|
||||||
(Minus, BigUint::new(b))
|
|
||||||
}
|
|
||||||
_ => (NoSign, Zero::zero()),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Three argument multiply accumulate:
|
|
||||||
/// acc += b * c
|
|
||||||
pub fn mac_digit(acc: &mut [BigDigit], b: &[BigDigit], c: BigDigit) {
|
|
||||||
if c == 0 {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
let mut carry = 0;
|
|
||||||
let (a_lo, a_hi) = acc.split_at_mut(b.len());
|
|
||||||
|
|
||||||
for (a, &b) in a_lo.iter_mut().zip(b) {
|
|
||||||
*a = mac_with_carry(*a, b, c, &mut carry);
|
|
||||||
}
|
|
||||||
|
|
||||||
let mut a = a_hi.iter_mut();
|
|
||||||
while carry != 0 {
|
|
||||||
let a = a.next().expect("carry overflow during multiplication!");
|
|
||||||
*a = adc(*a, 0, &mut carry);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// 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)
|
|
||||||
};
|
|
||||||
|
|
||||||
// We use three algorithms for different input sizes.
|
|
||||||
//
|
|
||||||
// - For small inputs, long multiplication is fastest.
|
|
||||||
// - Next we use Karatsuba multiplication (Toom-2), which we have optimized
|
|
||||||
// to avoid unnecessary allocations for intermediate values.
|
|
||||||
// - For the largest inputs we use Toom-3, which better optimizes the
|
|
||||||
// number of operations, but uses more temporary allocations.
|
|
||||||
//
|
|
||||||
// The thresholds are somewhat arbitrary, chosen by evaluating the results
|
|
||||||
// of `cargo bench --bench bigint multiply`.
|
|
||||||
|
|
||||||
if x.len() <= 32 {
|
|
||||||
// Long multiplication:
|
|
||||||
for (i, xi) in x.iter().enumerate() {
|
|
||||||
mac_digit(&mut acc[i..], y, *xi);
|
|
||||||
}
|
|
||||||
} else if x.len() <= 256 {
|
|
||||||
/*
|
|
||||||
* Karatsuba multiplication:
|
|
||||||
*
|
|
||||||
* The idea is that we break x and y up into two smaller numbers that each have about half
|
|
||||||
* as many digits, like so (note that multiplying by b is just a shift):
|
|
||||||
*
|
|
||||||
* x = x0 + x1 * b
|
|
||||||
* y = y0 + y1 * b
|
|
||||||
*
|
|
||||||
* With some algebra, we can compute x * y with three smaller products, where the inputs to
|
|
||||||
* each of the smaller products have only about half as many digits as x and y:
|
|
||||||
*
|
|
||||||
* x * y = (x0 + x1 * b) * (y0 + y1 * b)
|
|
||||||
*
|
|
||||||
* x * y = x0 * y0
|
|
||||||
* + x0 * y1 * b
|
|
||||||
* + x1 * y0 * b
|
|
||||||
* + x1 * y1 * b^2
|
|
||||||
*
|
|
||||||
* Let p0 = x0 * y0 and p2 = x1 * y1:
|
|
||||||
*
|
|
||||||
* x * y = p0
|
|
||||||
* + (x0 * y1 + x1 * y0) * b
|
|
||||||
* + p2 * b^2
|
|
||||||
*
|
|
||||||
* The real trick is that middle term:
|
|
||||||
*
|
|
||||||
* x0 * y1 + x1 * y0
|
|
||||||
*
|
|
||||||
* = x0 * y1 + x1 * y0 - p0 + p0 - p2 + p2
|
|
||||||
*
|
|
||||||
* = x0 * y1 + x1 * y0 - x0 * y0 - x1 * y1 + p0 + p2
|
|
||||||
*
|
|
||||||
* Now we complete the square:
|
|
||||||
*
|
|
||||||
* = -(x0 * y0 - x0 * y1 - x1 * y0 + x1 * y1) + p0 + p2
|
|
||||||
*
|
|
||||||
* = -((x1 - x0) * (y1 - y0)) + p0 + p2
|
|
||||||
*
|
|
||||||
* Let p1 = (x1 - x0) * (y1 - y0), and substitute back into our original formula:
|
|
||||||
*
|
|
||||||
* x * y = p0
|
|
||||||
* + (p0 + p2 - p1) * b
|
|
||||||
* + p2 * b^2
|
|
||||||
*
|
|
||||||
* Where the three intermediate products are:
|
|
||||||
*
|
|
||||||
* p0 = x0 * y0
|
|
||||||
* p1 = (x1 - x0) * (y1 - y0)
|
|
||||||
* p2 = x1 * y1
|
|
||||||
*
|
|
||||||
* In doing the computation, we take great care to avoid unnecessary temporary variables
|
|
||||||
* (since creating a BigUint requires a heap allocation): thus, we rearrange the formula a
|
|
||||||
* bit so we can use the same temporary variable for all the intermediate products:
|
|
||||||
*
|
|
||||||
* x * y = p2 * b^2 + p2 * b
|
|
||||||
* + p0 * b + p0
|
|
||||||
* - p1 * b
|
|
||||||
*
|
|
||||||
* The other trick we use is instead of doing explicit shifts, we slice acc at the
|
|
||||||
* appropriate offset when doing the add.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* When x is smaller than y, it's significantly faster to pick b such that x is split in
|
|
||||||
* half, not y:
|
|
||||||
*/
|
|
||||||
let b = x.len() / 2;
|
|
||||||
let (x0, x1) = x.split_at(b);
|
|
||||||
let (y0, y1) = y.split_at(b);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* We reuse the same BigUint for all the intermediate multiplies and have to size p
|
|
||||||
* appropriately here: x1.len() >= x0.len and y1.len() >= y0.len():
|
|
||||||
*/
|
|
||||||
let len = x1.len() + y1.len() + 1;
|
|
||||||
let mut p = BigUint { data: vec![0; len] };
|
|
||||||
|
|
||||||
// p2 = x1 * y1
|
|
||||||
mac3(&mut p.data[..], x1, y1);
|
|
||||||
|
|
||||||
// Not required, but the adds go faster if we drop any unneeded 0s from the end:
|
|
||||||
p.normalize();
|
|
||||||
|
|
||||||
add2(&mut acc[b..], &p.data[..]);
|
|
||||||
add2(&mut acc[b * 2..], &p.data[..]);
|
|
||||||
|
|
||||||
// Zero out p before the next multiply:
|
|
||||||
p.data.truncate(0);
|
|
||||||
p.data.extend(repeat(0).take(len));
|
|
||||||
|
|
||||||
// p0 = x0 * y0
|
|
||||||
mac3(&mut p.data[..], x0, y0);
|
|
||||||
p.normalize();
|
|
||||||
|
|
||||||
add2(&mut acc[..], &p.data[..]);
|
|
||||||
add2(&mut acc[b..], &p.data[..]);
|
|
||||||
|
|
||||||
// p1 = (x1 - x0) * (y1 - y0)
|
|
||||||
// We do this one last, since it may be negative and acc can't ever be negative:
|
|
||||||
let (j0_sign, j0) = sub_sign(x1, x0);
|
|
||||||
let (j1_sign, j1) = sub_sign(y1, y0);
|
|
||||||
|
|
||||||
match j0_sign * j1_sign {
|
|
||||||
Plus => {
|
|
||||||
p.data.truncate(0);
|
|
||||||
p.data.extend(repeat(0).take(len));
|
|
||||||
|
|
||||||
mac3(&mut p.data[..], &j0.data[..], &j1.data[..]);
|
|
||||||
p.normalize();
|
|
||||||
|
|
||||||
sub2(&mut acc[b..], &p.data[..]);
|
|
||||||
},
|
|
||||||
Minus => {
|
|
||||||
mac3(&mut acc[b..], &j0.data[..], &j1.data[..]);
|
|
||||||
},
|
|
||||||
NoSign => (),
|
|
||||||
}
|
|
||||||
|
|
||||||
} else {
|
|
||||||
// Toom-3 multiplication:
|
|
||||||
//
|
|
||||||
// Toom-3 is like Karatsuba above, but dividing the inputs into three parts.
|
|
||||||
// Both are instances of Toom-Cook, using `k=3` and `k=2` respectively.
|
|
||||||
//
|
|
||||||
// FIXME: It would be nice to have comments breaking down the operations below.
|
|
||||||
|
|
||||||
let i = y.len()/3 + 1;
|
|
||||||
|
|
||||||
let x0_len = cmp::min(x.len(), i);
|
|
||||||
let x1_len = cmp::min(x.len() - x0_len, i);
|
|
||||||
|
|
||||||
let y0_len = i;
|
|
||||||
let y1_len = cmp::min(y.len() - y0_len, i);
|
|
||||||
|
|
||||||
let x0 = BigInt::from_slice(Plus, &x[..x0_len]);
|
|
||||||
let x1 = BigInt::from_slice(Plus, &x[x0_len..x0_len + x1_len]);
|
|
||||||
let x2 = BigInt::from_slice(Plus, &x[x0_len + x1_len..]);
|
|
||||||
|
|
||||||
let y0 = BigInt::from_slice(Plus, &y[..y0_len]);
|
|
||||||
let y1 = BigInt::from_slice(Plus, &y[y0_len..y0_len + y1_len]);
|
|
||||||
let y2 = BigInt::from_slice(Plus, &y[y0_len + y1_len..]);
|
|
||||||
|
|
||||||
let p = &x0 + &x2;
|
|
||||||
let q = &y0 + &y2;
|
|
||||||
|
|
||||||
let p2 = &p - &x1;
|
|
||||||
let q2 = &q - &y1;
|
|
||||||
|
|
||||||
let r0 = &x0 * &y0;
|
|
||||||
let r4 = &x2 * &y2;
|
|
||||||
let r1 = (p + x1) * (q + y1);
|
|
||||||
let r2 = &p2 * &q2;
|
|
||||||
let r3 = ((p2 + x2)*2 - x0) * ((q2 + y2)*2 - y0);
|
|
||||||
|
|
||||||
let mut comp3: BigInt = (r3 - &r1) / 3;
|
|
||||||
let mut comp1: BigInt = (r1 - &r2) / 2;
|
|
||||||
let mut comp2: BigInt = r2 - &r0;
|
|
||||||
comp3 = (&comp2 - comp3)/2 + &r4*2;
|
|
||||||
comp2 = comp2 + &comp1 - &r4;
|
|
||||||
comp1 = comp1 - &comp3;
|
|
||||||
|
|
||||||
let result = r0 + (comp1 << 32*i) + (comp2 << 2*32*i) + (comp3 << 3*32*i) + (r4 << 4*32*i);
|
|
||||||
let result_pos = result.to_biguint().unwrap();
|
|
||||||
add2(&mut acc[..], &result_pos.data);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn mul3(x: &[BigDigit], y: &[BigDigit]) -> BigUint {
|
|
||||||
let len = x.len() + y.len() + 1;
|
|
||||||
let mut prod = BigUint { data: vec![0; len] };
|
|
||||||
|
|
||||||
mac3(&mut prod.data[..], x, y);
|
|
||||||
prod.normalized()
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn scalar_mul(a: &mut [BigDigit], b: BigDigit) -> BigDigit {
|
|
||||||
let mut carry = 0;
|
|
||||||
for a in a.iter_mut() {
|
|
||||||
*a = mul_with_carry(*a, b, &mut carry);
|
|
||||||
}
|
|
||||||
carry
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn div_rem(u: &BigUint, d: &BigUint) -> (BigUint, BigUint) {
|
|
||||||
if d.is_zero() {
|
|
||||||
panic!()
|
|
||||||
}
|
|
||||||
if u.is_zero() {
|
|
||||||
return (Zero::zero(), Zero::zero());
|
|
||||||
}
|
|
||||||
if *d == One::one() {
|
|
||||||
return (u.clone(), Zero::zero());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Required or the q_len calculation below can underflow:
|
|
||||||
match u.cmp(d) {
|
|
||||||
Less => return (Zero::zero(), u.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.
|
|
||||||
//
|
|
||||||
let shift = d.data.last().unwrap().leading_zeros() as usize;
|
|
||||||
let mut a = u << shift;
|
|
||||||
let b = d << 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.
|
|
||||||
//
|
|
||||||
|
|
||||||
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).
|
|
||||||
//
|
|
||||||
let mut tmp = BigUint { data: Vec::with_capacity(2) };
|
|
||||||
|
|
||||||
for j in (0..q_len).rev() {
|
|
||||||
/*
|
|
||||||
* When calculating our next guess q0, we don't need to consider the digits below j
|
|
||||||
* + b.data.len() - 1: we're guessing digit j of the quotient (i.e. q0 << j) from
|
|
||||||
* digit bn of the divisor (i.e. bn << (b.data.len() - 1) - so the product of those
|
|
||||||
* two numbers will be zero in all digits up to (j + b.data.len() - 1).
|
|
||||||
*/
|
|
||||||
let offset = j + b.data.len() - 1;
|
|
||||||
if offset >= a.data.len() {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* just avoiding a heap allocation: */
|
|
||||||
let mut a0 = tmp;
|
|
||||||
a0.data.truncate(0);
|
|
||||||
a0.data.extend(a.data[offset..].iter().cloned());
|
|
||||||
|
|
||||||
/*
|
|
||||||
* q0 << j * big_digit::BITS is our actual quotient estimate - we do the shifts
|
|
||||||
* implicitly at the end, when adding and subtracting to a and q. Not only do we
|
|
||||||
* save the cost of the shifts, the rest of the arithmetic gets to work with
|
|
||||||
* smaller numbers.
|
|
||||||
*/
|
|
||||||
let (mut q0, _) = div_rem_digit(a0, bn);
|
|
||||||
let mut prod = &b * &q0;
|
|
||||||
|
|
||||||
while cmp_slice(&prod.data[..], &a.data[j..]) == Greater {
|
|
||||||
let one: BigUint = One::one();
|
|
||||||
q0 = q0 - one;
|
|
||||||
prod = prod - &b;
|
|
||||||
}
|
|
||||||
|
|
||||||
add2(&mut q.data[j..], &q0.data[..]);
|
|
||||||
sub2(&mut a.data[j..], &prod.data[..]);
|
|
||||||
a.normalize();
|
|
||||||
|
|
||||||
tmp = q0;
|
|
||||||
}
|
|
||||||
|
|
||||||
debug_assert!(a < b);
|
|
||||||
|
|
||||||
(q.normalized(), a >> shift)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Find last set bit
|
|
||||||
/// fls(0) == 0, fls(u32::MAX) == 32
|
|
||||||
pub fn fls<T: traits::PrimInt>(v: T) -> usize {
|
|
||||||
mem::size_of::<T>() * 8 - v.leading_zeros() as usize
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn ilog2<T: traits::PrimInt>(v: T) -> usize {
|
|
||||||
fls(v) - 1
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
pub fn biguint_shl(n: Cow<BigUint>, bits: usize) -> BigUint {
|
|
||||||
let n_unit = bits / big_digit::BITS;
|
|
||||||
let mut data = match n_unit {
|
|
||||||
0 => n.into_owned().data,
|
|
||||||
_ => {
|
|
||||||
let len = n_unit + n.data.len() + 1;
|
|
||||||
let mut data = Vec::with_capacity(len);
|
|
||||||
data.extend(repeat(0).take(n_unit));
|
|
||||||
data.extend(n.data.iter().cloned());
|
|
||||||
data
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
let n_bits = bits % big_digit::BITS;
|
|
||||||
if n_bits > 0 {
|
|
||||||
let mut carry = 0;
|
|
||||||
for elem in data[n_unit..].iter_mut() {
|
|
||||||
let new_carry = *elem >> (big_digit::BITS - n_bits);
|
|
||||||
*elem = (*elem << n_bits) | carry;
|
|
||||||
carry = new_carry;
|
|
||||||
}
|
|
||||||
if carry != 0 {
|
|
||||||
data.push(carry);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
BigUint::new(data)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
pub fn biguint_shr(n: Cow<BigUint>, bits: usize) -> BigUint {
|
|
||||||
let n_unit = bits / big_digit::BITS;
|
|
||||||
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(),
|
|
||||||
};
|
|
||||||
|
|
||||||
let n_bits = bits % big_digit::BITS;
|
|
||||||
if n_bits > 0 {
|
|
||||||
let mut borrow = 0;
|
|
||||||
for elem in data.iter_mut().rev() {
|
|
||||||
let new_borrow = *elem << (big_digit::BITS - n_bits);
|
|
||||||
*elem = (*elem >> n_bits) | borrow;
|
|
||||||
borrow = new_borrow;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
BigUint::new(data)
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn cmp_slice(a: &[BigDigit], b: &[BigDigit]) -> Ordering {
|
|
||||||
debug_assert!(a.last() != Some(&0));
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (&ai, &bi) in a.iter().rev().zip(b.iter().rev()) {
|
|
||||||
if ai < bi {
|
|
||||||
return Less;
|
|
||||||
}
|
|
||||||
if ai > bi {
|
|
||||||
return Greater;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return Equal;
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod algorithm_tests {
|
|
||||||
use {BigDigit, BigUint, BigInt};
|
|
||||||
use Sign::Plus;
|
|
||||||
use traits::Num;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_sub_sign() {
|
|
||||||
use super::sub_sign;
|
|
||||||
|
|
||||||
fn sub_sign_i(a: &[BigDigit], b: &[BigDigit]) -> BigInt {
|
|
||||||
let (sign, val) = sub_sign(a, b);
|
|
||||||
BigInt::from_biguint(sign, val)
|
|
||||||
}
|
|
||||||
|
|
||||||
let a = BigUint::from_str_radix("265252859812191058636308480000000", 10).unwrap();
|
|
||||||
let b = BigUint::from_str_radix("26525285981219105863630848000000", 10).unwrap();
|
|
||||||
let a_i = BigInt::from_biguint(Plus, a.clone());
|
|
||||||
let b_i = BigInt::from_biguint(Plus, b.clone());
|
|
||||||
|
|
||||||
assert_eq!(sub_sign_i(&a.data[..], &b.data[..]), &a_i - &b_i);
|
|
||||||
assert_eq!(sub_sign_i(&b.data[..], &a.data[..]), &b_i - &a_i);
|
|
||||||
}
|
|
||||||
}
|
|
1767
bigint/src/bigint.rs
1767
bigint/src/bigint.rs
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -1,154 +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 <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.
|
|
||||||
|
|
||||||
//! A Big integer (signed version: `BigInt`, unsigned version: `BigUint`).
|
|
||||||
//!
|
|
||||||
//! A `BigUint` is represented as a vector of `BigDigit`s.
|
|
||||||
//! A `BigInt` is a combination of `BigUint` and `Sign`.
|
|
||||||
//!
|
|
||||||
//! Common numerical operations are overloaded, so we can treat them
|
|
||||||
//! the same way we treat other numbers.
|
|
||||||
//!
|
|
||||||
//! ## Example
|
|
||||||
//!
|
|
||||||
//! ```rust
|
|
||||||
//! 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.
|
|
||||||
//! fn fib(n: usize) -> BigUint {
|
|
||||||
//! let mut f0: BigUint = Zero::zero();
|
|
||||||
//! let mut f1: BigUint = One::one();
|
|
||||||
//! for _ in 0..n {
|
|
||||||
//! let f2 = f0 + &f1;
|
|
||||||
//! // This is a low cost way of swapping f0 with f1 and f1 with f2.
|
|
||||||
//! f0 = replace(&mut f1, f2);
|
|
||||||
//! }
|
|
||||||
//! f0
|
|
||||||
//! }
|
|
||||||
//!
|
|
||||||
//! // 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_bigint as bigint;
|
|
||||||
//!
|
|
||||||
//! # #[cfg(feature = "rand")]
|
|
||||||
//! # fn main() {
|
|
||||||
//! use bigint::{ToBigInt, RandBigInt};
|
|
||||||
//!
|
|
||||||
//! let mut rng = rand::thread_rng();
|
|
||||||
//! let a = rng.gen_bigint(1000);
|
|
||||||
//!
|
|
||||||
//! let low = -10000.to_bigint().unwrap();
|
|
||||||
//! let high = 10000.to_bigint().unwrap();
|
|
||||||
//! let b = rng.gen_bigint_range(&low, &high);
|
|
||||||
//!
|
|
||||||
//! // Probably an even larger number.
|
|
||||||
//! println!("{}", a * b);
|
|
||||||
//! # }
|
|
||||||
//!
|
|
||||||
//! # #[cfg(not(feature = "rand"))]
|
|
||||||
//! # fn main() {
|
|
||||||
//! # }
|
|
||||||
//! ```
|
|
||||||
#![doc(html_logo_url = "https://rust-num.github.io/num/rust-logo-128x128-blk-v2.png",
|
|
||||||
html_favicon_url = "https://rust-num.github.io/num/favicon.ico",
|
|
||||||
html_root_url = "https://rust-num.github.io/num/",
|
|
||||||
html_playground_url = "http://play.integer32.com/")]
|
|
||||||
|
|
||||||
#[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::error::Error;
|
|
||||||
use std::num::ParseIntError;
|
|
||||||
use std::fmt;
|
|
||||||
|
|
||||||
#[cfg(target_pointer_width = "32")]
|
|
||||||
type UsizePromotion = u32;
|
|
||||||
#[cfg(target_pointer_width = "64")]
|
|
||||||
type UsizePromotion = u64;
|
|
||||||
|
|
||||||
#[cfg(target_pointer_width = "32")]
|
|
||||||
type IsizePromotion = i32;
|
|
||||||
#[cfg(target_pointer_width = "64")]
|
|
||||||
type IsizePromotion = i64;
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq)]
|
|
||||||
pub enum ParseBigIntError {
|
|
||||||
ParseInt(ParseIntError),
|
|
||||||
Other,
|
|
||||||
}
|
|
||||||
|
|
||||||
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),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Error for ParseBigIntError {
|
|
||||||
fn description(&self) -> &str {
|
|
||||||
"failed to parse bigint/biguint"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<ParseIntError> for ParseBigIntError {
|
|
||||||
fn from(err: ParseIntError) -> ParseBigIntError {
|
|
||||||
ParseBigIntError::ParseInt(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
use std::hash;
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
fn hash<T: hash::Hash>(x: &T) -> u64 {
|
|
||||||
use std::hash::{BuildHasher, Hasher};
|
|
||||||
use std::collections::hash_map::RandomState;
|
|
||||||
let mut hasher = <RandomState as BuildHasher>::Hasher::new();
|
|
||||||
x.hash(&mut hasher);
|
|
||||||
hasher.finish()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[macro_use]
|
|
||||||
mod macros;
|
|
||||||
|
|
||||||
mod biguint;
|
|
||||||
mod bigint;
|
|
||||||
|
|
||||||
pub use biguint::BigUint;
|
|
||||||
pub use biguint::ToBigUint;
|
|
||||||
pub use biguint::big_digit;
|
|
||||||
pub use biguint::big_digit::{BigDigit, DoubleBigDigit, ZERO_BIG_DIGIT};
|
|
||||||
|
|
||||||
pub use bigint::Sign;
|
|
||||||
pub use bigint::BigInt;
|
|
||||||
pub use bigint::ToBigInt;
|
|
||||||
pub use bigint::RandBigInt;
|
|
|
@ -1,316 +0,0 @@
|
||||||
#![allow(unknown_lints)] // older rustc doesn't know `unused_macros`
|
|
||||||
#![allow(unused_macros)]
|
|
||||||
|
|
||||||
macro_rules! forward_val_val_binop {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
impl $imp<$res> for $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: $res) -> $res {
|
|
||||||
// forward to val-ref
|
|
||||||
$imp::$method(self, &other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_val_val_binop_commutative {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
impl $imp<$res> for $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: $res) -> $res {
|
|
||||||
// forward to val-ref, with the larger capacity as val
|
|
||||||
if self.data.capacity() >= other.data.capacity() {
|
|
||||||
$imp::$method(self, &other)
|
|
||||||
} else {
|
|
||||||
$imp::$method(other, &self)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_ref_val_binop {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
impl<'a> $imp<$res> for &'a $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: $res) -> $res {
|
|
||||||
// forward to ref-ref
|
|
||||||
$imp::$method(self, &other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_ref_val_binop_commutative {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
impl<'a> $imp<$res> for &'a $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: $res) -> $res {
|
|
||||||
// reverse, forward to val-ref
|
|
||||||
$imp::$method(other, self)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_val_ref_binop {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
impl<'a> $imp<&'a $res> for $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: &$res) -> $res {
|
|
||||||
// forward to ref-ref
|
|
||||||
$imp::$method(&self, other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_ref_ref_binop {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
impl<'a, 'b> $imp<&'b $res> for &'a $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: &$res) -> $res {
|
|
||||||
// forward to val-ref
|
|
||||||
$imp::$method(self.clone(), other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_ref_ref_binop_commutative {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
impl<'a, 'b> $imp<&'b $res> for &'a $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: &$res) -> $res {
|
|
||||||
// forward to val-ref, choosing the larger to clone
|
|
||||||
if self.data.len() >= other.data.len() {
|
|
||||||
$imp::$method(self.clone(), other)
|
|
||||||
} else {
|
|
||||||
$imp::$method(other.clone(), self)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_val_assign {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
impl $imp<$res> for $res {
|
|
||||||
#[inline]
|
|
||||||
fn $method(&mut self, other: $res) {
|
|
||||||
self.$method(&other);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
macro_rules! forward_val_assign_scalar {
|
|
||||||
(impl $imp:ident for $res:ty, $scalar:ty, $method:ident) => {
|
|
||||||
impl $imp<$res> for $scalar {
|
|
||||||
#[inline]
|
|
||||||
fn $method(&mut self, other: $res) {
|
|
||||||
self.$method(&other);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_scalar_val_val_binop_commutative {
|
|
||||||
(impl $imp:ident<$scalar:ty> for $res:ty, $method: ident) => {
|
|
||||||
impl $imp<$res> for $scalar {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: $res) -> $res {
|
|
||||||
$imp::$method(other, self)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_scalar_val_ref_binop {
|
|
||||||
(impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
|
|
||||||
impl<'a> $imp<&'a $scalar> for $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: &$scalar) -> $res {
|
|
||||||
$imp::$method(self, *other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> $imp<$res> for &'a $scalar {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: $res) -> $res {
|
|
||||||
$imp::$method(*self, other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_scalar_ref_val_binop {
|
|
||||||
(impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
|
|
||||||
impl<'a> $imp<$scalar> for &'a $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: $scalar) -> $res {
|
|
||||||
$imp::$method(self.clone(), other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> $imp<&'a $res> for $scalar {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: &$res) -> $res {
|
|
||||||
$imp::$method(self, other.clone())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_scalar_ref_ref_binop {
|
|
||||||
(impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
|
|
||||||
impl<'a, 'b> $imp<&'b $scalar> for &'a $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: &$scalar) -> $res {
|
|
||||||
$imp::$method(self.clone(), *other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a, 'b> $imp<&'a $res> for &'b $scalar {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: &$res) -> $res {
|
|
||||||
$imp::$method(*self, other.clone())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! promote_scalars {
|
|
||||||
(impl $imp:ident<$promo:ty> for $res:ty, $method:ident, $( $scalar:ty ),*) => {
|
|
||||||
$(
|
|
||||||
forward_all_scalar_binop_to_val_val!(impl $imp<$scalar> for $res, $method);
|
|
||||||
|
|
||||||
impl $imp<$scalar> for $res {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: $scalar) -> $res {
|
|
||||||
$imp::$method(self, other as $promo)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl $imp<$res> for $scalar {
|
|
||||||
type Output = $res;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn $method(self, other: $res) -> $res {
|
|
||||||
$imp::$method(self as $promo, other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)*
|
|
||||||
}
|
|
||||||
}
|
|
||||||
macro_rules! promote_scalars_assign {
|
|
||||||
(impl $imp:ident<$promo:ty> for $res:ty, $method:ident, $( $scalar:ty ),*) => {
|
|
||||||
$(
|
|
||||||
impl $imp<$scalar> for $res {
|
|
||||||
#[inline]
|
|
||||||
fn $method(&mut self, other: $scalar) {
|
|
||||||
self.$method(other as $promo);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)*
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! promote_unsigned_scalars {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
promote_scalars!(impl $imp<u32> for $res, $method, u8, u16);
|
|
||||||
promote_scalars!(impl $imp<UsizePromotion> for $res, $method, usize);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! promote_unsigned_scalars_assign {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
promote_scalars_assign!(impl $imp<u32> for $res, $method, u8, u16);
|
|
||||||
promote_scalars_assign!(impl $imp<UsizePromotion> for $res, $method, usize);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! promote_signed_scalars {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
promote_scalars!(impl $imp<i32> for $res, $method, i8, i16);
|
|
||||||
promote_scalars!(impl $imp<IsizePromotion> for $res, $method, isize);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Forward everything to ref-ref, when reusing storage is not helpful
|
|
||||||
macro_rules! forward_all_binop_to_ref_ref {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
forward_val_val_binop!(impl $imp for $res, $method);
|
|
||||||
forward_val_ref_binop!(impl $imp for $res, $method);
|
|
||||||
forward_ref_val_binop!(impl $imp for $res, $method);
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
// Forward everything to val-ref, so LHS storage can be reused
|
|
||||||
macro_rules! forward_all_binop_to_val_ref {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
forward_val_val_binop!(impl $imp for $res, $method);
|
|
||||||
forward_ref_val_binop!(impl $imp for $res, $method);
|
|
||||||
forward_ref_ref_binop!(impl $imp for $res, $method);
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
// Forward everything to val-ref, commutatively, so either LHS or RHS storage can be reused
|
|
||||||
macro_rules! forward_all_binop_to_val_ref_commutative {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
forward_val_val_binop_commutative!(impl $imp for $res, $method);
|
|
||||||
forward_ref_val_binop_commutative!(impl $imp for $res, $method);
|
|
||||||
forward_ref_ref_binop_commutative!(impl $imp for $res, $method);
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_all_scalar_binop_to_val_val {
|
|
||||||
(impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
|
|
||||||
forward_scalar_val_ref_binop!(impl $imp<$scalar> for $res, $method);
|
|
||||||
forward_scalar_ref_val_binop!(impl $imp<$scalar> for $res, $method);
|
|
||||||
forward_scalar_ref_ref_binop!(impl $imp<$scalar> for $res, $method);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! forward_all_scalar_binop_to_val_val_commutative {
|
|
||||||
(impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
|
|
||||||
forward_scalar_val_val_binop_commutative!(impl $imp<$scalar> for $res, $method);
|
|
||||||
forward_all_scalar_binop_to_val_val!(impl $imp<$scalar> for $res, $method);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! promote_all_scalars {
|
|
||||||
(impl $imp:ident for $res:ty, $method:ident) => {
|
|
||||||
promote_unsigned_scalars!(impl $imp for $res, $method);
|
|
||||||
promote_signed_scalars!(impl $imp for $res, $method);
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,127 +0,0 @@
|
||||||
use integer::Integer;
|
|
||||||
use traits::Zero;
|
|
||||||
|
|
||||||
use biguint::BigUint;
|
|
||||||
|
|
||||||
struct MontyReducer<'a> {
|
|
||||||
n: &'a BigUint,
|
|
||||||
n0inv: u32
|
|
||||||
}
|
|
||||||
|
|
||||||
// Calculate the modular inverse of `num`, using Extended GCD.
|
|
||||||
//
|
|
||||||
// Reference:
|
|
||||||
// Brent & Zimmermann, Modern Computer Arithmetic, v0.5.9, Algorithm 1.20
|
|
||||||
fn inv_mod_u32(num: u32) -> u32 {
|
|
||||||
// num needs to be relatively prime to 2**32 -- i.e. it must be odd.
|
|
||||||
assert!(num % 2 != 0);
|
|
||||||
|
|
||||||
let mut a: i64 = num as i64;
|
|
||||||
let mut b: i64 = (u32::max_value() as i64) + 1;
|
|
||||||
|
|
||||||
// ExtendedGcd
|
|
||||||
// Input: positive integers a and b
|
|
||||||
// Output: integers (g, u, v) such that g = gcd(a, b) = ua + vb
|
|
||||||
// As we don't need v for modular inverse, we don't calculate it.
|
|
||||||
|
|
||||||
// 1: (u, w) <- (1, 0)
|
|
||||||
let mut u = 1;
|
|
||||||
let mut w = 0;
|
|
||||||
// 3: while b != 0
|
|
||||||
while b != 0 {
|
|
||||||
// 4: (q, r) <- DivRem(a, b)
|
|
||||||
let q = a / b;
|
|
||||||
let r = a % b;
|
|
||||||
// 5: (a, b) <- (b, r)
|
|
||||||
a = b; b = r;
|
|
||||||
// 6: (u, w) <- (w, u - qw)
|
|
||||||
let m = u - w*q;
|
|
||||||
u = w; w = m;
|
|
||||||
}
|
|
||||||
|
|
||||||
assert!(a == 1);
|
|
||||||
// Downcasting acts like a mod 2^32 too.
|
|
||||||
u as u32
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> MontyReducer<'a> {
|
|
||||||
fn new(n: &'a BigUint) -> Self {
|
|
||||||
let n0inv = inv_mod_u32(n.data[0]);
|
|
||||||
MontyReducer { n: n, n0inv: n0inv }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Montgomery Reduction
|
|
||||||
//
|
|
||||||
// Reference:
|
|
||||||
// Brent & Zimmermann, Modern Computer Arithmetic, v0.5.9, Algorithm 2.6
|
|
||||||
fn monty_redc(a: BigUint, mr: &MontyReducer) -> BigUint {
|
|
||||||
let mut c = a.data;
|
|
||||||
let n = &mr.n.data;
|
|
||||||
let n_size = n.len();
|
|
||||||
|
|
||||||
// Allocate sufficient work space
|
|
||||||
c.resize(2 * n_size + 2, 0);
|
|
||||||
|
|
||||||
// β is the size of a word, in this case 32 bits. So "a mod β" is
|
|
||||||
// equivalent to masking a to 32 bits.
|
|
||||||
// mu <- -N^(-1) mod β
|
|
||||||
let mu = 0u32.wrapping_sub(mr.n0inv);
|
|
||||||
|
|
||||||
// 1: for i = 0 to (n-1)
|
|
||||||
for i in 0..n_size {
|
|
||||||
// 2: q_i <- mu*c_i mod β
|
|
||||||
let q_i = c[i].wrapping_mul(mu);
|
|
||||||
|
|
||||||
// 3: C <- C + q_i * N * β^i
|
|
||||||
super::algorithms::mac_digit(&mut c[i..], n, q_i);
|
|
||||||
}
|
|
||||||
|
|
||||||
// 4: R <- C * β^(-n)
|
|
||||||
// This is an n-word bitshift, equivalent to skipping n words.
|
|
||||||
let ret = BigUint::new(c[n_size..].to_vec());
|
|
||||||
|
|
||||||
// 5: if R >= β^n then return R-N else return R.
|
|
||||||
if &ret < mr.n {
|
|
||||||
ret
|
|
||||||
} else {
|
|
||||||
ret - mr.n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Montgomery Multiplication
|
|
||||||
fn monty_mult(a: BigUint, b: &BigUint, mr: &MontyReducer) -> BigUint {
|
|
||||||
monty_redc(a * b, mr)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Montgomery Squaring
|
|
||||||
fn monty_sqr(a: BigUint, mr: &MontyReducer) -> BigUint {
|
|
||||||
// TODO: Replace with an optimised squaring function
|
|
||||||
monty_redc(&a * &a, mr)
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn monty_modpow(a: &BigUint, exp: &BigUint, modulus: &BigUint) -> BigUint{
|
|
||||||
let mr = MontyReducer::new(modulus);
|
|
||||||
|
|
||||||
// Calculate the Montgomery parameter
|
|
||||||
let mut v = vec![0; modulus.data.len()];
|
|
||||||
v.push(1);
|
|
||||||
let r = BigUint::new(v);
|
|
||||||
|
|
||||||
// Map the base to the Montgomery domain
|
|
||||||
let mut apri = a * &r % modulus;
|
|
||||||
|
|
||||||
// Binary exponentiation
|
|
||||||
let mut ans = &r % modulus;
|
|
||||||
let mut e = exp.clone();
|
|
||||||
while !e.is_zero() {
|
|
||||||
if e.is_odd() {
|
|
||||||
ans = monty_mult(ans, &apri, &mr);
|
|
||||||
}
|
|
||||||
apri = monty_sqr(apri, &mr);
|
|
||||||
e = e >> 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Map the result back to the residues domain
|
|
||||||
monty_redc(ans, &mr)
|
|
||||||
}
|
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -1 +0,0 @@
|
||||||
/deploy
|
|
BIN
ci/deploy.enc
BIN
ci/deploy.enc
Binary file not shown.
12
ci/deploy.sh
12
ci/deploy.sh
|
@ -1,12 +0,0 @@
|
||||||
#!/bin/sh
|
|
||||||
|
|
||||||
set -ex
|
|
||||||
|
|
||||||
cp doc/* target/doc/
|
|
||||||
pip install ghp-import --user
|
|
||||||
$HOME/.local/bin/ghp-import -n target/doc
|
|
||||||
|
|
||||||
openssl aes-256-cbc -K $encrypted_9e86330b283d_key -iv $encrypted_9e86330b283d_iv -in ./ci/deploy.enc -out ./ci/deploy -d
|
|
||||||
chmod 600 ./ci/deploy
|
|
||||||
ssh-add ./ci/deploy
|
|
||||||
git push -qf ssh://git@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
|
|
10
ci/rustup.sh
10
ci/rustup.sh
|
@ -1,18 +1,12 @@
|
||||||
#!/bin/sh
|
#!/bin/sh
|
||||||
# Use rustup to locally run the same suite of tests as .travis.yml.
|
# Use rustup to locally run the same suite of tests as .travis.yml.
|
||||||
# (You should first install/update 1.8.0, 1.15.0, beta, and nightly.)
|
# (You should first install/update 1.8.0, stable, beta, and nightly.)
|
||||||
|
|
||||||
set -ex
|
set -ex
|
||||||
|
|
||||||
export TRAVIS_RUST_VERSION
|
export TRAVIS_RUST_VERSION
|
||||||
for TRAVIS_RUST_VERSION in 1.8.0 1.15.0 beta nightly; do
|
for TRAVIS_RUST_VERSION in 1.8.0 stable beta nightly; do
|
||||||
run="rustup run $TRAVIS_RUST_VERSION"
|
run="rustup run $TRAVIS_RUST_VERSION"
|
||||||
if [ "$TRAVIS_RUST_VERSION" = 1.8.0 ]; then
|
|
||||||
# libc 0.2.34 started using #[deprecated]
|
|
||||||
$run cargo generate-lockfile
|
|
||||||
$run cargo update --package libc --precise 0.2.33 || :
|
|
||||||
fi
|
|
||||||
$run cargo build --verbose
|
$run cargo build --verbose
|
||||||
$run $PWD/ci/test_full.sh
|
$run $PWD/ci/test_full.sh
|
||||||
$run cargo doc
|
|
||||||
done
|
done
|
||||||
|
|
|
@ -2,49 +2,10 @@
|
||||||
|
|
||||||
set -ex
|
set -ex
|
||||||
|
|
||||||
echo Testing num on rustc ${TRAVIS_RUST_VERSION}
|
echo Testing num-traits on rustc ${TRAVIS_RUST_VERSION}
|
||||||
|
|
||||||
# All of these packages should build and test everywhere.
|
# num-integer should build and test everywhere.
|
||||||
for package in bigint complex integer iter rational traits; do
|
cargo build --verbose
|
||||||
if [ "$TRAVIS_RUST_VERSION" = 1.8.0 ]; then
|
cargo test --verbose
|
||||||
# libc 0.2.34 started using #[deprecated]
|
|
||||||
cargo generate-lockfile --manifest-path $package/Cargo.toml
|
|
||||||
cargo update --manifest-path $package/Cargo.toml --package libc --precise 0.2.33 || :
|
|
||||||
fi
|
|
||||||
cargo build --manifest-path $package/Cargo.toml
|
|
||||||
cargo test --manifest-path $package/Cargo.toml
|
|
||||||
done
|
|
||||||
|
|
||||||
# They all should build with minimal features too
|
# We have no features to test...
|
||||||
for package in bigint complex integer iter rational traits; do
|
|
||||||
cargo build --manifest-path $package/Cargo.toml --no-default-features
|
|
||||||
cargo test --manifest-path $package/Cargo.toml --no-default-features
|
|
||||||
done
|
|
||||||
|
|
||||||
# Each isolated feature should also work everywhere.
|
|
||||||
for feature in '' bigint rational complex; do
|
|
||||||
cargo build --verbose --no-default-features --features="$feature"
|
|
||||||
cargo test --verbose --no-default-features --features="$feature"
|
|
||||||
done
|
|
||||||
|
|
||||||
# Build test for the serde feature
|
|
||||||
cargo build --verbose --features "serde"
|
|
||||||
|
|
||||||
# Downgrade serde and build test the 0.7.0 channel as well
|
|
||||||
cargo update -p serde --precise 0.7.0
|
|
||||||
cargo build --verbose --features "serde"
|
|
||||||
|
|
||||||
|
|
||||||
if [ "$TRAVIS_RUST_VERSION" = 1.8.0 ]; then exit; fi
|
|
||||||
|
|
||||||
# num-derive should build on 1.15.0+
|
|
||||||
cargo build --verbose --manifest-path=derive/Cargo.toml
|
|
||||||
|
|
||||||
|
|
||||||
if [ "$TRAVIS_RUST_VERSION" != nightly ]; then exit; fi
|
|
||||||
|
|
||||||
# num-derive testing requires compiletest_rs, which requires nightly
|
|
||||||
cargo test --verbose --manifest-path=derive/Cargo.toml
|
|
||||||
|
|
||||||
# benchmarks only work on nightly
|
|
||||||
cargo bench --verbose
|
|
||||||
|
|
|
@ -1,30 +0,0 @@
|
||||||
[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"]
|
|
||||||
categories = [ "algorithms", "data-structures", "science" ]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
name = "num-complex"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
version = "0.1.41"
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
|
|
||||||
[dependencies.num-traits]
|
|
||||||
optional = false
|
|
||||||
path = "../traits"
|
|
||||||
version = "0.1.39"
|
|
||||||
|
|
||||||
[dependencies.rustc-serialize]
|
|
||||||
optional = true
|
|
||||||
version = "0.3.19"
|
|
||||||
|
|
||||||
[dependencies.serde]
|
|
||||||
optional = true
|
|
||||||
version = ">= 0.7.0, < 0.9.0"
|
|
||||||
|
|
||||||
[features]
|
|
||||||
default = ["rustc-serialize"]
|
|
||||||
unstable = []
|
|
|
@ -1,201 +0,0 @@
|
||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
http://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
APPENDIX: How to apply the Apache License to your work.
|
|
||||||
|
|
||||||
To apply the Apache License to your work, attach the following
|
|
||||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
|
||||||
replaced with your own identifying information. (Don't include
|
|
||||||
the brackets!) The text should be enclosed in the appropriate
|
|
||||||
comment syntax for the file format. We also recommend that a
|
|
||||||
file or class name and description of purpose be included on the
|
|
||||||
same "printed page" as the copyright notice for easier
|
|
||||||
identification within third-party archives.
|
|
||||||
|
|
||||||
Copyright [yyyy] [name of copyright owner]
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
|
@ -1,25 +0,0 @@
|
||||||
Copyright (c) 2014 The Rust Project Developers
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any
|
|
||||||
person obtaining a copy of this software and associated
|
|
||||||
documentation files (the "Software"), to deal in the
|
|
||||||
Software without restriction, including without
|
|
||||||
limitation the rights to use, copy, modify, merge,
|
|
||||||
publish, distribute, sublicense, and/or sell copies of
|
|
||||||
the Software, and to permit persons to whom the Software
|
|
||||||
is furnished to do so, subject to the following
|
|
||||||
conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice
|
|
||||||
shall be included in all copies or substantial portions
|
|
||||||
of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
|
||||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
|
||||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
||||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
||||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
||||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
|
||||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
DEALINGS IN THE SOFTWARE.
|
|
1899
complex/src/lib.rs
1899
complex/src/lib.rs
File diff suppressed because it is too large
Load Diff
|
@ -1,27 +0,0 @@
|
||||||
[package]
|
|
||||||
authors = ["The Rust Project Developers"]
|
|
||||||
description = "Numeric syntax extensions"
|
|
||||||
documentation = "http://rust-num.github.io/num"
|
|
||||||
homepage = "https://github.com/rust-num/num"
|
|
||||||
keywords = ["mathematics", "numerics"]
|
|
||||||
categories = [ "science" ]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
name = "num-derive"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
version = "0.1.41"
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
quote = "0.1.3"
|
|
||||||
syn = "0.7.0"
|
|
||||||
|
|
||||||
[dev-dependencies]
|
|
||||||
compiletest_rs = "0.2.5"
|
|
||||||
|
|
||||||
[dev-dependencies.num]
|
|
||||||
path = ".."
|
|
||||||
version = "0.1"
|
|
||||||
|
|
||||||
[lib]
|
|
||||||
name = "num_derive"
|
|
||||||
proc-macro = true
|
|
||||||
test = false
|
|
|
@ -1,201 +0,0 @@
|
||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
http://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
APPENDIX: How to apply the Apache License to your work.
|
|
||||||
|
|
||||||
To apply the Apache License to your work, attach the following
|
|
||||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
|
||||||
replaced with your own identifying information. (Don't include
|
|
||||||
the brackets!) The text should be enclosed in the appropriate
|
|
||||||
comment syntax for the file format. We also recommend that a
|
|
||||||
file or class name and description of purpose be included on the
|
|
||||||
same "printed page" as the copyright notice for easier
|
|
||||||
identification within third-party archives.
|
|
||||||
|
|
||||||
Copyright [yyyy] [name of copyright owner]
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
|
@ -1,25 +0,0 @@
|
||||||
Copyright (c) 2014 The Rust Project Developers
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any
|
|
||||||
person obtaining a copy of this software and associated
|
|
||||||
documentation files (the "Software"), to deal in the
|
|
||||||
Software without restriction, including without
|
|
||||||
limitation the rights to use, copy, modify, merge,
|
|
||||||
publish, distribute, sublicense, and/or sell copies of
|
|
||||||
the Software, and to permit persons to whom the Software
|
|
||||||
is furnished to do so, subject to the following
|
|
||||||
conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice
|
|
||||||
shall be included in all copies or substantial portions
|
|
||||||
of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
|
||||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
|
||||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
||||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
||||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
||||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
|
||||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
DEALINGS IN THE SOFTWARE.
|
|
|
@ -1,118 +0,0 @@
|
||||||
// Copyright 2012-2015 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.
|
|
||||||
|
|
||||||
#![crate_type = "proc-macro"]
|
|
||||||
|
|
||||||
extern crate syn;
|
|
||||||
#[macro_use]
|
|
||||||
extern crate quote;
|
|
||||||
extern crate proc_macro;
|
|
||||||
|
|
||||||
use proc_macro::TokenStream;
|
|
||||||
|
|
||||||
use syn::Body::Enum;
|
|
||||||
use syn::VariantData::Unit;
|
|
||||||
|
|
||||||
#[proc_macro_derive(FromPrimitive)]
|
|
||||||
pub fn from_primitive(input: TokenStream) -> TokenStream {
|
|
||||||
let source = input.to_string();
|
|
||||||
|
|
||||||
let ast = syn::parse_macro_input(&source).unwrap();
|
|
||||||
let name = &ast.ident;
|
|
||||||
|
|
||||||
let variants = match ast.body {
|
|
||||||
Enum(ref variants) => variants,
|
|
||||||
_ => panic!("`FromPrimitive` can be applied only to the enums, {} is not an enum", name)
|
|
||||||
};
|
|
||||||
|
|
||||||
let mut idx = 0;
|
|
||||||
let variants: Vec<_> = variants.iter()
|
|
||||||
.map(|variant| {
|
|
||||||
let ident = &variant.ident;
|
|
||||||
match variant.data {
|
|
||||||
Unit => (),
|
|
||||||
_ => {
|
|
||||||
panic!("`FromPrimitive` can be applied only to unitary enums, {}::{} is either struct or tuple", name, ident)
|
|
||||||
},
|
|
||||||
}
|
|
||||||
if let Some(val) = variant.discriminant {
|
|
||||||
idx = val.value;
|
|
||||||
}
|
|
||||||
let tt = quote!(#idx => Some(#name::#ident));
|
|
||||||
idx += 1;
|
|
||||||
tt
|
|
||||||
})
|
|
||||||
.collect();
|
|
||||||
|
|
||||||
let res = quote! {
|
|
||||||
impl ::num::traits::FromPrimitive for #name {
|
|
||||||
fn from_i64(n: i64) -> Option<Self> {
|
|
||||||
Self::from_u64(n as u64)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn from_u64(n: u64) -> Option<Self> {
|
|
||||||
match n {
|
|
||||||
#(variants,)*
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
res.to_string().parse().unwrap()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[proc_macro_derive(ToPrimitive)]
|
|
||||||
pub fn to_primitive(input: TokenStream) -> TokenStream {
|
|
||||||
let source = input.to_string();
|
|
||||||
|
|
||||||
let ast = syn::parse_macro_input(&source).unwrap();
|
|
||||||
let name = &ast.ident;
|
|
||||||
|
|
||||||
let variants = match ast.body {
|
|
||||||
Enum(ref variants) => variants,
|
|
||||||
_ => panic!("`ToPrimitive` can be applied only to the enums, {} is not an enum", name)
|
|
||||||
};
|
|
||||||
|
|
||||||
let mut idx = 0;
|
|
||||||
let variants: Vec<_> = variants.iter()
|
|
||||||
.map(|variant| {
|
|
||||||
let ident = &variant.ident;
|
|
||||||
match variant.data {
|
|
||||||
Unit => (),
|
|
||||||
_ => {
|
|
||||||
panic!("`ToPrimitive` can be applied only to unitary enums, {}::{} is either struct or tuple", name, ident)
|
|
||||||
},
|
|
||||||
}
|
|
||||||
if let Some(val) = variant.discriminant {
|
|
||||||
idx = val.value;
|
|
||||||
}
|
|
||||||
let tt = quote!(#name::#ident => #idx);
|
|
||||||
idx += 1;
|
|
||||||
tt
|
|
||||||
})
|
|
||||||
.collect();
|
|
||||||
|
|
||||||
let res = quote! {
|
|
||||||
impl ::num::traits::ToPrimitive for #name {
|
|
||||||
fn to_i64(&self) -> Option<i64> {
|
|
||||||
self.to_u64().map(|x| x as i64)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn to_u64(&self) -> Option<u64> {
|
|
||||||
Some(match *self {
|
|
||||||
#(variants,)*
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
res.to_string().parse().unwrap()
|
|
||||||
}
|
|
|
@ -1,22 +0,0 @@
|
||||||
// Copyright 2013-2015 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.
|
|
||||||
|
|
||||||
extern crate num;
|
|
||||||
#[macro_use]
|
|
||||||
extern crate num_derive;
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, FromPrimitive)] //~ ERROR
|
|
||||||
struct Color {
|
|
||||||
r: u8,
|
|
||||||
g: u8,
|
|
||||||
b: u8,
|
|
||||||
}
|
|
||||||
|
|
||||||
fn main() {}
|
|
|
@ -1,21 +0,0 @@
|
||||||
// Copyright 2013-2015 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.
|
|
||||||
|
|
||||||
extern crate num;
|
|
||||||
#[macro_use]
|
|
||||||
extern crate num_derive;
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, FromPrimitive)] //~ ERROR
|
|
||||||
enum Color {
|
|
||||||
Rgb(u8, u8, u8),
|
|
||||||
Hsv(u8, u8, u8),
|
|
||||||
}
|
|
||||||
|
|
||||||
fn main() {}
|
|
|
@ -1,22 +0,0 @@
|
||||||
// Copyright 2013-2015 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.
|
|
||||||
|
|
||||||
extern crate num;
|
|
||||||
#[macro_use]
|
|
||||||
extern crate num_derive;
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, ToPrimitive)] //~ ERROR
|
|
||||||
struct Color {
|
|
||||||
r: u8,
|
|
||||||
g: u8,
|
|
||||||
b: u8,
|
|
||||||
}
|
|
||||||
|
|
||||||
fn main() {}
|
|
|
@ -1,21 +0,0 @@
|
||||||
// Copyright 2013-2015 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.
|
|
||||||
|
|
||||||
extern crate num;
|
|
||||||
#[macro_use]
|
|
||||||
extern crate num_derive;
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, ToPrimitive)] //~ ERROR
|
|
||||||
enum Color {
|
|
||||||
Rgb(u8, u8, u8),
|
|
||||||
Hsv(u8, u8, u8),
|
|
||||||
}
|
|
||||||
|
|
||||||
fn main() {}
|
|
|
@ -1,25 +0,0 @@
|
||||||
extern crate compiletest_rs as compiletest;
|
|
||||||
|
|
||||||
use std::path::PathBuf;
|
|
||||||
use std::env::var;
|
|
||||||
|
|
||||||
fn run_mode(mode: &'static str) {
|
|
||||||
let mut config = compiletest::default_config();
|
|
||||||
|
|
||||||
let cfg_mode = mode.parse().ok().expect("Invalid mode");
|
|
||||||
|
|
||||||
config.target_rustcflags = Some("-L target/debug/ -L target/debug/deps/".to_owned());
|
|
||||||
if let Ok(name) = var::<&str>("TESTNAME") {
|
|
||||||
let s : String = name.to_owned();
|
|
||||||
config.filter = Some(s)
|
|
||||||
}
|
|
||||||
config.mode = cfg_mode;
|
|
||||||
config.src_base = PathBuf::from(format!("tests/{}", mode));
|
|
||||||
|
|
||||||
compiletest::run_tests(&config);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn compile_test() {
|
|
||||||
run_mode("compile-fail");
|
|
||||||
}
|
|
|
@ -1,23 +0,0 @@
|
||||||
// Copyright 2013-2015 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.
|
|
||||||
|
|
||||||
extern crate num;
|
|
||||||
#[macro_use]
|
|
||||||
extern crate num_derive;
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, FromPrimitive, ToPrimitive)]
|
|
||||||
enum Color {}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_empty_enum() {
|
|
||||||
let v: [Option<Color>; 1] = [num::FromPrimitive::from_u64(0)];
|
|
||||||
|
|
||||||
assert_eq!(v, [None]);
|
|
||||||
}
|
|
|
@ -1,52 +0,0 @@
|
||||||
// Copyright 2013-2015 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.
|
|
||||||
|
|
||||||
extern crate num;
|
|
||||||
#[macro_use]
|
|
||||||
extern crate num_derive;
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, FromPrimitive, ToPrimitive)]
|
|
||||||
enum Color {
|
|
||||||
Red,
|
|
||||||
Blue,
|
|
||||||
Green,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_from_primitive_for_trivial_case() {
|
|
||||||
let v: [Option<Color>; 4] = [num::FromPrimitive::from_u64(0),
|
|
||||||
num::FromPrimitive::from_u64(1),
|
|
||||||
num::FromPrimitive::from_u64(2),
|
|
||||||
num::FromPrimitive::from_u64(3)];
|
|
||||||
|
|
||||||
assert_eq!(v,
|
|
||||||
[Some(Color::Red), Some(Color::Blue), Some(Color::Green), None]);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_to_primitive_for_trivial_case() {
|
|
||||||
let v: [Option<u64>; 3] = [num::ToPrimitive::to_u64(&Color::Red),
|
|
||||||
num::ToPrimitive::to_u64(&Color::Blue),
|
|
||||||
num::ToPrimitive::to_u64(&Color::Green)];
|
|
||||||
|
|
||||||
assert_eq!(v, [Some(0), Some(1), Some(2)]);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_reflexive_for_trivial_case() {
|
|
||||||
let before: [u64; 3] = [0, 1, 2];
|
|
||||||
let after: Vec<Option<u64>> = before.iter()
|
|
||||||
.map(|&x| -> Option<Color> { num::FromPrimitive::from_u64(x) })
|
|
||||||
.map(|x| x.and_then(|x| num::ToPrimitive::to_u64(&x)))
|
|
||||||
.collect();
|
|
||||||
let before = before.into_iter().cloned().map(Some).collect::<Vec<_>>();
|
|
||||||
|
|
||||||
assert_eq!(before, after);
|
|
||||||
}
|
|
|
@ -1,31 +0,0 @@
|
||||||
// Copyright 2013-2015 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.
|
|
||||||
|
|
||||||
extern crate num;
|
|
||||||
#[macro_use]
|
|
||||||
extern crate num_derive;
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, FromPrimitive)]
|
|
||||||
enum Color {
|
|
||||||
Red,
|
|
||||||
Blue = 5,
|
|
||||||
Green,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_from_primitive_for_enum_with_custom_value() {
|
|
||||||
let v: [Option<Color>; 4] = [num::FromPrimitive::from_u64(0),
|
|
||||||
num::FromPrimitive::from_u64(5),
|
|
||||||
num::FromPrimitive::from_u64(6),
|
|
||||||
num::FromPrimitive::from_u64(3)];
|
|
||||||
|
|
||||||
assert_eq!(v,
|
|
||||||
[Some(Color::Red), Some(Color::Blue), Some(Color::Green), None]);
|
|
||||||
}
|
|
BIN
doc/favicon.ico
BIN
doc/favicon.ico
Binary file not shown.
Before Width: | Height: | Size: 23 KiB |
|
@ -1 +0,0 @@
|
||||||
<meta http-equiv=refresh content=0;url=num/index.html>
|
|
Binary file not shown.
Before Width: | Height: | Size: 5.6 KiB |
|
@ -1,15 +0,0 @@
|
||||||
[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"]
|
|
||||||
categories = [ "algorithms", "science" ]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
name = "num-integer"
|
|
||||||
version = "0.1.35"
|
|
||||||
|
|
||||||
[dependencies.num-traits]
|
|
||||||
path = "../traits"
|
|
||||||
version = "0.1.32"
|
|
|
@ -1,201 +0,0 @@
|
||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
http://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
APPENDIX: How to apply the Apache License to your work.
|
|
||||||
|
|
||||||
To apply the Apache License to your work, attach the following
|
|
||||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
|
||||||
replaced with your own identifying information. (Don't include
|
|
||||||
the brackets!) The text should be enclosed in the appropriate
|
|
||||||
comment syntax for the file format. We also recommend that a
|
|
||||||
file or class name and description of purpose be included on the
|
|
||||||
same "printed page" as the copyright notice for easier
|
|
||||||
identification within third-party archives.
|
|
||||||
|
|
||||||
Copyright [yyyy] [name of copyright owner]
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
|
@ -1,25 +0,0 @@
|
||||||
Copyright (c) 2014 The Rust Project Developers
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any
|
|
||||||
person obtaining a copy of this software and associated
|
|
||||||
documentation files (the "Software"), to deal in the
|
|
||||||
Software without restriction, including without
|
|
||||||
limitation the rights to use, copy, modify, merge,
|
|
||||||
publish, distribute, sublicense, and/or sell copies of
|
|
||||||
the Software, and to permit persons to whom the Software
|
|
||||||
is furnished to do so, subject to the following
|
|
||||||
conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice
|
|
||||||
shall be included in all copies or substantial portions
|
|
||||||
of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
|
||||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
|
||||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
||||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
||||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
||||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
|
||||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
DEALINGS IN THE SOFTWARE.
|
|
|
@ -1,988 +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 <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.
|
|
||||||
|
|
||||||
//! Integer trait and functions.
|
|
||||||
#![doc(html_logo_url = "https://rust-num.github.io/num/rust-logo-128x128-blk-v2.png",
|
|
||||||
html_favicon_url = "https://rust-num.github.io/num/favicon.ico",
|
|
||||||
html_root_url = "https://rust-num.github.io/num/",
|
|
||||||
html_playground_url = "http://play.integer32.com/")]
|
|
||||||
|
|
||||||
extern crate num_traits as traits;
|
|
||||||
|
|
||||||
use std::ops::Add;
|
|
||||||
|
|
||||||
use traits::{Num, Signed};
|
|
||||||
|
|
||||||
pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
|
|
||||||
/// Floored integer division.
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # use num_integer::Integer;
|
|
||||||
/// assert!(( 8).div_floor(& 3) == 2);
|
|
||||||
/// assert!(( 8).div_floor(&-3) == -3);
|
|
||||||
/// assert!((-8).div_floor(& 3) == -3);
|
|
||||||
/// assert!((-8).div_floor(&-3) == 2);
|
|
||||||
///
|
|
||||||
/// assert!(( 1).div_floor(& 2) == 0);
|
|
||||||
/// assert!(( 1).div_floor(&-2) == -1);
|
|
||||||
/// assert!((-1).div_floor(& 2) == -1);
|
|
||||||
/// assert!((-1).div_floor(&-2) == 0);
|
|
||||||
/// ~~~
|
|
||||||
fn div_floor(&self, other: &Self) -> Self;
|
|
||||||
|
|
||||||
/// Floored integer modulo, satisfying:
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # use num_integer::Integer;
|
|
||||||
/// # let n = 1; let d = 1;
|
|
||||||
/// assert!(n.div_floor(&d) * d + n.mod_floor(&d) == n)
|
|
||||||
/// ~~~
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # use num_integer::Integer;
|
|
||||||
/// assert!(( 8).mod_floor(& 3) == 2);
|
|
||||||
/// assert!(( 8).mod_floor(&-3) == -1);
|
|
||||||
/// assert!((-8).mod_floor(& 3) == 1);
|
|
||||||
/// assert!((-8).mod_floor(&-3) == -2);
|
|
||||||
///
|
|
||||||
/// assert!(( 1).mod_floor(& 2) == 1);
|
|
||||||
/// assert!(( 1).mod_floor(&-2) == -1);
|
|
||||||
/// assert!((-1).mod_floor(& 2) == 1);
|
|
||||||
/// assert!((-1).mod_floor(&-2) == -1);
|
|
||||||
/// ~~~
|
|
||||||
fn mod_floor(&self, other: &Self) -> Self;
|
|
||||||
|
|
||||||
/// Greatest Common Divisor (GCD).
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # use num_integer::Integer;
|
|
||||||
/// assert_eq!(6.gcd(&8), 2);
|
|
||||||
/// assert_eq!(7.gcd(&3), 1);
|
|
||||||
/// ~~~
|
|
||||||
fn gcd(&self, other: &Self) -> Self;
|
|
||||||
|
|
||||||
/// Lowest Common Multiple (LCM).
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # use num_integer::Integer;
|
|
||||||
/// assert_eq!(7.lcm(&3), 21);
|
|
||||||
/// assert_eq!(2.lcm(&4), 4);
|
|
||||||
/// ~~~
|
|
||||||
fn lcm(&self, other: &Self) -> Self;
|
|
||||||
|
|
||||||
/// Deprecated, use `is_multiple_of` instead.
|
|
||||||
fn divides(&self, other: &Self) -> bool;
|
|
||||||
|
|
||||||
/// Returns `true` if `other` is a multiple of `self`.
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # use num_integer::Integer;
|
|
||||||
/// assert_eq!(9.is_multiple_of(&3), true);
|
|
||||||
/// assert_eq!(3.is_multiple_of(&9), false);
|
|
||||||
/// ~~~
|
|
||||||
fn is_multiple_of(&self, other: &Self) -> bool;
|
|
||||||
|
|
||||||
/// Returns `true` if the number is even.
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # use num_integer::Integer;
|
|
||||||
/// assert_eq!(3.is_even(), false);
|
|
||||||
/// assert_eq!(4.is_even(), true);
|
|
||||||
/// ~~~
|
|
||||||
fn is_even(&self) -> bool;
|
|
||||||
|
|
||||||
/// Returns `true` if the number is odd.
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # use num_integer::Integer;
|
|
||||||
/// assert_eq!(3.is_odd(), true);
|
|
||||||
/// assert_eq!(4.is_odd(), false);
|
|
||||||
/// ~~~
|
|
||||||
fn is_odd(&self) -> bool;
|
|
||||||
|
|
||||||
/// Simultaneous truncated integer division and modulus.
|
|
||||||
/// Returns `(quotient, remainder)`.
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # 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!(( 1).div_rem( &2), ( 0, 1));
|
|
||||||
/// assert_eq!(( 1).div_rem(&-2), ( 0, 1));
|
|
||||||
/// assert_eq!((-1).div_rem( &2), ( 0, -1));
|
|
||||||
/// assert_eq!((-1).div_rem(&-2), ( 0, -1));
|
|
||||||
/// ~~~
|
|
||||||
#[inline]
|
|
||||||
fn div_rem(&self, other: &Self) -> (Self, Self);
|
|
||||||
|
|
||||||
/// Simultaneous floored integer division and modulus.
|
|
||||||
/// Returns `(quotient, remainder)`.
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ~~~
|
|
||||||
/// # 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));
|
|
||||||
/// assert_eq!((-8).div_mod_floor(&-3), ( 2, -2));
|
|
||||||
///
|
|
||||||
/// assert_eq!(( 1).div_mod_floor( &2), ( 0, 1));
|
|
||||||
/// assert_eq!(( 1).div_mod_floor(&-2), (-1, -1));
|
|
||||||
/// assert_eq!((-1).div_mod_floor( &2), (-1, 1));
|
|
||||||
/// assert_eq!((-1).div_mod_floor(&-2), ( 0, -1));
|
|
||||||
/// ~~~
|
|
||||||
fn div_mod_floor(&self, other: &Self) -> (Self, Self) {
|
|
||||||
(self.div_floor(other), self.mod_floor(other))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Simultaneous integer division and modulus
|
|
||||||
#[inline]
|
|
||||||
pub fn div_rem<T: Integer>(x: T, y: T) -> (T, T) {
|
|
||||||
x.div_rem(&y)
|
|
||||||
}
|
|
||||||
/// Floored integer division
|
|
||||||
#[inline]
|
|
||||||
pub fn div_floor<T: Integer>(x: T, y: T) -> T {
|
|
||||||
x.div_floor(&y)
|
|
||||||
}
|
|
||||||
/// Floored integer modulus
|
|
||||||
#[inline]
|
|
||||||
pub fn mod_floor<T: Integer>(x: T, y: T) -> T {
|
|
||||||
x.mod_floor(&y)
|
|
||||||
}
|
|
||||||
/// 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)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calculates the Greatest Common Divisor (GCD) of the number and `other`. The
|
|
||||||
/// result is always positive.
|
|
||||||
#[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`.
|
|
||||||
#[inline(always)]
|
|
||||||
pub fn lcm<T: Integer>(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: &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) {
|
|
||||||
(d, r) if (r > 0 && *other < 0)
|
|
||||||
|| (r < 0 && *other > 0) => d - 1,
|
|
||||||
(d, _) => d,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Floored integer modulo
|
|
||||||
#[inline]
|
|
||||||
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 {
|
|
||||||
r if (r > 0 && *other < 0)
|
|
||||||
|| (r < 0 && *other > 0) => r + *other,
|
|
||||||
r => r,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calculates `div_floor` and `mod_floor` simultaneously
|
|
||||||
#[inline]
|
|
||||||
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) {
|
|
||||||
(d, r) if (r > 0 && *other < 0)
|
|
||||||
|| (r < 0 && *other > 0) => (d - 1, r + *other),
|
|
||||||
(d, r) => (d, r),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calculates the Greatest Common Divisor (GCD) of the number and
|
|
||||||
/// `other`. The result is always positive.
|
|
||||||
#[inline]
|
|
||||||
fn gcd(&self, other: &Self) -> Self {
|
|
||||||
// Use Stein's algorithm
|
|
||||||
let mut m = *self;
|
|
||||||
let mut n = *other;
|
|
||||||
if m == 0 || n == 0 { return (m | n).abs() }
|
|
||||||
|
|
||||||
// find common factors of 2
|
|
||||||
let shift = (m | n).trailing_zeros();
|
|
||||||
|
|
||||||
// The algorithm needs positive numbers, but the minimum value
|
|
||||||
// can't be represented as a positive one.
|
|
||||||
// It's also a power of two, so the gcd can be
|
|
||||||
// calculated by bitshifting in that case
|
|
||||||
|
|
||||||
// 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 == Self::min_value() || n == Self::min_value() {
|
|
||||||
return (1 << shift).abs()
|
|
||||||
}
|
|
||||||
|
|
||||||
// guaranteed to be positive now, rest like unsigned algorithm
|
|
||||||
m = m.abs();
|
|
||||||
n = n.abs();
|
|
||||||
|
|
||||||
// divide n and m by 2 until odd
|
|
||||||
// m inside loop
|
|
||||||
n >>= n.trailing_zeros();
|
|
||||||
|
|
||||||
while m != 0 {
|
|
||||||
m >>= m.trailing_zeros();
|
|
||||||
if n > m { ::std::mem::swap(&mut n, &mut m) }
|
|
||||||
m -= n;
|
|
||||||
}
|
|
||||||
|
|
||||||
n << shift
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calculates the Lowest Common Multiple (LCM) of the number and
|
|
||||||
/// `other`.
|
|
||||||
#[inline]
|
|
||||||
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: &Self) -> bool {
|
|
||||||
self.is_multiple_of(other)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns `true` if the number is a multiple of `other`.
|
|
||||||
#[inline]
|
|
||||||
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 }
|
|
||||||
|
|
||||||
/// Returns `true` if the number is not divisible by `2`
|
|
||||||
#[inline]
|
|
||||||
fn is_odd(&self) -> bool { !self.is_even() }
|
|
||||||
|
|
||||||
/// Simultaneous truncated integer division and modulus.
|
|
||||||
#[inline]
|
|
||||||
fn div_rem(&self, other: &Self) -> (Self, Self) {
|
|
||||||
(*self / *other, *self % *other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod $test_mod {
|
|
||||||
use Integer;
|
|
||||||
|
|
||||||
/// Checks that the division rule holds for:
|
|
||||||
///
|
|
||||||
/// - `n`: numerator (dividend)
|
|
||||||
/// - `d`: denominator (divisor)
|
|
||||||
/// - `qr`: quotient and remainder
|
|
||||||
#[cfg(test)]
|
|
||||||
fn test_division_rule((n,d): ($T, $T), (q,r): ($T, $T)) {
|
|
||||||
assert_eq!(d * q + r, n);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_div_rem() {
|
|
||||||
fn test_nd_dr(nd: ($T,$T), qr: ($T,$T)) {
|
|
||||||
let (n,d) = nd;
|
|
||||||
let separate_div_rem = (n / d, n % d);
|
|
||||||
let combined_div_rem = n.div_rem(&d);
|
|
||||||
|
|
||||||
assert_eq!(separate_div_rem, qr);
|
|
||||||
assert_eq!(combined_div_rem, qr);
|
|
||||||
|
|
||||||
test_division_rule(nd, separate_div_rem);
|
|
||||||
test_division_rule(nd, combined_div_rem);
|
|
||||||
}
|
|
||||||
|
|
||||||
test_nd_dr(( 8, 3), ( 2, 2));
|
|
||||||
test_nd_dr(( 8, -3), (-2, 2));
|
|
||||||
test_nd_dr((-8, 3), (-2, -2));
|
|
||||||
test_nd_dr((-8, -3), ( 2, -2));
|
|
||||||
|
|
||||||
test_nd_dr(( 1, 2), ( 0, 1));
|
|
||||||
test_nd_dr(( 1, -2), ( 0, 1));
|
|
||||||
test_nd_dr((-1, 2), ( 0, -1));
|
|
||||||
test_nd_dr((-1, -2), ( 0, -1));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_div_mod_floor() {
|
|
||||||
fn test_nd_dm(nd: ($T,$T), dm: ($T,$T)) {
|
|
||||||
let (n,d) = nd;
|
|
||||||
let separate_div_mod_floor = (n.div_floor(&d), n.mod_floor(&d));
|
|
||||||
let combined_div_mod_floor = n.div_mod_floor(&d);
|
|
||||||
|
|
||||||
assert_eq!(separate_div_mod_floor, dm);
|
|
||||||
assert_eq!(combined_div_mod_floor, dm);
|
|
||||||
|
|
||||||
test_division_rule(nd, separate_div_mod_floor);
|
|
||||||
test_division_rule(nd, combined_div_mod_floor);
|
|
||||||
}
|
|
||||||
|
|
||||||
test_nd_dm(( 8, 3), ( 2, 2));
|
|
||||||
test_nd_dm(( 8, -3), (-3, -1));
|
|
||||||
test_nd_dm((-8, 3), (-3, 1));
|
|
||||||
test_nd_dm((-8, -3), ( 2, -2));
|
|
||||||
|
|
||||||
test_nd_dm(( 1, 2), ( 0, 1));
|
|
||||||
test_nd_dm(( 1, -2), (-1, -1));
|
|
||||||
test_nd_dm((-1, 2), (-1, 1));
|
|
||||||
test_nd_dm((-1, -2), ( 0, -1));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_gcd() {
|
|
||||||
assert_eq!((10 as $T).gcd(&2), 2 as $T);
|
|
||||||
assert_eq!((10 as $T).gcd(&3), 1 as $T);
|
|
||||||
assert_eq!((0 as $T).gcd(&3), 3 as $T);
|
|
||||||
assert_eq!((3 as $T).gcd(&3), 3 as $T);
|
|
||||||
assert_eq!((56 as $T).gcd(&42), 14 as $T);
|
|
||||||
assert_eq!((3 as $T).gcd(&-3), 3 as $T);
|
|
||||||
assert_eq!((-6 as $T).gcd(&3), 3 as $T);
|
|
||||||
assert_eq!((-4 as $T).gcd(&-2), 2 as $T);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_gcd_cmp_with_euclidean() {
|
|
||||||
fn euclidean_gcd(mut m: $T, mut n: $T) -> $T {
|
|
||||||
while m != 0 {
|
|
||||||
::std::mem::swap(&mut m, &mut n);
|
|
||||||
m %= n;
|
|
||||||
}
|
|
||||||
|
|
||||||
n.abs()
|
|
||||||
}
|
|
||||||
|
|
||||||
// gcd(-128, b) = 128 is not representable as positive value
|
|
||||||
// for i8
|
|
||||||
for i in -127..127 {
|
|
||||||
for j in -127..127 {
|
|
||||||
assert_eq!(euclidean_gcd(i,j), i.gcd(&j));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// last value
|
|
||||||
// FIXME: Use inclusive ranges for above loop when implemented
|
|
||||||
let i = 127;
|
|
||||||
for j in -127..127 {
|
|
||||||
assert_eq!(euclidean_gcd(i,j), i.gcd(&j));
|
|
||||||
}
|
|
||||||
assert_eq!(127.gcd(&127), 127);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_gcd_min_val() {
|
|
||||||
let min = <$T>::min_value();
|
|
||||||
let max = <$T>::max_value();
|
|
||||||
let max_pow2 = max / 2 + 1;
|
|
||||||
assert_eq!(min.gcd(&max), 1 as $T);
|
|
||||||
assert_eq!(max.gcd(&min), 1 as $T);
|
|
||||||
assert_eq!(min.gcd(&max_pow2), max_pow2);
|
|
||||||
assert_eq!(max_pow2.gcd(&min), max_pow2);
|
|
||||||
assert_eq!(min.gcd(&42), 2 as $T);
|
|
||||||
assert_eq!((42 as $T).gcd(&min), 2 as $T);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
#[should_panic]
|
|
||||||
fn test_gcd_min_val_min_val() {
|
|
||||||
let min = <$T>::min_value();
|
|
||||||
assert!(min.gcd(&min) >= 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
#[should_panic]
|
|
||||||
fn test_gcd_min_val_0() {
|
|
||||||
let min = <$T>::min_value();
|
|
||||||
assert!(min.gcd(&0) >= 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
#[should_panic]
|
|
||||||
fn test_gcd_0_min_val() {
|
|
||||||
let min = <$T>::min_value();
|
|
||||||
assert!((0 as $T).gcd(&min) >= 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_lcm() {
|
|
||||||
assert_eq!((1 as $T).lcm(&0), 0 as $T);
|
|
||||||
assert_eq!((0 as $T).lcm(&1), 0 as $T);
|
|
||||||
assert_eq!((1 as $T).lcm(&1), 1 as $T);
|
|
||||||
assert_eq!((-1 as $T).lcm(&1), 1 as $T);
|
|
||||||
assert_eq!((1 as $T).lcm(&-1), 1 as $T);
|
|
||||||
assert_eq!((-1 as $T).lcm(&-1), 1 as $T);
|
|
||||||
assert_eq!((8 as $T).lcm(&9), 72 as $T);
|
|
||||||
assert_eq!((11 as $T).lcm(&5), 55 as $T);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_even() {
|
|
||||||
assert_eq!((-4 as $T).is_even(), true);
|
|
||||||
assert_eq!((-3 as $T).is_even(), false);
|
|
||||||
assert_eq!((-2 as $T).is_even(), true);
|
|
||||||
assert_eq!((-1 as $T).is_even(), false);
|
|
||||||
assert_eq!((0 as $T).is_even(), true);
|
|
||||||
assert_eq!((1 as $T).is_even(), false);
|
|
||||||
assert_eq!((2 as $T).is_even(), true);
|
|
||||||
assert_eq!((3 as $T).is_even(), false);
|
|
||||||
assert_eq!((4 as $T).is_even(), true);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_odd() {
|
|
||||||
assert_eq!((-4 as $T).is_odd(), false);
|
|
||||||
assert_eq!((-3 as $T).is_odd(), true);
|
|
||||||
assert_eq!((-2 as $T).is_odd(), false);
|
|
||||||
assert_eq!((-1 as $T).is_odd(), true);
|
|
||||||
assert_eq!((0 as $T).is_odd(), false);
|
|
||||||
assert_eq!((1 as $T).is_odd(), true);
|
|
||||||
assert_eq!((2 as $T).is_odd(), false);
|
|
||||||
assert_eq!((3 as $T).is_odd(), true);
|
|
||||||
assert_eq!((4 as $T).is_odd(), false);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
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: &Self) -> Self {
|
|
||||||
*self / *other
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Unsigned integer modulo operation. Returns the same result as `rem` (`%`).
|
|
||||||
#[inline]
|
|
||||||
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: &Self) -> Self {
|
|
||||||
// Use Stein's algorithm
|
|
||||||
let mut m = *self;
|
|
||||||
let mut n = *other;
|
|
||||||
if m == 0 || n == 0 { return m | n }
|
|
||||||
|
|
||||||
// find common factors of 2
|
|
||||||
let shift = (m | n).trailing_zeros();
|
|
||||||
|
|
||||||
// divide n and m by 2 until odd
|
|
||||||
// m inside loop
|
|
||||||
n >>= n.trailing_zeros();
|
|
||||||
|
|
||||||
while m != 0 {
|
|
||||||
m >>= m.trailing_zeros();
|
|
||||||
if n > m { ::std::mem::swap(&mut n, &mut m) }
|
|
||||||
m -= n;
|
|
||||||
}
|
|
||||||
|
|
||||||
n << shift
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calculates the Lowest Common Multiple (LCM) of the number and `other`.
|
|
||||||
#[inline]
|
|
||||||
fn lcm(&self, other: &Self) -> Self {
|
|
||||||
*self * (*other / self.gcd(other))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Deprecated, use `is_multiple_of` instead.
|
|
||||||
#[inline]
|
|
||||||
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: &Self) -> bool {
|
|
||||||
*self % *other == 0
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns `true` if the number is divisible by `2`.
|
|
||||||
#[inline]
|
|
||||||
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()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Simultaneous truncated integer division and modulus.
|
|
||||||
#[inline]
|
|
||||||
fn div_rem(&self, other: &Self) -> (Self, Self) {
|
|
||||||
(*self / *other, *self % *other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod $test_mod {
|
|
||||||
use Integer;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_div_mod_floor() {
|
|
||||||
assert_eq!((10 as $T).div_floor(&(3 as $T)), 3 as $T);
|
|
||||||
assert_eq!((10 as $T).mod_floor(&(3 as $T)), 1 as $T);
|
|
||||||
assert_eq!((10 as $T).div_mod_floor(&(3 as $T)), (3 as $T, 1 as $T));
|
|
||||||
assert_eq!((5 as $T).div_floor(&(5 as $T)), 1 as $T);
|
|
||||||
assert_eq!((5 as $T).mod_floor(&(5 as $T)), 0 as $T);
|
|
||||||
assert_eq!((5 as $T).div_mod_floor(&(5 as $T)), (1 as $T, 0 as $T));
|
|
||||||
assert_eq!((3 as $T).div_floor(&(7 as $T)), 0 as $T);
|
|
||||||
assert_eq!((3 as $T).mod_floor(&(7 as $T)), 3 as $T);
|
|
||||||
assert_eq!((3 as $T).div_mod_floor(&(7 as $T)), (0 as $T, 3 as $T));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_gcd() {
|
|
||||||
assert_eq!((10 as $T).gcd(&2), 2 as $T);
|
|
||||||
assert_eq!((10 as $T).gcd(&3), 1 as $T);
|
|
||||||
assert_eq!((0 as $T).gcd(&3), 3 as $T);
|
|
||||||
assert_eq!((3 as $T).gcd(&3), 3 as $T);
|
|
||||||
assert_eq!((56 as $T).gcd(&42), 14 as $T);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_gcd_cmp_with_euclidean() {
|
|
||||||
fn euclidean_gcd(mut m: $T, mut n: $T) -> $T {
|
|
||||||
while m != 0 {
|
|
||||||
::std::mem::swap(&mut m, &mut n);
|
|
||||||
m %= n;
|
|
||||||
}
|
|
||||||
n
|
|
||||||
}
|
|
||||||
|
|
||||||
for i in 0..255 {
|
|
||||||
for j in 0..255 {
|
|
||||||
assert_eq!(euclidean_gcd(i,j), i.gcd(&j));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// last value
|
|
||||||
// FIXME: Use inclusive ranges for above loop when implemented
|
|
||||||
let i = 255;
|
|
||||||
for j in 0..255 {
|
|
||||||
assert_eq!(euclidean_gcd(i,j), i.gcd(&j));
|
|
||||||
}
|
|
||||||
assert_eq!(255.gcd(&255), 255);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_lcm() {
|
|
||||||
assert_eq!((1 as $T).lcm(&0), 0 as $T);
|
|
||||||
assert_eq!((0 as $T).lcm(&1), 0 as $T);
|
|
||||||
assert_eq!((1 as $T).lcm(&1), 1 as $T);
|
|
||||||
assert_eq!((8 as $T).lcm(&9), 72 as $T);
|
|
||||||
assert_eq!((11 as $T).lcm(&5), 55 as $T);
|
|
||||||
assert_eq!((15 as $T).lcm(&17), 255 as $T);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_is_multiple_of() {
|
|
||||||
assert!((6 as $T).is_multiple_of(&(6 as $T)));
|
|
||||||
assert!((6 as $T).is_multiple_of(&(3 as $T)));
|
|
||||||
assert!((6 as $T).is_multiple_of(&(1 as $T)));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_even() {
|
|
||||||
assert_eq!((0 as $T).is_even(), true);
|
|
||||||
assert_eq!((1 as $T).is_even(), false);
|
|
||||||
assert_eq!((2 as $T).is_even(), true);
|
|
||||||
assert_eq!((3 as $T).is_even(), false);
|
|
||||||
assert_eq!((4 as $T).is_even(), true);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_odd() {
|
|
||||||
assert_eq!((0 as $T).is_odd(), false);
|
|
||||||
assert_eq!((1 as $T).is_odd(), true);
|
|
||||||
assert_eq!((2 as $T).is_odd(), false);
|
|
||||||
assert_eq!((3 as $T).is_odd(), true);
|
|
||||||
assert_eq!((4 as $T).is_odd(), false);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
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);
|
|
||||||
|
|
||||||
/// An iterator over binomial coefficients.
|
|
||||||
pub struct IterBinomial<T> {
|
|
||||||
a: T,
|
|
||||||
n: T,
|
|
||||||
k: T,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T> IterBinomial<T>
|
|
||||||
where T: Integer,
|
|
||||||
{
|
|
||||||
/// For a given n, iterate over all binomial coefficients binomial(n, k), for k=0...n.
|
|
||||||
///
|
|
||||||
/// Note that this might overflow, depending on `T`. For the primitive
|
|
||||||
/// integer types, the following n are the largest ones for which there will
|
|
||||||
/// be no overflow:
|
|
||||||
///
|
|
||||||
/// type | n
|
|
||||||
/// -----|---
|
|
||||||
/// u8 | 10
|
|
||||||
/// i8 | 9
|
|
||||||
/// u16 | 18
|
|
||||||
/// i16 | 17
|
|
||||||
/// u32 | 34
|
|
||||||
/// i32 | 33
|
|
||||||
/// u64 | 67
|
|
||||||
/// i64 | 66
|
|
||||||
///
|
|
||||||
/// For larger n, `T` should be a bigint type.
|
|
||||||
pub fn new(n: T) -> IterBinomial<T> {
|
|
||||||
IterBinomial {
|
|
||||||
k: T::zero(), a: T::one(), n: n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T> Iterator for IterBinomial<T>
|
|
||||||
where T: Integer + Clone
|
|
||||||
{
|
|
||||||
type Item = T;
|
|
||||||
|
|
||||||
fn next(&mut self) -> Option<T> {
|
|
||||||
if self.k > self.n {
|
|
||||||
return None;
|
|
||||||
}
|
|
||||||
self.a = if !self.k.is_zero() {
|
|
||||||
multiply_and_divide(
|
|
||||||
self.a.clone(),
|
|
||||||
self.n.clone() - self.k.clone() + T::one(),
|
|
||||||
self.k.clone()
|
|
||||||
)
|
|
||||||
} else {
|
|
||||||
T::one()
|
|
||||||
};
|
|
||||||
self.k = self.k.clone() + T::one();
|
|
||||||
Some(self.a.clone())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calculate r * a / b, avoiding overflows and fractions.
|
|
||||||
///
|
|
||||||
/// Assumes that b divides r * a evenly.
|
|
||||||
fn multiply_and_divide<T: Integer + Clone>(r: T, a: T, b: T) -> T {
|
|
||||||
// See http://blog.plover.com/math/choose-2.html for the idea.
|
|
||||||
let g = gcd(r.clone(), b.clone());
|
|
||||||
r/g.clone() * (a / (b/g))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calculate the binomial coefficient.
|
|
||||||
///
|
|
||||||
/// Note that this might overflow, depending on `T`. For the primitive integer
|
|
||||||
/// types, the following n are the largest ones possible such that there will
|
|
||||||
/// be no overflow for any k:
|
|
||||||
///
|
|
||||||
/// type | n
|
|
||||||
/// -----|---
|
|
||||||
/// u8 | 10
|
|
||||||
/// i8 | 9
|
|
||||||
/// u16 | 18
|
|
||||||
/// i16 | 17
|
|
||||||
/// u32 | 34
|
|
||||||
/// i32 | 33
|
|
||||||
/// u64 | 67
|
|
||||||
/// i64 | 66
|
|
||||||
///
|
|
||||||
/// For larger n, consider using a bigint type for `T`.
|
|
||||||
pub fn binomial<T: Integer + Clone>(mut n: T, k: T) -> T {
|
|
||||||
// See http://blog.plover.com/math/choose.html for the idea.
|
|
||||||
if k > n {
|
|
||||||
return T::zero();
|
|
||||||
}
|
|
||||||
if k > n.clone() - k.clone() {
|
|
||||||
return binomial(n.clone(), n - k);
|
|
||||||
}
|
|
||||||
let mut r = T::one();
|
|
||||||
let mut d = T::one();
|
|
||||||
loop {
|
|
||||||
if d > k {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
r = multiply_and_divide(r, n.clone(), d.clone());
|
|
||||||
n = n - T::one();
|
|
||||||
d = d + T::one();
|
|
||||||
}
|
|
||||||
r
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calculate the multinomial coefficient.
|
|
||||||
pub fn multinomial<T: Integer + Clone>(k: &[T]) -> T
|
|
||||||
where for<'a> T: Add<&'a T, Output = T>
|
|
||||||
{
|
|
||||||
let mut r = T::one();
|
|
||||||
let mut p = T::zero();
|
|
||||||
for i in k {
|
|
||||||
p = p + i;
|
|
||||||
r = r * binomial(p.clone(), i.clone());
|
|
||||||
}
|
|
||||||
r
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_lcm_overflow() {
|
|
||||||
macro_rules! check {
|
|
||||||
($t:ty, $x:expr, $y:expr, $r:expr) => { {
|
|
||||||
let x: $t = $x;
|
|
||||||
let y: $t = $y;
|
|
||||||
let o = x.checked_mul(y);
|
|
||||||
assert!(o.is_none(),
|
|
||||||
"sanity checking that {} input {} * {} overflows",
|
|
||||||
stringify!($t), x, y);
|
|
||||||
assert_eq!(x.lcm(&y), $r);
|
|
||||||
assert_eq!(y.lcm(&x), $r);
|
|
||||||
} }
|
|
||||||
}
|
|
||||||
|
|
||||||
// Original bug (Issue #166)
|
|
||||||
check!(i64, 46656000000000000, 600, 46656000000000000);
|
|
||||||
|
|
||||||
check!(i8, 0x40, 0x04, 0x40);
|
|
||||||
check!(u8, 0x80, 0x02, 0x80);
|
|
||||||
check!(i16, 0x40_00, 0x04, 0x40_00);
|
|
||||||
check!(u16, 0x80_00, 0x02, 0x80_00);
|
|
||||||
check!(i32, 0x4000_0000, 0x04, 0x4000_0000);
|
|
||||||
check!(u32, 0x8000_0000, 0x02, 0x8000_0000);
|
|
||||||
check!(i64, 0x4000_0000_0000_0000, 0x04, 0x4000_0000_0000_0000);
|
|
||||||
check!(u64, 0x8000_0000_0000_0000, 0x02, 0x8000_0000_0000_0000);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_iter_binomial() {
|
|
||||||
macro_rules! check_simple {
|
|
||||||
($t:ty) => { {
|
|
||||||
let n: $t = 3;
|
|
||||||
let c: Vec<_> = IterBinomial::new(n).collect();
|
|
||||||
let expected = vec![1, 3, 3, 1];
|
|
||||||
assert_eq!(c, expected);
|
|
||||||
} }
|
|
||||||
}
|
|
||||||
|
|
||||||
check_simple!(u8);
|
|
||||||
check_simple!(i8);
|
|
||||||
check_simple!(u16);
|
|
||||||
check_simple!(i16);
|
|
||||||
check_simple!(u32);
|
|
||||||
check_simple!(i32);
|
|
||||||
check_simple!(u64);
|
|
||||||
check_simple!(i64);
|
|
||||||
|
|
||||||
macro_rules! check_binomial {
|
|
||||||
($t:ty, $n:expr) => { {
|
|
||||||
let n: $t = $n;
|
|
||||||
let c: Vec<_> = IterBinomial::new(n).collect();
|
|
||||||
let mut k: $t = 0;
|
|
||||||
for b in c {
|
|
||||||
assert_eq!(b, binomial(n, k));
|
|
||||||
k += 1;
|
|
||||||
}
|
|
||||||
} }
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check the largest n for which there is no overflow.
|
|
||||||
check_binomial!(u8, 10);
|
|
||||||
check_binomial!(i8, 9);
|
|
||||||
check_binomial!(u16, 18);
|
|
||||||
check_binomial!(i16, 17);
|
|
||||||
check_binomial!(u32, 34);
|
|
||||||
check_binomial!(i32, 33);
|
|
||||||
check_binomial!(u64, 67);
|
|
||||||
check_binomial!(i64, 66);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_binomial() {
|
|
||||||
macro_rules! check {
|
|
||||||
($t:ty, $x:expr, $y:expr, $r:expr) => { {
|
|
||||||
let x: $t = $x;
|
|
||||||
let y: $t = $y;
|
|
||||||
let expected: $t = $r;
|
|
||||||
assert_eq!(binomial(x, y), expected);
|
|
||||||
if y <= x {
|
|
||||||
assert_eq!(binomial(x, x - y), expected);
|
|
||||||
}
|
|
||||||
} }
|
|
||||||
}
|
|
||||||
check!(u8, 9, 4, 126);
|
|
||||||
check!(u8, 0, 0, 1);
|
|
||||||
check!(u8, 2, 3, 0);
|
|
||||||
|
|
||||||
check!(i8, 9, 4, 126);
|
|
||||||
check!(i8, 0, 0, 1);
|
|
||||||
check!(i8, 2, 3, 0);
|
|
||||||
|
|
||||||
check!(u16, 100, 2, 4950);
|
|
||||||
check!(u16, 14, 4, 1001);
|
|
||||||
check!(u16, 0, 0, 1);
|
|
||||||
check!(u16, 2, 3, 0);
|
|
||||||
|
|
||||||
check!(i16, 100, 2, 4950);
|
|
||||||
check!(i16, 14, 4, 1001);
|
|
||||||
check!(i16, 0, 0, 1);
|
|
||||||
check!(i16, 2, 3, 0);
|
|
||||||
|
|
||||||
check!(u32, 100, 2, 4950);
|
|
||||||
check!(u32, 35, 11, 417225900);
|
|
||||||
check!(u32, 14, 4, 1001);
|
|
||||||
check!(u32, 0, 0, 1);
|
|
||||||
check!(u32, 2, 3, 0);
|
|
||||||
|
|
||||||
check!(i32, 100, 2, 4950);
|
|
||||||
check!(i32, 35, 11, 417225900);
|
|
||||||
check!(i32, 14, 4, 1001);
|
|
||||||
check!(i32, 0, 0, 1);
|
|
||||||
check!(i32, 2, 3, 0);
|
|
||||||
|
|
||||||
check!(u64, 100, 2, 4950);
|
|
||||||
check!(u64, 35, 11, 417225900);
|
|
||||||
check!(u64, 14, 4, 1001);
|
|
||||||
check!(u64, 0, 0, 1);
|
|
||||||
check!(u64, 2, 3, 0);
|
|
||||||
|
|
||||||
check!(i64, 100, 2, 4950);
|
|
||||||
check!(i64, 35, 11, 417225900);
|
|
||||||
check!(i64, 14, 4, 1001);
|
|
||||||
check!(i64, 0, 0, 1);
|
|
||||||
check!(i64, 2, 3, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_multinomial() {
|
|
||||||
macro_rules! check_binomial {
|
|
||||||
($t:ty, $k:expr) => { {
|
|
||||||
let n: $t = $k.iter().fold(0, |acc, &x| acc + x);
|
|
||||||
let k: &[$t] = $k;
|
|
||||||
assert_eq!(k.len(), 2);
|
|
||||||
assert_eq!(multinomial(k), binomial(n, k[0]));
|
|
||||||
} }
|
|
||||||
}
|
|
||||||
|
|
||||||
check_binomial!(u8, &[4, 5]);
|
|
||||||
|
|
||||||
check_binomial!(i8, &[4, 5]);
|
|
||||||
|
|
||||||
check_binomial!(u16, &[2, 98]);
|
|
||||||
check_binomial!(u16, &[4, 10]);
|
|
||||||
|
|
||||||
check_binomial!(i16, &[2, 98]);
|
|
||||||
check_binomial!(i16, &[4, 10]);
|
|
||||||
|
|
||||||
check_binomial!(u32, &[2, 98]);
|
|
||||||
check_binomial!(u32, &[11, 24]);
|
|
||||||
check_binomial!(u32, &[4, 10]);
|
|
||||||
|
|
||||||
check_binomial!(i32, &[2, 98]);
|
|
||||||
check_binomial!(i32, &[11, 24]);
|
|
||||||
check_binomial!(i32, &[4, 10]);
|
|
||||||
|
|
||||||
check_binomial!(u64, &[2, 98]);
|
|
||||||
check_binomial!(u64, &[11, 24]);
|
|
||||||
check_binomial!(u64, &[4, 10]);
|
|
||||||
|
|
||||||
check_binomial!(i64, &[2, 98]);
|
|
||||||
check_binomial!(i64, &[11, 24]);
|
|
||||||
check_binomial!(i64, &[4, 10]);
|
|
||||||
|
|
||||||
macro_rules! check_multinomial {
|
|
||||||
($t:ty, $k:expr, $r:expr) => { {
|
|
||||||
let k: &[$t] = $k;
|
|
||||||
let expected: $t = $r;
|
|
||||||
assert_eq!(multinomial(k), expected);
|
|
||||||
} }
|
|
||||||
}
|
|
||||||
|
|
||||||
check_multinomial!(u8, &[2, 1, 2], 30);
|
|
||||||
check_multinomial!(u8, &[2, 3, 0], 10);
|
|
||||||
|
|
||||||
check_multinomial!(i8, &[2, 1, 2], 30);
|
|
||||||
check_multinomial!(i8, &[2, 3, 0], 10);
|
|
||||||
|
|
||||||
check_multinomial!(u16, &[2, 1, 2], 30);
|
|
||||||
check_multinomial!(u16, &[2, 3, 0], 10);
|
|
||||||
|
|
||||||
check_multinomial!(i16, &[2, 1, 2], 30);
|
|
||||||
check_multinomial!(i16, &[2, 3, 0], 10);
|
|
||||||
|
|
||||||
check_multinomial!(u32, &[2, 1, 2], 30);
|
|
||||||
check_multinomial!(u32, &[2, 3, 0], 10);
|
|
||||||
|
|
||||||
check_multinomial!(i32, &[2, 1, 2], 30);
|
|
||||||
check_multinomial!(i32, &[2, 3, 0], 10);
|
|
||||||
|
|
||||||
check_multinomial!(u64, &[2, 1, 2], 30);
|
|
||||||
check_multinomial!(u64, &[2, 3, 0], 10);
|
|
||||||
|
|
||||||
check_multinomial!(i64, &[2, 1, 2], 30);
|
|
||||||
check_multinomial!(i64, &[2, 3, 0], 10);
|
|
||||||
|
|
||||||
check_multinomial!(u64, &[], 1);
|
|
||||||
check_multinomial!(u64, &[0], 1);
|
|
||||||
check_multinomial!(u64, &[12345], 1);
|
|
||||||
}
|
|
|
@ -1,23 +0,0 @@
|
||||||
[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"]
|
|
||||||
categories = [ "algorithms", "science" ]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
name = "num-iter"
|
|
||||||
version = "0.1.34"
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
|
|
||||||
[dependencies.num-integer]
|
|
||||||
optional = false
|
|
||||||
path = "../integer"
|
|
||||||
version = "0.1.32"
|
|
||||||
|
|
||||||
[dependencies.num-traits]
|
|
||||||
optional = false
|
|
||||||
path = "../traits"
|
|
||||||
version = "0.1.32"
|
|
|
@ -1,201 +0,0 @@
|
||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
http://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
APPENDIX: How to apply the Apache License to your work.
|
|
||||||
|
|
||||||
To apply the Apache License to your work, attach the following
|
|
||||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
|
||||||
replaced with your own identifying information. (Don't include
|
|
||||||
the brackets!) The text should be enclosed in the appropriate
|
|
||||||
comment syntax for the file format. We also recommend that a
|
|
||||||
file or class name and description of purpose be included on the
|
|
||||||
same "printed page" as the copyright notice for easier
|
|
||||||
identification within third-party archives.
|
|
||||||
|
|
||||||
Copyright [yyyy] [name of copyright owner]
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
|
@ -1,25 +0,0 @@
|
||||||
Copyright (c) 2014 The Rust Project Developers
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any
|
|
||||||
person obtaining a copy of this software and associated
|
|
||||||
documentation files (the "Software"), to deal in the
|
|
||||||
Software without restriction, including without
|
|
||||||
limitation the rights to use, copy, modify, merge,
|
|
||||||
publish, distribute, sublicense, and/or sell copies of
|
|
||||||
the Software, and to permit persons to whom the Software
|
|
||||||
is furnished to do so, subject to the following
|
|
||||||
conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice
|
|
||||||
shall be included in all copies or substantial portions
|
|
||||||
of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
|
||||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
|
||||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
||||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
||||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
||||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
|
||||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
DEALINGS IN THE SOFTWARE.
|
|
378
iter/src/lib.rs
378
iter/src/lib.rs
|
@ -1,378 +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 <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.
|
|
||||||
|
|
||||||
//! External iterators for generic mathematics
|
|
||||||
#![doc(html_logo_url = "https://rust-num.github.io/num/rust-logo-128x128-blk-v2.png",
|
|
||||||
html_favicon_url = "https://rust-num.github.io/num/favicon.ico",
|
|
||||||
html_root_url = "https://rust-num.github.io/num/",
|
|
||||||
html_playground_url = "http://play.integer32.com/")]
|
|
||||||
|
|
||||||
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)
|
|
||||||
#[derive(Clone)]
|
|
||||||
pub struct Range<A> {
|
|
||||||
state: A,
|
|
||||||
stop: A,
|
|
||||||
one: A
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns an iterator over the given range [start, stop) (that is, starting
|
|
||||||
/// at start (inclusive), and ending at stop (exclusive)).
|
|
||||||
///
|
|
||||||
/// # Example
|
|
||||||
///
|
|
||||||
/// ```rust
|
|
||||||
/// let array = [0, 1, 2, 3, 4];
|
|
||||||
///
|
|
||||||
/// for i in num_iter::range(0, 5) {
|
|
||||||
/// println!("{}", i);
|
|
||||||
/// assert_eq!(i, array[i]);
|
|
||||||
/// }
|
|
||||||
/// ```
|
|
||||||
#[inline]
|
|
||||||
pub fn range<A>(start: A, stop: A) -> Range<A>
|
|
||||||
where A: Add<A, Output = A> + PartialOrd + Clone + One
|
|
||||||
{
|
|
||||||
Range{state: start, stop: stop, one: One::one()}
|
|
||||||
}
|
|
||||||
|
|
||||||
// FIXME: rust-lang/rust#10414: Unfortunate type bound
|
|
||||||
impl<A> Iterator for Range<A>
|
|
||||||
where A: Add<A, Output = A> + PartialOrd + Clone + ToPrimitive
|
|
||||||
{
|
|
||||||
type Item = A;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn next(&mut self) -> Option<A> {
|
|
||||||
if self.state < self.stop {
|
|
||||||
let result = self.state.clone();
|
|
||||||
self.state = self.state.clone() + self.one.clone();
|
|
||||||
Some(result)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
|
||||||
// This first checks if the elements are representable as i64. If they aren't, try u64 (to
|
|
||||||
// handle cases like range(huge, huger)). We don't use usize/int because the difference of
|
|
||||||
// the i64/u64 might lie within their range.
|
|
||||||
let bound = match self.state.to_i64() {
|
|
||||||
Some(a) => {
|
|
||||||
let sz = self.stop.to_i64().map(|b| b.checked_sub(a));
|
|
||||||
match sz {
|
|
||||||
Some(Some(bound)) => bound.to_usize(),
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
},
|
|
||||||
None => match self.state.to_u64() {
|
|
||||||
Some(a) => {
|
|
||||||
let sz = self.stop.to_u64().map(|b| b.checked_sub(a));
|
|
||||||
match sz {
|
|
||||||
Some(Some(bound)) => bound.to_usize(),
|
|
||||||
_ => None
|
|
||||||
}
|
|
||||||
},
|
|
||||||
None => None
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
match bound {
|
|
||||||
Some(b) => (b, Some(b)),
|
|
||||||
// Standard fallback for unbounded/unrepresentable bounds
|
|
||||||
None => (0, None)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// `Integer` is required to ensure the range will be the same regardless of
|
|
||||||
/// the direction it is consumed.
|
|
||||||
impl<A> DoubleEndedIterator for Range<A>
|
|
||||||
where A: Integer + Clone + ToPrimitive
|
|
||||||
{
|
|
||||||
#[inline]
|
|
||||||
fn next_back(&mut self) -> Option<A> {
|
|
||||||
if self.stop > self.state {
|
|
||||||
self.stop = self.stop.clone() - self.one.clone();
|
|
||||||
Some(self.stop.clone())
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// An iterator over the range [start, stop]
|
|
||||||
#[derive(Clone)]
|
|
||||||
pub struct RangeInclusive<A> {
|
|
||||||
range: Range<A>,
|
|
||||||
done: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Return an iterator over the range [start, stop]
|
|
||||||
#[inline]
|
|
||||||
pub fn range_inclusive<A>(start: A, stop: A) -> RangeInclusive<A>
|
|
||||||
where A: Add<A, Output = A> + PartialOrd + Clone + One
|
|
||||||
{
|
|
||||||
RangeInclusive{range: range(start, stop), done: false}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<A> Iterator for RangeInclusive<A>
|
|
||||||
where A: Add<A, Output = A> + PartialOrd + Clone + ToPrimitive
|
|
||||||
{
|
|
||||||
type Item = A;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn next(&mut self) -> Option<A> {
|
|
||||||
match self.range.next() {
|
|
||||||
Some(x) => Some(x),
|
|
||||||
None => {
|
|
||||||
if !self.done && self.range.state == self.range.stop {
|
|
||||||
self.done = true;
|
|
||||||
Some(self.range.stop.clone())
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
|
||||||
let (lo, hi) = self.range.size_hint();
|
|
||||||
if self.done {
|
|
||||||
(lo, hi)
|
|
||||||
} else {
|
|
||||||
let lo = lo.saturating_add(1);
|
|
||||||
let hi = match hi {
|
|
||||||
Some(x) => x.checked_add(1),
|
|
||||||
None => None
|
|
||||||
};
|
|
||||||
(lo, hi)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<A> DoubleEndedIterator for RangeInclusive<A>
|
|
||||||
where A: Sub<A, Output = A> + Integer + Clone + ToPrimitive
|
|
||||||
{
|
|
||||||
#[inline]
|
|
||||||
fn next_back(&mut self) -> Option<A> {
|
|
||||||
if self.range.stop > self.range.state {
|
|
||||||
let result = self.range.stop.clone();
|
|
||||||
self.range.stop = self.range.stop.clone() - self.range.one.clone();
|
|
||||||
Some(result)
|
|
||||||
} else if !self.done && self.range.state == self.range.stop {
|
|
||||||
self.done = true;
|
|
||||||
Some(self.range.stop.clone())
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
|
|
||||||
#[derive(Clone)]
|
|
||||||
pub struct RangeStep<A> {
|
|
||||||
state: A,
|
|
||||||
stop: A,
|
|
||||||
step: A,
|
|
||||||
rev: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping.
|
|
||||||
#[inline]
|
|
||||||
pub fn range_step<A>(start: A, stop: A, step: A) -> RangeStep<A>
|
|
||||||
where A: CheckedAdd + PartialOrd + Clone + Zero
|
|
||||||
{
|
|
||||||
let rev = step < Zero::zero();
|
|
||||||
RangeStep{state: start, stop: stop, step: step, rev: rev}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<A> Iterator for RangeStep<A>
|
|
||||||
where A: CheckedAdd + PartialOrd + Clone
|
|
||||||
{
|
|
||||||
type Item = A;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn next(&mut self) -> Option<A> {
|
|
||||||
if (self.rev && self.state > self.stop) || (!self.rev && self.state < self.stop) {
|
|
||||||
let result = self.state.clone();
|
|
||||||
match self.state.checked_add(&self.step) {
|
|
||||||
Some(x) => self.state = x,
|
|
||||||
None => self.state = self.stop.clone()
|
|
||||||
}
|
|
||||||
Some(result)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
|
|
||||||
#[derive(Clone)]
|
|
||||||
pub struct RangeStepInclusive<A> {
|
|
||||||
state: A,
|
|
||||||
stop: A,
|
|
||||||
step: A,
|
|
||||||
rev: bool,
|
|
||||||
done: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping.
|
|
||||||
#[inline]
|
|
||||||
pub fn range_step_inclusive<A>(start: A, stop: A, step: A) -> RangeStepInclusive<A>
|
|
||||||
where A: CheckedAdd + PartialOrd + Clone + Zero
|
|
||||||
{
|
|
||||||
let rev = step < Zero::zero();
|
|
||||||
RangeStepInclusive{state: start, stop: stop, step: step, rev: rev, done: false}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<A> Iterator for RangeStepInclusive<A>
|
|
||||||
where A: CheckedAdd + PartialOrd + Clone + PartialEq
|
|
||||||
{
|
|
||||||
type Item = A;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn next(&mut self) -> Option<A> {
|
|
||||||
if !self.done && ((self.rev && self.state >= self.stop) ||
|
|
||||||
(!self.rev && self.state <= self.stop)) {
|
|
||||||
let result = self.state.clone();
|
|
||||||
match self.state.checked_add(&self.step) {
|
|
||||||
Some(x) => self.state = x,
|
|
||||||
None => self.done = true
|
|
||||||
}
|
|
||||||
Some(result)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use std::usize;
|
|
||||||
use std::ops::{Add, Mul};
|
|
||||||
use std::cmp::Ordering;
|
|
||||||
use traits::{One, ToPrimitive};
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_range() {
|
|
||||||
/// A mock type to check Range when ToPrimitive returns None
|
|
||||||
struct Foo;
|
|
||||||
|
|
||||||
impl ToPrimitive for Foo {
|
|
||||||
fn to_i64(&self) -> Option<i64> { None }
|
|
||||||
fn to_u64(&self) -> Option<u64> { None }
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Add<Foo> for Foo {
|
|
||||||
type Output = Foo;
|
|
||||||
|
|
||||||
fn add(self, _: Foo) -> Foo {
|
|
||||||
Foo
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PartialEq for Foo {
|
|
||||||
fn eq(&self, _: &Foo) -> bool {
|
|
||||||
true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PartialOrd for Foo {
|
|
||||||
fn partial_cmp(&self, _: &Foo) -> Option<Ordering> {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Clone for Foo {
|
|
||||||
fn clone(&self) -> Foo {
|
|
||||||
Foo
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Mul<Foo> for Foo {
|
|
||||||
type Output = Foo;
|
|
||||||
|
|
||||||
fn mul(self, _: Foo) -> Foo {
|
|
||||||
Foo
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl One for Foo {
|
|
||||||
fn one() -> Foo {
|
|
||||||
Foo
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
assert!(super::range(0, 5).collect::<Vec<isize>>() == vec![0, 1, 2, 3, 4]);
|
|
||||||
assert!(super::range(-10, -1).collect::<Vec<isize>>() ==
|
|
||||||
vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
|
|
||||||
assert!(super::range(0, 5).rev().collect::<Vec<isize>>() == vec![4, 3, 2, 1, 0]);
|
|
||||||
assert_eq!(super::range(200, -5).count(), 0);
|
|
||||||
assert_eq!(super::range(200, -5).rev().count(), 0);
|
|
||||||
assert_eq!(super::range(200, 200).count(), 0);
|
|
||||||
assert_eq!(super::range(200, 200).rev().count(), 0);
|
|
||||||
|
|
||||||
assert_eq!(super::range(0, 100).size_hint(), (100, Some(100)));
|
|
||||||
// this test is only meaningful when sizeof usize < sizeof u64
|
|
||||||
assert_eq!(super::range(usize::MAX - 1, usize::MAX).size_hint(), (1, Some(1)));
|
|
||||||
assert_eq!(super::range(-10, -1).size_hint(), (9, Some(9)));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_range_inclusive() {
|
|
||||||
assert!(super::range_inclusive(0, 5).collect::<Vec<isize>>() ==
|
|
||||||
vec![0, 1, 2, 3, 4, 5]);
|
|
||||||
assert!(super::range_inclusive(0, 5).rev().collect::<Vec<isize>>() ==
|
|
||||||
vec![5, 4, 3, 2, 1, 0]);
|
|
||||||
assert_eq!(super::range_inclusive(200, -5).count(), 0);
|
|
||||||
assert_eq!(super::range_inclusive(200, -5).rev().count(), 0);
|
|
||||||
assert!(super::range_inclusive(200, 200).collect::<Vec<isize>>() == vec![200]);
|
|
||||||
assert!(super::range_inclusive(200, 200).rev().collect::<Vec<isize>>() == vec![200]);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_range_step() {
|
|
||||||
assert!(super::range_step(0, 20, 5).collect::<Vec<isize>>() ==
|
|
||||||
vec![0, 5, 10, 15]);
|
|
||||||
assert!(super::range_step(20, 0, -5).collect::<Vec<isize>>() ==
|
|
||||||
vec![20, 15, 10, 5]);
|
|
||||||
assert!(super::range_step(20, 0, -6).collect::<Vec<isize>>() ==
|
|
||||||
vec![20, 14, 8, 2]);
|
|
||||||
assert!(super::range_step(200u8, 255, 50).collect::<Vec<u8>>() ==
|
|
||||||
vec![200u8, 250]);
|
|
||||||
assert!(super::range_step(200, -5, 1).collect::<Vec<isize>>() == vec![]);
|
|
||||||
assert!(super::range_step(200, 200, 1).collect::<Vec<isize>>() == vec![]);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_range_step_inclusive() {
|
|
||||||
assert!(super::range_step_inclusive(0, 20, 5).collect::<Vec<isize>>() ==
|
|
||||||
vec![0, 5, 10, 15, 20]);
|
|
||||||
assert!(super::range_step_inclusive(20, 0, -5).collect::<Vec<isize>>() ==
|
|
||||||
vec![20, 15, 10, 5, 0]);
|
|
||||||
assert!(super::range_step_inclusive(20, 0, -6).collect::<Vec<isize>>() ==
|
|
||||||
vec![20, 14, 8, 2]);
|
|
||||||
assert!(super::range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>() ==
|
|
||||||
vec![200u8, 250]);
|
|
||||||
assert!(super::range_step_inclusive(200, -5, 1).collect::<Vec<isize>>() ==
|
|
||||||
vec![]);
|
|
||||||
assert!(super::range_step_inclusive(200, 200, 1).collect::<Vec<isize>>() ==
|
|
||||||
vec![200]);
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,38 +0,0 @@
|
||||||
[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"]
|
|
||||||
categories = [ "algorithms", "data-structures", "science" ]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
name = "num-rational"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
version = "0.1.40"
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
|
|
||||||
[dependencies.num-bigint]
|
|
||||||
optional = true
|
|
||||||
path = "../bigint"
|
|
||||||
version = "0.1.32"
|
|
||||||
|
|
||||||
[dependencies.num-integer]
|
|
||||||
path = "../integer"
|
|
||||||
version = "0.1.32"
|
|
||||||
|
|
||||||
[dependencies.num-traits]
|
|
||||||
path = "../traits"
|
|
||||||
version = "0.1.32"
|
|
||||||
|
|
||||||
[dependencies.rustc-serialize]
|
|
||||||
optional = true
|
|
||||||
version = "0.3.19"
|
|
||||||
|
|
||||||
[dependencies.serde]
|
|
||||||
optional = true
|
|
||||||
version = ">= 0.7.0, < 0.9.0"
|
|
||||||
|
|
||||||
[features]
|
|
||||||
default = ["bigint", "rustc-serialize"]
|
|
||||||
bigint = ["num-bigint"]
|
|
|
@ -1,201 +0,0 @@
|
||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
http://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
APPENDIX: How to apply the Apache License to your work.
|
|
||||||
|
|
||||||
To apply the Apache License to your work, attach the following
|
|
||||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
|
||||||
replaced with your own identifying information. (Don't include
|
|
||||||
the brackets!) The text should be enclosed in the appropriate
|
|
||||||
comment syntax for the file format. We also recommend that a
|
|
||||||
file or class name and description of purpose be included on the
|
|
||||||
same "printed page" as the copyright notice for easier
|
|
||||||
identification within third-party archives.
|
|
||||||
|
|
||||||
Copyright [yyyy] [name of copyright owner]
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
|
@ -1,25 +0,0 @@
|
||||||
Copyright (c) 2014 The Rust Project Developers
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any
|
|
||||||
person obtaining a copy of this software and associated
|
|
||||||
documentation files (the "Software"), to deal in the
|
|
||||||
Software without restriction, including without
|
|
||||||
limitation the rights to use, copy, modify, merge,
|
|
||||||
publish, distribute, sublicense, and/or sell copies of
|
|
||||||
the Software, and to permit persons to whom the Software
|
|
||||||
is furnished to do so, subject to the following
|
|
||||||
conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice
|
|
||||||
shall be included in all copies or substantial portions
|
|
||||||
of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
|
||||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
|
||||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
||||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
||||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
||||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
|
||||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
DEALINGS IN THE SOFTWARE.
|
|
1413
rational/src/lib.rs
1413
rational/src/lib.rs
File diff suppressed because it is too large
Load Diff
500
src/lib.rs
500
src/lib.rs
|
@ -1,4 +1,4 @@
|
||||||
// Copyright 2014-2016 The Rust Project Developers. See the COPYRIGHT
|
// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
|
||||||
// file at the top-level directory of this distribution and at
|
// file at the top-level directory of this distribution and at
|
||||||
// http://rust-lang.org/COPYRIGHT.
|
// http://rust-lang.org/COPYRIGHT.
|
||||||
//
|
//
|
||||||
|
@ -8,104 +8,428 @@
|
||||||
// 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.
|
||||||
|
|
||||||
//! A collection of numeric types and traits for Rust.
|
//! Numeric traits for generic mathematics
|
||||||
//!
|
|
||||||
//! This includes new types for big integers, rationals, and complex numbers,
|
|
||||||
//! new traits for generic programming on numeric properties like `Integer`,
|
|
||||||
//! and generic range iterators.
|
|
||||||
//!
|
|
||||||
//! ## Example
|
|
||||||
//!
|
|
||||||
//! This example uses the BigRational type and [Newton's method][newt] to
|
|
||||||
//! approximate a square root to arbitrary precision:
|
|
||||||
//!
|
|
||||||
//! ```
|
|
||||||
//! extern crate num;
|
|
||||||
//! # #[cfg(all(feature = "bigint", feature="rational"))]
|
|
||||||
//! # mod test {
|
|
||||||
//!
|
|
||||||
//! use num::FromPrimitive;
|
|
||||||
//! use num::bigint::BigInt;
|
|
||||||
//! use num::rational::{Ratio, BigRational};
|
|
||||||
//!
|
|
||||||
//! # pub
|
|
||||||
//! fn approx_sqrt(number: u64, iterations: usize) -> BigRational {
|
|
||||||
//! let start: Ratio<BigInt> = Ratio::from_integer(FromPrimitive::from_u64(number).unwrap());
|
|
||||||
//! let mut approx = start.clone();
|
|
||||||
//!
|
|
||||||
//! for _ in 0..iterations {
|
|
||||||
//! approx = (&approx + (&start / &approx)) /
|
|
||||||
//! Ratio::from_integer(FromPrimitive::from_u64(2).unwrap());
|
|
||||||
//! }
|
|
||||||
//!
|
|
||||||
//! approx
|
|
||||||
//! }
|
|
||||||
//! # }
|
|
||||||
//! # #[cfg(not(all(feature = "bigint", feature="rational")))]
|
|
||||||
//! # mod test { pub fn approx_sqrt(n: u64, _: usize) -> u64 { n } }
|
|
||||||
//! # use test::approx_sqrt;
|
|
||||||
//!
|
|
||||||
//! fn main() {
|
|
||||||
//! println!("{}", approx_sqrt(10, 4)); // prints 4057691201/1283082416
|
|
||||||
//! }
|
|
||||||
//!
|
|
||||||
//! ```
|
|
||||||
//!
|
|
||||||
//! [newt]: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
|
|
||||||
#![doc(html_logo_url = "https://rust-num.github.io/num/rust-logo-128x128-blk-v2.png",
|
|
||||||
html_favicon_url = "https://rust-num.github.io/num/favicon.ico",
|
|
||||||
html_root_url = "https://rust-num.github.io/num/",
|
|
||||||
html_playground_url = "http://play.integer32.com/")]
|
|
||||||
|
|
||||||
extern crate num_traits;
|
#![doc(html_root_url = "https://docs.rs/num-traits/0.1")]
|
||||||
extern crate num_integer;
|
|
||||||
extern crate num_iter;
|
|
||||||
#[cfg(feature = "num-complex")]
|
|
||||||
extern crate num_complex;
|
|
||||||
#[cfg(feature = "num-bigint")]
|
|
||||||
extern crate num_bigint;
|
|
||||||
#[cfg(feature = "num-rational")]
|
|
||||||
extern crate num_rational;
|
|
||||||
|
|
||||||
#[cfg(feature = "num-bigint")]
|
use std::ops::{Add, Sub, Mul, Div, Rem};
|
||||||
pub use num_bigint::{BigInt, BigUint};
|
use std::ops::{AddAssign, SubAssign, MulAssign, DivAssign, RemAssign};
|
||||||
#[cfg(feature = "num-rational")]
|
use std::num::Wrapping;
|
||||||
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,
|
|
||||||
one, zero, abs, abs_sub, signum,
|
|
||||||
Saturating, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv,
|
|
||||||
PrimInt, Float, ToPrimitive, FromPrimitive, NumCast, cast,
|
|
||||||
pow, checked_pow, clamp};
|
|
||||||
|
|
||||||
#[cfg(feature = "num-bigint")]
|
pub use bounds::Bounded;
|
||||||
pub mod bigint {
|
pub use float::{Float, FloatConst};
|
||||||
pub use num_bigint::*;
|
pub use identities::{Zero, One, zero, one};
|
||||||
|
pub use ops::checked::*;
|
||||||
|
pub use ops::wrapping::*;
|
||||||
|
pub use ops::saturating::Saturating;
|
||||||
|
pub use sign::{Signed, Unsigned, abs, abs_sub, signum};
|
||||||
|
pub use cast::*;
|
||||||
|
pub use int::PrimInt;
|
||||||
|
pub use pow::{pow, checked_pow};
|
||||||
|
|
||||||
|
pub mod identities;
|
||||||
|
pub mod sign;
|
||||||
|
pub mod ops;
|
||||||
|
pub mod bounds;
|
||||||
|
pub mod float;
|
||||||
|
pub mod cast;
|
||||||
|
pub mod int;
|
||||||
|
pub mod pow;
|
||||||
|
|
||||||
|
/// The base trait for numeric types, covering `0` and `1` values,
|
||||||
|
/// comparisons, basic numeric operations, and string conversion.
|
||||||
|
pub trait Num: PartialEq + Zero + One + NumOps
|
||||||
|
{
|
||||||
|
type FromStrRadixErr;
|
||||||
|
|
||||||
|
/// Convert from a string and radix <= 36.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// use num_traits::Num;
|
||||||
|
///
|
||||||
|
/// let result = <i32 as Num>::from_str_radix("27", 10);
|
||||||
|
/// assert_eq!(result, Ok(27));
|
||||||
|
///
|
||||||
|
/// let result = <i32 as Num>::from_str_radix("foo", 10);
|
||||||
|
/// assert!(result.is_err());
|
||||||
|
/// ```
|
||||||
|
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>;
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(feature = "num-complex")]
|
/// The trait for types implementing basic numeric operations
|
||||||
pub mod complex {
|
///
|
||||||
pub use num_complex::*;
|
/// This is automatically implemented for types which implement the operators.
|
||||||
|
pub trait NumOps<Rhs = Self, Output = Self>
|
||||||
|
: Add<Rhs, Output = Output>
|
||||||
|
+ Sub<Rhs, Output = Output>
|
||||||
|
+ Mul<Rhs, Output = Output>
|
||||||
|
+ Div<Rhs, Output = Output>
|
||||||
|
+ Rem<Rhs, Output = Output>
|
||||||
|
{}
|
||||||
|
|
||||||
|
impl<T, Rhs, Output> NumOps<Rhs, Output> for T
|
||||||
|
where T: Add<Rhs, Output = Output>
|
||||||
|
+ Sub<Rhs, Output = Output>
|
||||||
|
+ Mul<Rhs, Output = Output>
|
||||||
|
+ Div<Rhs, Output = Output>
|
||||||
|
+ Rem<Rhs, Output = Output>
|
||||||
|
{}
|
||||||
|
|
||||||
|
/// The trait for `Num` types which also implement numeric operations taking
|
||||||
|
/// the second operand by reference.
|
||||||
|
///
|
||||||
|
/// This is automatically implemented for types which implement the operators.
|
||||||
|
pub trait NumRef: Num + for<'r> NumOps<&'r Self> {}
|
||||||
|
impl<T> NumRef for T where T: Num + for<'r> NumOps<&'r T> {}
|
||||||
|
|
||||||
|
/// The trait for references which implement numeric operations, taking the
|
||||||
|
/// second operand either by value or by reference.
|
||||||
|
///
|
||||||
|
/// This is automatically implemented for types which implement the operators.
|
||||||
|
pub trait RefNum<Base>: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base> {}
|
||||||
|
impl<T, Base> RefNum<Base> for T where T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base> {}
|
||||||
|
|
||||||
|
/// The trait for types implementing numeric assignment operators (like `+=`).
|
||||||
|
///
|
||||||
|
/// This is automatically implemented for types which implement the operators.
|
||||||
|
pub trait NumAssignOps<Rhs = Self>
|
||||||
|
: AddAssign<Rhs>
|
||||||
|
+ SubAssign<Rhs>
|
||||||
|
+ MulAssign<Rhs>
|
||||||
|
+ DivAssign<Rhs>
|
||||||
|
+ RemAssign<Rhs>
|
||||||
|
{}
|
||||||
|
|
||||||
|
impl<T, Rhs> NumAssignOps<Rhs> for T
|
||||||
|
where T: AddAssign<Rhs>
|
||||||
|
+ SubAssign<Rhs>
|
||||||
|
+ MulAssign<Rhs>
|
||||||
|
+ DivAssign<Rhs>
|
||||||
|
+ RemAssign<Rhs>
|
||||||
|
{}
|
||||||
|
|
||||||
|
/// The trait for `Num` types which also implement assignment operators.
|
||||||
|
///
|
||||||
|
/// This is automatically implemented for types which implement the operators.
|
||||||
|
pub trait NumAssign: Num + NumAssignOps {}
|
||||||
|
impl<T> NumAssign for T where T: Num + NumAssignOps {}
|
||||||
|
|
||||||
|
/// The trait for `NumAssign` types which also implement assignment operations
|
||||||
|
/// taking the second operand by reference.
|
||||||
|
///
|
||||||
|
/// This is automatically implemented for types which implement the operators.
|
||||||
|
pub trait NumAssignRef: NumAssign + for<'r> NumAssignOps<&'r Self> {}
|
||||||
|
impl<T> NumAssignRef for T where T: NumAssign + for<'r> NumAssignOps<&'r T> {}
|
||||||
|
|
||||||
|
|
||||||
|
macro_rules! int_trait_impl {
|
||||||
|
($name:ident for $($t:ty)*) => ($(
|
||||||
|
impl $name for $t {
|
||||||
|
type FromStrRadixErr = ::std::num::ParseIntError;
|
||||||
|
#[inline]
|
||||||
|
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);
|
||||||
|
|
||||||
|
impl<T: Num> Num for Wrapping<T>
|
||||||
|
where Wrapping<T>:
|
||||||
|
Add<Output = Wrapping<T>> + Sub<Output = Wrapping<T>>
|
||||||
|
+ Mul<Output = Wrapping<T>> + Div<Output = Wrapping<T>> + Rem<Output = Wrapping<T>>
|
||||||
|
{
|
||||||
|
type FromStrRadixErr = T::FromStrRadixErr;
|
||||||
|
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
|
||||||
|
T::from_str_radix(str, radix).map(Wrapping)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub mod integer {
|
|
||||||
pub use num_integer::*;
|
#[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,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub mod iter {
|
// FIXME: The standard library from_str_radix on floats was deprecated, so we're stuck
|
||||||
pub use num_iter::*;
|
// 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);
|
||||||
|
|
||||||
|
/// A value bounded by a minimum and a maximum
|
||||||
|
///
|
||||||
|
/// If input is less than min then this returns min.
|
||||||
|
/// If input is greater than max then this returns max.
|
||||||
|
/// Otherwise this returns input.
|
||||||
|
#[inline]
|
||||||
|
pub fn clamp<T: PartialOrd>(input: T, min: T, max: T) -> T {
|
||||||
|
debug_assert!(min <= max, "min must be less than or equal to max");
|
||||||
|
if input < min {
|
||||||
|
min
|
||||||
|
} else if input > max {
|
||||||
|
max
|
||||||
|
} else {
|
||||||
|
input
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub mod traits {
|
#[test]
|
||||||
pub use num_traits::*;
|
fn clamp_test() {
|
||||||
|
// Int test
|
||||||
|
assert_eq!(1, clamp(1, -1, 2));
|
||||||
|
assert_eq!(-1, clamp(-2, -1, 2));
|
||||||
|
assert_eq!(2, clamp(3, -1, 2));
|
||||||
|
|
||||||
|
// Float test
|
||||||
|
assert_eq!(1.0, clamp(1.0, -1.0, 2.0));
|
||||||
|
assert_eq!(-1.0, clamp(-2.0, -1.0, 2.0));
|
||||||
|
assert_eq!(2.0, clamp(3.0, -1.0, 2.0));
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(feature = "num-rational")]
|
#[test]
|
||||||
pub mod rational {
|
fn from_str_radix_unwrap() {
|
||||||
pub use num_rational::*;
|
// 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);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_num() {
|
||||||
|
fn require_num<T: Num>(_: &T) {}
|
||||||
|
require_num(&Wrapping(42_u32));
|
||||||
|
require_num(&Wrapping(-42));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_from_str_radix() {
|
||||||
|
macro_rules! test_wrapping_from_str_radix {
|
||||||
|
($($t:ty)+) => {
|
||||||
|
$(
|
||||||
|
for &(s, r) in &[("42", 10), ("42", 2), ("-13.0", 10), ("foo", 10)] {
|
||||||
|
let w = Wrapping::<$t>::from_str_radix(s, r).map(|w| w.0);
|
||||||
|
assert_eq!(w, <$t as Num>::from_str_radix(s, r));
|
||||||
|
}
|
||||||
|
)+
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
test_wrapping_from_str_radix!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn check_num_ops() {
|
||||||
|
fn compute<T: Num + Copy>(x: T, y: T) -> T {
|
||||||
|
x * y / y % y + y - y
|
||||||
|
}
|
||||||
|
assert_eq!(compute(1, 2), 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn check_numref_ops() {
|
||||||
|
fn compute<T: NumRef>(x: T, y: &T) -> T {
|
||||||
|
x * y / y % y + y - y
|
||||||
|
}
|
||||||
|
assert_eq!(compute(1, &2), 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn check_refnum_ops() {
|
||||||
|
fn compute<T: Copy>(x: &T, y: T) -> T
|
||||||
|
where for<'a> &'a T: RefNum<T>
|
||||||
|
{
|
||||||
|
&(&(&(&(x * y) / y) % y) + y) - y
|
||||||
|
}
|
||||||
|
assert_eq!(compute(&1, 2), 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn check_refref_ops() {
|
||||||
|
fn compute<T>(x: &T, y: &T) -> T
|
||||||
|
where for<'a> &'a T: RefNum<T>
|
||||||
|
{
|
||||||
|
&(&(&(&(x * y) / y) % y) + y) - y
|
||||||
|
}
|
||||||
|
assert_eq!(compute(&1, &2), 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn check_numassign_ops() {
|
||||||
|
fn compute<T: NumAssign + Copy>(mut x: T, y: T) -> T {
|
||||||
|
x *= y;
|
||||||
|
x /= y;
|
||||||
|
x %= y;
|
||||||
|
x += y;
|
||||||
|
x -= y;
|
||||||
|
x
|
||||||
|
}
|
||||||
|
assert_eq!(compute(1, 2), 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO test `NumAssignRef`, but even the standard numeric types don't
|
||||||
|
// implement this yet. (see rust pr41336)
|
||||||
|
|
|
@ -1,13 +0,0 @@
|
||||||
[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"]
|
|
||||||
categories = [ "algorithms", "science" ]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
name = "num-traits"
|
|
||||||
version = "0.1.41"
|
|
||||||
|
|
||||||
[dependencies]
|
|
|
@ -1,201 +0,0 @@
|
||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
http://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
APPENDIX: How to apply the Apache License to your work.
|
|
||||||
|
|
||||||
To apply the Apache License to your work, attach the following
|
|
||||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
|
||||||
replaced with your own identifying information. (Don't include
|
|
||||||
the brackets!) The text should be enclosed in the appropriate
|
|
||||||
comment syntax for the file format. We also recommend that a
|
|
||||||
file or class name and description of purpose be included on the
|
|
||||||
same "printed page" as the copyright notice for easier
|
|
||||||
identification within third-party archives.
|
|
||||||
|
|
||||||
Copyright [yyyy] [name of copyright owner]
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
|
@ -1,25 +0,0 @@
|
||||||
Copyright (c) 2014 The Rust Project Developers
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any
|
|
||||||
person obtaining a copy of this software and associated
|
|
||||||
documentation files (the "Software"), to deal in the
|
|
||||||
Software without restriction, including without
|
|
||||||
limitation the rights to use, copy, modify, merge,
|
|
||||||
publish, distribute, sublicense, and/or sell copies of
|
|
||||||
the Software, and to permit persons to whom the Software
|
|
||||||
is furnished to do so, subject to the following
|
|
||||||
conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice
|
|
||||||
shall be included in all copies or substantial portions
|
|
||||||
of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
|
||||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
|
||||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
||||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
||||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
||||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
|
||||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
DEALINGS IN THE SOFTWARE.
|
|
|
@ -1,437 +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 <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
|
|
||||||
#![doc(html_logo_url = "https://rust-num.github.io/num/rust-logo-128x128-blk-v2.png",
|
|
||||||
html_favicon_url = "https://rust-num.github.io/num/favicon.ico",
|
|
||||||
html_root_url = "https://rust-num.github.io/num/",
|
|
||||||
html_playground_url = "http://play.integer32.com/")]
|
|
||||||
|
|
||||||
use std::ops::{Add, Sub, Mul, Div, Rem};
|
|
||||||
use std::ops::{AddAssign, SubAssign, MulAssign, DivAssign, RemAssign};
|
|
||||||
use std::num::Wrapping;
|
|
||||||
|
|
||||||
pub use bounds::Bounded;
|
|
||||||
pub use float::{Float, FloatConst};
|
|
||||||
pub use identities::{Zero, One, zero, one};
|
|
||||||
pub use ops::checked::*;
|
|
||||||
pub use ops::wrapping::*;
|
|
||||||
pub use ops::saturating::Saturating;
|
|
||||||
pub use sign::{Signed, Unsigned, abs, abs_sub, signum};
|
|
||||||
pub use cast::*;
|
|
||||||
pub use int::PrimInt;
|
|
||||||
pub use pow::{pow, checked_pow};
|
|
||||||
|
|
||||||
pub mod identities;
|
|
||||||
pub mod sign;
|
|
||||||
pub mod ops;
|
|
||||||
pub mod bounds;
|
|
||||||
pub mod float;
|
|
||||||
pub mod cast;
|
|
||||||
pub mod int;
|
|
||||||
pub mod pow;
|
|
||||||
|
|
||||||
/// The base trait for numeric types, covering `0` and `1` values,
|
|
||||||
/// comparisons, basic numeric operations, and string conversion.
|
|
||||||
pub trait Num: PartialEq + Zero + One + NumOps
|
|
||||||
{
|
|
||||||
type FromStrRadixErr;
|
|
||||||
|
|
||||||
/// Convert from a string and radix <= 36.
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ```rust
|
|
||||||
/// use num_traits::Num;
|
|
||||||
///
|
|
||||||
/// let result = <i32 as Num>::from_str_radix("27", 10);
|
|
||||||
/// assert_eq!(result, Ok(27));
|
|
||||||
///
|
|
||||||
/// let result = <i32 as Num>::from_str_radix("foo", 10);
|
|
||||||
/// assert!(result.is_err());
|
|
||||||
/// ```
|
|
||||||
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The trait for types implementing basic numeric operations
|
|
||||||
///
|
|
||||||
/// This is automatically implemented for types which implement the operators.
|
|
||||||
pub trait NumOps<Rhs = Self, Output = Self>
|
|
||||||
: Add<Rhs, Output = Output>
|
|
||||||
+ Sub<Rhs, Output = Output>
|
|
||||||
+ Mul<Rhs, Output = Output>
|
|
||||||
+ Div<Rhs, Output = Output>
|
|
||||||
+ Rem<Rhs, Output = Output>
|
|
||||||
{}
|
|
||||||
|
|
||||||
impl<T, Rhs, Output> NumOps<Rhs, Output> for T
|
|
||||||
where T: Add<Rhs, Output = Output>
|
|
||||||
+ Sub<Rhs, Output = Output>
|
|
||||||
+ Mul<Rhs, Output = Output>
|
|
||||||
+ Div<Rhs, Output = Output>
|
|
||||||
+ Rem<Rhs, Output = Output>
|
|
||||||
{}
|
|
||||||
|
|
||||||
/// The trait for `Num` types which also implement numeric operations taking
|
|
||||||
/// the second operand by reference.
|
|
||||||
///
|
|
||||||
/// This is automatically implemented for types which implement the operators.
|
|
||||||
pub trait NumRef: Num + for<'r> NumOps<&'r Self> {}
|
|
||||||
impl<T> NumRef for T where T: Num + for<'r> NumOps<&'r T> {}
|
|
||||||
|
|
||||||
/// The trait for references which implement numeric operations, taking the
|
|
||||||
/// second operand either by value or by reference.
|
|
||||||
///
|
|
||||||
/// This is automatically implemented for types which implement the operators.
|
|
||||||
pub trait RefNum<Base>: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base> {}
|
|
||||||
impl<T, Base> RefNum<Base> for T where T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base> {}
|
|
||||||
|
|
||||||
/// The trait for types implementing numeric assignment operators (like `+=`).
|
|
||||||
///
|
|
||||||
/// This is automatically implemented for types which implement the operators.
|
|
||||||
pub trait NumAssignOps<Rhs = Self>
|
|
||||||
: AddAssign<Rhs>
|
|
||||||
+ SubAssign<Rhs>
|
|
||||||
+ MulAssign<Rhs>
|
|
||||||
+ DivAssign<Rhs>
|
|
||||||
+ RemAssign<Rhs>
|
|
||||||
{}
|
|
||||||
|
|
||||||
impl<T, Rhs> NumAssignOps<Rhs> for T
|
|
||||||
where T: AddAssign<Rhs>
|
|
||||||
+ SubAssign<Rhs>
|
|
||||||
+ MulAssign<Rhs>
|
|
||||||
+ DivAssign<Rhs>
|
|
||||||
+ RemAssign<Rhs>
|
|
||||||
{}
|
|
||||||
|
|
||||||
/// The trait for `Num` types which also implement assignment operators.
|
|
||||||
///
|
|
||||||
/// This is automatically implemented for types which implement the operators.
|
|
||||||
pub trait NumAssign: Num + NumAssignOps {}
|
|
||||||
impl<T> NumAssign for T where T: Num + NumAssignOps {}
|
|
||||||
|
|
||||||
/// The trait for `NumAssign` types which also implement assignment operations
|
|
||||||
/// taking the second operand by reference.
|
|
||||||
///
|
|
||||||
/// This is automatically implemented for types which implement the operators.
|
|
||||||
pub trait NumAssignRef: NumAssign + for<'r> NumAssignOps<&'r Self> {}
|
|
||||||
impl<T> NumAssignRef for T where T: NumAssign + for<'r> NumAssignOps<&'r T> {}
|
|
||||||
|
|
||||||
|
|
||||||
macro_rules! int_trait_impl {
|
|
||||||
($name:ident for $($t:ty)*) => ($(
|
|
||||||
impl $name for $t {
|
|
||||||
type FromStrRadixErr = ::std::num::ParseIntError;
|
|
||||||
#[inline]
|
|
||||||
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);
|
|
||||||
|
|
||||||
impl<T: Num> Num for Wrapping<T>
|
|
||||||
where Wrapping<T>:
|
|
||||||
Add<Output = Wrapping<T>> + Sub<Output = Wrapping<T>>
|
|
||||||
+ Mul<Output = Wrapping<T>> + Div<Output = Wrapping<T>> + Rem<Output = Wrapping<T>>
|
|
||||||
{
|
|
||||||
type FromStrRadixErr = T::FromStrRadixErr;
|
|
||||||
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
|
|
||||||
T::from_str_radix(str, radix).map(Wrapping)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#[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);
|
|
||||||
|
|
||||||
/// A value bounded by a minimum and a maximum
|
|
||||||
///
|
|
||||||
/// If input is less than min then this returns min.
|
|
||||||
/// If input is greater than max then this returns max.
|
|
||||||
/// Otherwise this returns input.
|
|
||||||
#[inline]
|
|
||||||
pub fn clamp<T: PartialOrd>(input: T, min: T, max: T) -> T {
|
|
||||||
debug_assert!(min <= max, "min must be less than or equal to max");
|
|
||||||
if input < min {
|
|
||||||
min
|
|
||||||
} else if input > max {
|
|
||||||
max
|
|
||||||
} else {
|
|
||||||
input
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn clamp_test() {
|
|
||||||
// Int test
|
|
||||||
assert_eq!(1, clamp(1, -1, 2));
|
|
||||||
assert_eq!(-1, clamp(-2, -1, 2));
|
|
||||||
assert_eq!(2, clamp(3, -1, 2));
|
|
||||||
|
|
||||||
// Float test
|
|
||||||
assert_eq!(1.0, clamp(1.0, -1.0, 2.0));
|
|
||||||
assert_eq!(-1.0, clamp(-2.0, -1.0, 2.0));
|
|
||||||
assert_eq!(2.0, clamp(3.0, -1.0, 2.0));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[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);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_is_num() {
|
|
||||||
fn require_num<T: Num>(_: &T) {}
|
|
||||||
require_num(&Wrapping(42_u32));
|
|
||||||
require_num(&Wrapping(-42));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_from_str_radix() {
|
|
||||||
macro_rules! test_wrapping_from_str_radix {
|
|
||||||
($($t:ty)+) => {
|
|
||||||
$(
|
|
||||||
for &(s, r) in &[("42", 10), ("42", 2), ("-13.0", 10), ("foo", 10)] {
|
|
||||||
let w = Wrapping::<$t>::from_str_radix(s, r).map(|w| w.0);
|
|
||||||
assert_eq!(w, <$t as Num>::from_str_radix(s, r));
|
|
||||||
}
|
|
||||||
)+
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
test_wrapping_from_str_radix!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn check_num_ops() {
|
|
||||||
fn compute<T: Num + Copy>(x: T, y: T) -> T {
|
|
||||||
x * y / y % y + y - y
|
|
||||||
}
|
|
||||||
assert_eq!(compute(1, 2), 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn check_numref_ops() {
|
|
||||||
fn compute<T: NumRef>(x: T, y: &T) -> T {
|
|
||||||
x * y / y % y + y - y
|
|
||||||
}
|
|
||||||
assert_eq!(compute(1, &2), 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn check_refnum_ops() {
|
|
||||||
fn compute<T: Copy>(x: &T, y: T) -> T
|
|
||||||
where for<'a> &'a T: RefNum<T>
|
|
||||||
{
|
|
||||||
&(&(&(&(x * y) / y) % y) + y) - y
|
|
||||||
}
|
|
||||||
assert_eq!(compute(&1, 2), 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn check_refref_ops() {
|
|
||||||
fn compute<T>(x: &T, y: &T) -> T
|
|
||||||
where for<'a> &'a T: RefNum<T>
|
|
||||||
{
|
|
||||||
&(&(&(&(x * y) / y) % y) + y) - y
|
|
||||||
}
|
|
||||||
assert_eq!(compute(&1, &2), 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn check_numassign_ops() {
|
|
||||||
fn compute<T: NumAssign + Copy>(mut x: T, y: T) -> T {
|
|
||||||
x *= y;
|
|
||||||
x /= y;
|
|
||||||
x %= y;
|
|
||||||
x += y;
|
|
||||||
x -= y;
|
|
||||||
x
|
|
||||||
}
|
|
||||||
assert_eq!(compute(1, 2), 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
// TODO test `NumAssignRef`, but even the standard numeric types don't
|
|
||||||
// implement this yet. (see rust pr41336)
|
|
Loading…
Reference in New Issue