Compare commits
379 Commits
num-traits
...
master
Author | SHA1 | Date |
---|---|---|
bors[bot] | 2f0cffd522 | |
bors[bot] | 4fc3d8f72d | |
Josh Stone | 06b3f854d4 | |
bors[bot] | 5b9f6e4c47 | |
Josh Stone | 93328dfc90 | |
Josh Stone | c4256bd4df | |
Josh Stone | b64ee3809c | |
Josh Stone | 27b9202ff3 | |
Yoan Lecoq | f050c60df9 | |
Yoan Lecoq | 2d113f56c8 | |
Yoan Lecoq | 63047365be | |
Yoan Lecoq | 0547a355ee | |
Yoan Lecoq | 4b1ea5fb12 | |
Yoan Lecoq | 1b28e6182d | |
Yoan Lecoq | 55c5b7455a | |
Yoan Lecoq | c28e2fe062 | |
Yoan Lecoq | aaf3c267bd | |
Yoan Lecoq | 849e2a0b1b | |
Yoan Lecoq | 4234eb76aa | |
Yoan Lecoq | 4d3cb0a4ba | |
Yoan Lecoq | f523f532e6 | |
Yoan Lecoq | b4558d1c49 | |
Yoan Lecoq | fec6c3610c | |
bors[bot] | d394467906 | |
Jim Turner | 987ed8fd38 | |
Jim Turner | d02f166765 | |
Jim Turner | 33b74618b6 | |
bors[bot] | 428f89a7d5 | |
Toshiki Teramura | 0e7c2a4a00 | |
bors[bot] | 3add713434 | |
Sergey "Shnatsel" Davidoff | 40898e5071 | |
Toshiki Teramura | 973ba72e4f | |
Toshiki Teramura | e7ba9b62dc | |
Toshiki Teramura | 2fb8a6e8a9 | |
Josh Stone | b8906eff1b | |
Josh Stone | 7a61e79757 | |
bors[bot] | 45067c1357 | |
Andreas Molzer | cd0da1ae5e | |
Toshiki Teramura | f20d74fce8 | |
Toshiki Teramura | e8dce19146 | |
bors[bot] | 58f02a8677 | |
Bruce Mitchener | d1f5658bfe | |
Bruce Mitchener | 107a326745 | |
bors[bot] | 84e14d4f36 | |
Josh Stone | 2c2cfe1bf3 | |
Josh Stone | a194d91625 | |
bors[bot] | 8e765ee1ff | |
Josh Stone | 6d62b6a228 | |
bors[bot] | 852ec9380f | |
Josh Stone | 615d83a5b6 | |
bors[bot] | 38655c91c1 | |
Josh Stone | a1688f6991 | |
Josh Stone | c38b4b601d | |
bors[bot] | 4ab251b0a2 | |
bors[bot] | 5404658360 | |
Josh Stone | 09e27abaa0 | |
lcnr/Bastian Kauschke | 87d4dbc418 | |
David Rheinsberg | 398c298fa9 | |
bors[bot] | 8915b74ae4 | |
lcnr/Bastian Kauschke | 9cd2422221 | |
lcnr/Bastian Kauschke | d2a1e035ad | |
lcnr/Bastian Kauschke | 8ac6a62a6e | |
lcnr/Bastian Kauschke | f06893feb0 | |
lcnr/Bastian Kauschke | 80052795ba | |
lcnr/Bastian Kauschke | f3869040c7 | |
bors[bot] | d668985fae | |
Igor Gnatenko | ff45e00849 | |
bors[bot] | 2925f10f40 | |
Samuel Tardieu | fc4f1afdf6 | |
bors[bot] | 5c24fcc4a7 | |
Josh Stone | b8ad107c1c | |
bors[bot] | ac7e550b00 | |
Ed McCardell | abb51f9a09 | |
bors[bot] | 5985a8b750 | |
Roald | 2b975badfa | |
Roald | 0f228be4d5 | |
bors[bot] | a415e2a751 | |
Josh Stone | d2bf4e04e4 | |
Josh Stone | 83841d15f8 | |
bors[bot] | e796afc83a | |
Josh Stone | 714057979e | |
Josh Stone | 60924ecc70 | |
Josh Stone | 21e3620999 | |
Josh Stone | dd7900d62f | |
Josh Stone | d968efbc76 | |
bors[bot] | 15dc0e7127 | |
Corey Farwell | 4775dee66b | |
bors[bot] | f4125621ac | |
Josh Stone | c00ae2046e | |
Josh Stone | 51f6c57c4b | |
bors[bot] | 4e136ddc85 | |
Josh Stone | 4a03db4e1c | |
bors[bot] | c3feb40897 | |
Josh Stone | 7e055b131f | |
Josh Stone | 5add4c580e | |
Josh Stone | 817ef94784 | |
Josh Stone | f35cce229e | |
bors[bot] | 6edb91f5e8 | |
Josh Stone | 1af2319201 | |
Josh Stone | bbbc2bd1d7 | |
Josh Stone | 6161f1ade1 | |
Josh Stone | fe53805550 | |
Josh Stone | 428e0107d2 | |
Josh Stone | d2107ae005 | |
Josh Stone | 08ad9b1642 | |
Josh Stone | 261efafe0b | |
bors[bot] | dd67e9d2e1 | |
Josh Stone | 6aaff332d3 | |
bors[bot] | a49013e338 | |
Josh Stone | 0d358034d9 | |
Vincent Esche | 157efc5a26 | |
Vincent Esche | 28be885481 | |
Vincent Esche | 257917f3f2 | |
Josh Stone | 4fb749a401 | |
bors[bot] | 4195043240 | |
Josh Stone | aa21fba9fc | |
Josh Stone | b1c4074cc4 | |
Josh Stone | 5fb3724b69 | |
LEXUGE | f74de249c8 | |
Vinzent Steinberg | 9ca219c677 | |
bors[bot] | 97f3892bd1 | |
Vinzent Steinberg | 2836cfc9ab | |
Vinzent Steinberg | 6430351e74 | |
Vincent Esche | dd5b107c56 | |
Vincent Esche | 746db74dac | |
Vincent Esche | 152b38e03f | |
Vincent Esche | 6d3b55030f | |
Vincent Esche | 830363024b | |
Vincent Esche | d1334bf903 | |
Vincent Esche | f69af180cc | |
Vincent Esche | 5ee2570618 | |
Vincent Esche | 234706fb97 | |
Vincent Esche | b44666183d | |
Vincent Esche | bc19c34934 | |
Vincent Esche | 62723f6f3a | |
Vincent Esche | f8d1896c6c | |
bors[bot] | bb67a3d03a | |
Josh Stone | 058a6004f0 | |
bors[bot] | fcc33a3577 | |
Josh Stone | a4d234c253 | |
Josh Stone | f0ed42b3bc | |
Josh Stone | 50868c60d2 | |
Josh Stone | 6d7bbb1b53 | |
Josh Stone | d195eafbe2 | |
Josh Stone | f6dc4d29a4 | |
Josh Stone | b025c273c7 | |
Dan Barella | 8e27c7327d | |
Dan Barella | aab7098acd | |
Alexander Popiak | c32cb5c65b | |
Dan Barella | ab8fda7654 | |
Dan Barella | ecb0816c83 | |
Dan Barella | 3534a89858 | |
Dan Barella | f99aa0e181 | |
bors[bot] | aa36cdb206 | |
Josh Stone | ab0de9c329 | |
bors[bot] | 5f906234bc | |
Josh Stone | 04a3f2a591 | |
Josh Stone | 080f6f259e | |
Josh Stone | aa9ceba628 | |
Josh Stone | ec3cd50f3d | |
Josh Stone | ac6eca4b66 | |
Josh Stone | 36c7e324db | |
Josh Stone | 964a7e52a8 | |
Josh Stone | 8d16921579 | |
Josh Stone | 6fa29be7c0 | |
Josh Stone | 83d498d0be | |
Josh Stone | f365a4205f | |
Josh Stone | 99c6cc11ba | |
Josh Stone | 7d6575da0f | |
Josh Stone | ac503261ca | |
Josh Stone | c848562fcf | |
bors[bot] | dc6a125a9c | |
Clar Charr | 79b557f040 | |
Clar Charr | aca8dc8149 | |
Clar Charr | 61a6acc9c2 | |
Clar Charr | 5d6933f34a | |
Clar Charr | ce3badca57 | |
Clar Charr | c1f4118b4e | |
Clar Charr | 5bdff3f0ff | |
bors[bot] | 3431da80a2 | |
Clar Charr | 51dad501aa | |
Clar Charr | 45856ee846 | |
Clar Charr | 9461cd84f2 | |
bors[bot] | bfd62d4638 | |
Vinzent Steinberg | 52bc8eb22b | |
Vinzent Steinberg | d115dadeb1 | |
Vinzent Steinberg | 1db660ed56 | |
Vinzent Steinberg | efad5329b4 | |
Josh Stone | a062bed8b2 | |
bors[bot] | 17cc9c1e75 | |
Josh Stone | 2566d53ad2 | |
Josh Stone | aa9ea42f9e | |
Vinzent Steinberg | 8a7f383eb1 | |
Josh Stone | 47515a10e1 | |
bors[bot] | afa81f80e4 | |
Toshiki Teramura | ffa67c8527 | |
Josh Stone | 67f03391a1 | |
Josh Stone | 36b2514f4b | |
Josh Stone | 4fbc583eb9 | |
Josh Stone | 79786ac518 | |
Josh Stone | e6bb97b3ac | |
Vinzent Steinberg | a843027b56 | |
bors[bot] | 3716330128 | |
Josh Stone | ff73e62d93 | |
bors[bot] | 93be5dbff2 | |
Yoan Lecoq | 1e892e2238 | |
Yoan Lecoq | a2337f392b | |
bors[bot] | aa7c15e0e9 | |
Eduardo Pinho | 31218add95 | |
Fabian Schuiki | 809ccff63f | |
bors[bot] | 9c8676e6d5 | |
Yoan Lecoq | ddd664ae2b | |
Yoan Lecoq | 52c87dd410 | |
Yoan Lecoq | 5a6997c1c8 | |
svartalf | 53ab360d94 | |
Fabian Schuiki | 21dfae004c | |
Eduardo Pinho | af693fef48 | |
Eduardo Pinho | 773a222237 | |
Eduardo Pinho | 741e1f4e09 | |
Josh Stone | 42a610d323 | |
bors[bot] | f172ef3a6b | |
bors[bot] | a0c431e270 | |
Josh Stone | d90ae0ae8b | |
Josh Stone | bd1701ded4 | |
Mikhail Hogrefe | 56a029b20f | |
Josh Stone | c24f76781b | |
Josh Stone | 98cb815183 | |
Josh Stone | 18b48f335e | |
Josh Stone | 0e1c4c8b65 | |
bors[bot] | 0e31f3c6b3 | |
Josh Stone | a7464b2b42 | |
Josh Stone | d354559365 | |
Josh Stone | cc3be86781 | |
bors[bot] | ca7e438d77 | |
Josh Stone | b67f1bd6d6 | |
bors[bot] | a203e9f9fc | |
Josh Stone | ed10d617b5 | |
Josh Stone | 35b7187e83 | |
Josh Stone | bb0c9324b2 | |
Josh Stone | b380880ed3 | |
Josh Stone | 96c4a26624 | |
Josh Stone | 7fa27b6007 | |
Josh Stone | 5708db0f67 | |
Josh Stone | 5a0de140c9 | |
Josh Stone | 4d35815426 | |
Josh Stone | aea5f85216 | |
Josh Stone | c2fba06787 | |
Josh Stone | 2a1fe6e7ef | |
bors[bot] | fc39e1beaa | |
Matt Brubeck | 531c2a754f | |
str4d | 720893f67b | |
str4d | f523b9c359 | |
bors[bot] | 741a5a6207 | |
Josh Stone | 2f8f952d1d | |
Josh Stone | 2a9750ada4 | |
Josh Stone | 7679cb86fb | |
bors[bot] | 4896746fec | |
Josh Stone | 1ddbee7f37 | |
Josh Stone | 28d84ca3ac | |
Josh Stone | 2c2e46c8df | |
Josh Stone | 05dc87c041 | |
bors[bot] | 8646be5a95 | |
Josh Stone | 3c1c84307c | |
Josh Stone | 952dba4e06 | |
bors[bot] | 85bd97fcfe | |
Josh Stone | 3adce78385 | |
Josh Stone | ec0342e9f1 | |
Josh Stone | 953087fe4e | |
Josh Stone | 98a3f17db6 | |
Isaac Carruthers | b29c13e54f | |
Alice Ryhl | ff8f106186 | |
Alice Ryhl | 555dab7d33 | |
Alice Ryhl | 2f6c0bf354 | |
Alice Ryhl | 8c3b2de11c | |
Alice Ryhl | 23085800e0 | |
Alice Ryhl | e85ab24567 | |
Alice Ryhl | 04117fafe9 | |
Alice Ryhl | 17030ea412 | |
Alice Ryhl | 8c47ca00c7 | |
Alice Ryhl | 03d717f26f | |
Isaac Carruthers | 263bd0ec44 | |
Isaac Carruthers | 42a6ae5353 | |
Nicolas Kirchner | bcd76c55e8 | |
Nicolas Kirchner | 243bc6fe4c | |
Nicolas Kirchner | b43c1ab258 | |
Nicolas Kirchner | c9c40b9402 | |
Nicolas Kirchner | d7554ad931 | |
Isaac Carruthers | 41d6a32dba | |
Isaac Carruthers | 2dcb722007 | |
Isaac Carruthers | 1b671ca43e | |
Nicolas Kirchner | 10127907f5 | |
bors[bot] | e7df30bac4 | |
Nicolas Kirchner | cbdaf8f6f9 | |
Nicolas Kirchner | 5106fcc95a | |
Nicolas Kirchner | 9b56d6667c | |
bors[bot] | 54fe41f305 | |
Martin Geisler | 97bc42854a | |
Martin Geisler | 8d64ff9708 | |
Josh Stone | 846ef39ba6 | |
bors[bot] | a8ebac5af1 | |
Josh Stone | ee6bbdb2f6 | |
Josh Stone | bd22a89a32 | |
Josh Stone | 79c7a4be5f | |
Alan Liddell | 16a180f132 | |
Alan Liddell | add0fbf0f0 | |
Alan Liddell | 38ee1304bb | |
Josh Stone | 23d1ab689d | |
Josh Stone | 4e9b426c30 | |
Josh Stone | fe55d1fb4e | |
Josh Stone | 59b8433a5e | |
Josh Stone | 11a23dd5d7 | |
Josh Stone | ea2158f3dd | |
Josh Stone | 63aa15ae9a | |
Josh Stone | ca433f74ab | |
Alan Liddell | 97e6d45d03 | |
Alan Liddell | 14d323f5a3 | |
Alan Liddell | ac746c2a5d | |
bors[bot] | d159ed63be | |
bors[bot] | a07eaab226 | |
Josh Stone | f06f5c548e | |
Josh Stone | d57c0c2879 | |
Josh Stone | 055c6693b1 | |
bluss | 686411f44e | |
bluss | 3ec194bafb | |
bors[bot] | ebc36b3e55 | |
Josh Stone | e5434dc659 | |
Josh Stone | 6afac825d9 | |
Josh Stone | 18a5bfcd0b | |
Josh Stone | 18cc1902fb | |
bors[bot] | 73a2dfd647 | |
bors[bot] | 26af99cf39 | |
Keith Wansbrough | ef83e851e7 | |
Keith Wansbrough | c87faf46a6 | |
Keith Wansbrough | eddcb54d6b | |
bors[bot] | bcccab17dd | |
bors[bot] | 36b492a191 | |
Alan Liddell | e5e8266009 | |
Alan Liddell | 506fbaf4e7 | |
Alan Liddell | 3c490cdee4 | |
Lee Bousfield | 426034ba09 | |
Josh Stone | 31fa9f626a | |
Josh Stone | b181cae401 | |
Josh Stone | 3299702e69 | |
Lee Bousfield | aaa4ab357f | |
Lee Bousfield | f0fa65a9d5 | |
Lee Bousfield | 5f3a3b0004 | |
Sam Cappleman-Lynes | 1fb03ca18a | |
Sam Cappleman-Lynes | 2a3cd41820 | |
Sam Cappleman-Lynes | fd87d87db3 | |
Josh Stone | 3f32ad48f4 | |
Sam Cappleman-Lynes | 99873d06e5 | |
Sam Cappleman-Lynes | 94d570697c | |
Sam Cappleman-Lynes | 9b0392d235 | |
Sam Cappleman-Lynes | 8b1288ea01 | |
Sam Cappleman-Lynes | 79448cbdf9 | |
Sam Cappleman-Lynes | 80feea2722 | |
Sam Cappleman-Lynes | 1e26bdde81 | |
Sam Cappleman-Lynes | d0bfb54eee | |
Sam Cappleman-Lynes | 51408a9b3b | |
Sam Cappleman-Lynes | 5738141b7c | |
Sam Cappleman-Lynes | fd2f516a5d | |
Sam Cappleman-Lynes | e5ed503141 | |
Sam Cappleman-Lynes | 784d26bbf8 | |
Sam Cappleman-Lynes | 530e2f6022 | |
Sam Cappleman-Lynes | 7b7799eab7 | |
Sam Cappleman-Lynes | a2a28c682e | |
Sam Cappleman-Lynes | e520bdad0d | |
Josh Stone | 8964c65f38 | |
Josh Stone | 8dd6890ddc | |
Eduardo Pinho | 15f9334955 | |
Eduardo Pinho | 61cfdc37b3 | |
Phaiax | 563e4dc509 | |
Eduardo Pinho | 1660590125 | |
Phaiax | 1ea02d8d0c | |
Phaiax | fc09503d3d | |
Phaiax | 1ab07df709 | |
Josh Stone | b1b034f438 | |
Josh Stone | d2defd67f2 | |
Josh Stone | 81e932b671 |
47
.travis.yml
47
.travis.yml
|
@ -1,19 +1,52 @@
|
||||||
language: rust
|
language: rust
|
||||||
|
sudo: false
|
||||||
rust:
|
rust:
|
||||||
- 1.8.0
|
- 1.8.0
|
||||||
- 1.15.0
|
- 1.15.0
|
||||||
|
- 1.20.0
|
||||||
|
- 1.26.0 # has_i128
|
||||||
|
- 1.31.0 # 2018!
|
||||||
|
- stable
|
||||||
- beta
|
- beta
|
||||||
- nightly
|
- nightly
|
||||||
sudo: false
|
|
||||||
script:
|
script:
|
||||||
- cargo build --verbose
|
- cargo build --verbose
|
||||||
- ./ci/test_full.sh
|
- ./ci/test_full.sh
|
||||||
- cargo doc
|
matrix:
|
||||||
after_success: |
|
include:
|
||||||
[ $TRAVIS_BRANCH = master ] &&
|
# i586 presents floating point challenges for lack of SSE/SSE2
|
||||||
[ $TRAVIS_PULL_REQUEST = false ] &&
|
- name: "i586"
|
||||||
[ $TRAVIS_RUST_VERSION = nightly ] &&
|
rust: stable
|
||||||
ssh-agent ./ci/deploy.sh
|
env: TARGET=i586-unknown-linux-gnu
|
||||||
|
addons:
|
||||||
|
apt:
|
||||||
|
packages:
|
||||||
|
- gcc-multilib
|
||||||
|
before_script:
|
||||||
|
- rustup target add $TARGET
|
||||||
|
script:
|
||||||
|
- cargo test --verbose --target $TARGET --all-features
|
||||||
|
# try a target that doesn't have std at all
|
||||||
|
- name: "no_std"
|
||||||
|
rust: stable
|
||||||
|
env: TARGET=thumbv6m-none-eabi
|
||||||
|
before_script:
|
||||||
|
- rustup target add $TARGET
|
||||||
|
script:
|
||||||
|
- cargo build --verbose --target $TARGET --no-default-features --features i128
|
||||||
|
- cargo build --verbose --target $TARGET --no-default-features --features libm
|
||||||
|
- name: "rustfmt"
|
||||||
|
rust: 1.31.0
|
||||||
|
before_script:
|
||||||
|
- rustup component add rustfmt
|
||||||
|
script:
|
||||||
|
- cargo fmt --all -- --check
|
||||||
notifications:
|
notifications:
|
||||||
email:
|
email:
|
||||||
on_success: never
|
on_success: never
|
||||||
|
branches:
|
||||||
|
only:
|
||||||
|
- master
|
||||||
|
- next
|
||||||
|
- staging
|
||||||
|
- trying
|
||||||
|
|
77
Cargo.toml
77
Cargo.toml
|
@ -1,69 +1,28 @@
|
||||||
[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"]
|
keywords = ["mathematics", "numerics"]
|
||||||
|
categories = ["algorithms", "science", "no-std"]
|
||||||
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.38"
|
version = "0.2.8"
|
||||||
|
readme = "README.md"
|
||||||
|
build = "build.rs"
|
||||||
|
exclude = ["/ci/*", "/.travis.yml", "/bors.toml"]
|
||||||
|
|
||||||
[[bench]]
|
[package.metadata.docs.rs]
|
||||||
name = "bigint"
|
features = ["std"]
|
||||||
|
|
||||||
[[bench]]
|
|
||||||
harness = false
|
|
||||||
name = "shootout-pidigits"
|
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
|
libm = { version = "0.1.4", optional = true }
|
||||||
[dependencies.num-bigint]
|
|
||||||
optional = true
|
|
||||||
path = "bigint"
|
|
||||||
version = "0.1.38"
|
|
||||||
|
|
||||||
[dependencies.num-complex]
|
|
||||||
optional = true
|
|
||||||
path = "complex"
|
|
||||||
version = "0.1.38"
|
|
||||||
|
|
||||||
[dependencies.num-integer]
|
|
||||||
path = "./integer"
|
|
||||||
version = "0.1.34"
|
|
||||||
|
|
||||||
[dependencies.num-iter]
|
|
||||||
optional = false
|
|
||||||
path = "iter"
|
|
||||||
version = "0.1.33"
|
|
||||||
|
|
||||||
[dependencies.num-rational]
|
|
||||||
optional = true
|
|
||||||
path = "rational"
|
|
||||||
version = "0.1.37"
|
|
||||||
|
|
||||||
[dependencies.num-traits]
|
|
||||||
path = "./traits"
|
|
||||||
version = "0.1.38"
|
|
||||||
|
|
||||||
[dev-dependencies]
|
|
||||||
|
|
||||||
[dev-dependencies.rand]
|
|
||||||
version = "0.3.8"
|
|
||||||
|
|
||||||
[features]
|
[features]
|
||||||
bigint = ["num-bigint"]
|
default = ["std"]
|
||||||
complex = ["num-complex"]
|
std = []
|
||||||
rational = ["num-rational"]
|
i128 = []
|
||||||
default = ["bigint", "complex", "rational", "rustc-serialize"]
|
|
||||||
|
|
||||||
serde = [
|
[build-dependencies]
|
||||||
"num-bigint/serde",
|
autocfg = "0.1.3"
|
||||||
"num-complex/serde",
|
|
||||||
"num-rational/serde"
|
|
||||||
]
|
|
||||||
rustc-serialize = [
|
|
||||||
"num-bigint/rustc-serialize",
|
|
||||||
"num-complex/rustc-serialize",
|
|
||||||
"num-rational/rustc-serialize"
|
|
||||||
]
|
|
||||||
|
|
48
README.md
48
README.md
|
@ -1,12 +1,11 @@
|
||||||
# num
|
# num-traits
|
||||||
|
|
||||||
A collection of numeric types and traits for Rust.
|
[![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)
|
||||||
|
![minimum rustc 1.8](https://img.shields.io/badge/rustc-1.8+-red.svg)
|
||||||
|
[![Travis status](https://travis-ci.org/rust-num/num-traits.svg?branch=master)](https://travis-ci.org/rust-num/num-traits)
|
||||||
|
|
||||||
This includes new types for big integers, rationals, and complex numbers,
|
Numeric traits for generic mathematics in Rust.
|
||||||
new traits for generic programming on numeric properties like `Integer`,
|
|
||||||
and generic range iterators.
|
|
||||||
|
|
||||||
[Documentation](http://rust-num.github.io/num)
|
|
||||||
|
|
||||||
## Usage
|
## Usage
|
||||||
|
|
||||||
|
@ -14,17 +13,42 @@ Add this to your `Cargo.toml`:
|
||||||
|
|
||||||
```toml
|
```toml
|
||||||
[dependencies]
|
[dependencies]
|
||||||
num = "0.1"
|
num-traits = "0.2"
|
||||||
```
|
```
|
||||||
|
|
||||||
and this to your crate root:
|
and this to your crate root:
|
||||||
|
|
||||||
```rust
|
```rust
|
||||||
extern crate num;
|
extern crate num_traits;
|
||||||
```
|
```
|
||||||
|
|
||||||
|
## Features
|
||||||
|
|
||||||
|
This crate can be used without the standard library (`#![no_std]`) by disabling
|
||||||
|
the default `std` feature. Use this in `Cargo.toml`:
|
||||||
|
|
||||||
|
```toml
|
||||||
|
[dependencies.num-traits]
|
||||||
|
version = "0.2"
|
||||||
|
default-features = false
|
||||||
|
# features = ["libm"] # <--- Uncomment if you wish to use `Float` and `Real` without `std`
|
||||||
|
```
|
||||||
|
|
||||||
|
The `Float` and `Real` traits are only available when either `std` or `libm` is enabled.
|
||||||
|
The `libm` feature is only available with Rust 1.31 and later ([see PR #99](https://github.com/rust-num/num-traits/pull/99)).
|
||||||
|
|
||||||
|
The `FloatCore` trait is always available. `MulAdd` and `MulAddAssign` for `f32`
|
||||||
|
and `f64` also require `std` or `libm`, as do implementations of signed and floating-
|
||||||
|
point exponents in `Pow`.
|
||||||
|
|
||||||
|
Implementations for `i128` and `u128` are only available with Rust 1.26 and
|
||||||
|
later. The build script automatically detects this, but you can make it
|
||||||
|
mandatory by enabling the `i128` crate feature.
|
||||||
|
|
||||||
|
## Releases
|
||||||
|
|
||||||
|
Release notes are available in [RELEASES.md](RELEASES.md).
|
||||||
|
|
||||||
## 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 exceptions are `num-derive` which requires at least rustc 1.15,
|
|
||||||
and the deprecated `num-macros` which requires nightly rustc.
|
|
||||||
|
|
|
@ -0,0 +1,154 @@
|
||||||
|
# Release 0.2.8 (2019-05-21)
|
||||||
|
|
||||||
|
- [Fixed feature detection on `no_std` targets][116].
|
||||||
|
|
||||||
|
**Contributors**: @cuviper
|
||||||
|
|
||||||
|
[116]: https://github.com/rust-num/num-traits/pull/116
|
||||||
|
|
||||||
|
# Release 0.2.7 (2019-05-20)
|
||||||
|
|
||||||
|
- [Documented when `CheckedShl` and `CheckedShr` return `None`][90].
|
||||||
|
- [The new `Zero::set_zero` and `One::set_one`][104] will set values to their
|
||||||
|
identities in place, possibly optimized better than direct assignment.
|
||||||
|
- [Documented general features and intentions of `PrimInt`][108].
|
||||||
|
|
||||||
|
**Contributors**: @cuviper, @dvdhrm, @ignatenkobrain, @lcnr, @samueltardieu
|
||||||
|
|
||||||
|
[90]: https://github.com/rust-num/num-traits/pull/90
|
||||||
|
[104]: https://github.com/rust-num/num-traits/pull/104
|
||||||
|
[108]: https://github.com/rust-num/num-traits/pull/108
|
||||||
|
|
||||||
|
# Release 0.2.6 (2018-09-13)
|
||||||
|
|
||||||
|
- [Documented that `pow(0, 0)` returns `1`][79]. Mathematically, this is not
|
||||||
|
strictly defined, but the current behavior is a pragmatic choice that has
|
||||||
|
precedent in Rust `core` for the primitives and in many other languages.
|
||||||
|
- [The new `WrappingShl` and `WrappingShr` traits][81] will wrap the shift count
|
||||||
|
if it exceeds the bit size of the type.
|
||||||
|
|
||||||
|
**Contributors**: @cuviper, @edmccard, @meltinglava
|
||||||
|
|
||||||
|
[79]: https://github.com/rust-num/num-traits/pull/79
|
||||||
|
[81]: https://github.com/rust-num/num-traits/pull/81
|
||||||
|
|
||||||
|
# Release 0.2.5 (2018-06-20)
|
||||||
|
|
||||||
|
- [Documentation for `mul_add` now clarifies that it's not always faster.][70]
|
||||||
|
- [The default methods in `FromPrimitive` and `ToPrimitive` are more robust.][73]
|
||||||
|
|
||||||
|
**Contributors**: @cuviper, @frewsxcv
|
||||||
|
|
||||||
|
[70]: https://github.com/rust-num/num-traits/pull/70
|
||||||
|
[73]: https://github.com/rust-num/num-traits/pull/73
|
||||||
|
|
||||||
|
# Release 0.2.4 (2018-05-11)
|
||||||
|
|
||||||
|
- [Support for 128-bit integers is now automatically detected and enabled.][69]
|
||||||
|
Setting the `i128` crate feature now causes the build script to panic if such
|
||||||
|
support is not detected.
|
||||||
|
|
||||||
|
**Contributors**: @cuviper
|
||||||
|
|
||||||
|
[69]: https://github.com/rust-num/num-traits/pull/69
|
||||||
|
|
||||||
|
# Release 0.2.3 (2018-05-10)
|
||||||
|
|
||||||
|
- [The new `CheckedNeg` and `CheckedRem` traits][63] perform checked `Neg` and
|
||||||
|
`Rem`, returning `Some(output)` or `None` on overflow.
|
||||||
|
- [The `no_std` implementation of `FloatCore::to_degrees` for `f32`][61] now
|
||||||
|
uses a constant for greater accuracy, mirroring [rust#47919]. (With `std` it
|
||||||
|
just calls the inherent `f32::to_degrees` in the standard library.)
|
||||||
|
- [The new `MulAdd` and `MulAddAssign` traits][59] perform a fused multiply-
|
||||||
|
add. For integer types this is just a convenience, but for floating point
|
||||||
|
types this produces a more accurate result than the separate operations.
|
||||||
|
- [All applicable traits are now implemented for 128-bit integers][60] starting
|
||||||
|
with Rust 1.26, enabled by the new `i128` crate feature. The `FromPrimitive`
|
||||||
|
and `ToPrimitive` traits now also have corresponding 128-bit methods, which
|
||||||
|
default to converting via 64-bit integers for compatibility.
|
||||||
|
|
||||||
|
**Contributors**: @cuviper, @LEXUGE, @regexident, @vks
|
||||||
|
|
||||||
|
[59]: https://github.com/rust-num/num-traits/pull/59
|
||||||
|
[60]: https://github.com/rust-num/num-traits/pull/60
|
||||||
|
[61]: https://github.com/rust-num/num-traits/pull/61
|
||||||
|
[63]: https://github.com/rust-num/num-traits/pull/63
|
||||||
|
[rust#47919]: https://github.com/rust-lang/rust/pull/47919
|
||||||
|
|
||||||
|
# Release 0.2.2 (2018-03-18)
|
||||||
|
|
||||||
|
- [Casting from floating point to integers now returns `None` on overflow][52],
|
||||||
|
avoiding [rustc's undefined behavior][rust-10184]. This applies to the `cast`
|
||||||
|
function and the traits `NumCast`, `FromPrimitive`, and `ToPrimitive`.
|
||||||
|
|
||||||
|
**Contributors**: @apopiak, @cuviper, @dbarella
|
||||||
|
|
||||||
|
[52]: https://github.com/rust-num/num-traits/pull/52
|
||||||
|
[rust-10184]: https://github.com/rust-lang/rust/issues/10184
|
||||||
|
|
||||||
|
|
||||||
|
# Release 0.2.1 (2018-03-01)
|
||||||
|
|
||||||
|
- [The new `FloatCore` trait][32] offers a subset of `Float` for `#![no_std]` use.
|
||||||
|
[This includes everything][41] except the transcendental functions and FMA.
|
||||||
|
- [The new `Inv` trait][37] returns the multiplicative inverse, or reciprocal.
|
||||||
|
- [The new `Pow` trait][37] performs exponentiation, much like the existing `pow`
|
||||||
|
function, but with generic exponent types.
|
||||||
|
- [The new `One::is_one` method][39] tests if a value equals 1. Implementers
|
||||||
|
should override this method if there's a more efficient way to check for 1,
|
||||||
|
rather than comparing with a temporary `one()`.
|
||||||
|
|
||||||
|
**Contributors**: @clarcharr, @cuviper, @vks
|
||||||
|
|
||||||
|
[32]: https://github.com/rust-num/num-traits/pull/32
|
||||||
|
[37]: https://github.com/rust-num/num-traits/pull/37
|
||||||
|
[39]: https://github.com/rust-num/num-traits/pull/39
|
||||||
|
[41]: https://github.com/rust-num/num-traits/pull/41
|
||||||
|
|
||||||
|
|
||||||
|
# Release 0.2.0 (2018-02-06)
|
||||||
|
|
||||||
|
- **breaking change**: [There is now a `std` feature][30], enabled by default, along
|
||||||
|
with the implication that building *without* this feature makes this a
|
||||||
|
`#![no_std]` crate.
|
||||||
|
- The `Float` and `Real` traits are only available when `std` is enabled.
|
||||||
|
- Otherwise, the API is unchanged, and num-traits 0.1.43 now re-exports its
|
||||||
|
items from num-traits 0.2 for compatibility (the [semver-trick]).
|
||||||
|
|
||||||
|
**Contributors**: @cuviper, @termoshtt, @vks
|
||||||
|
|
||||||
|
[semver-trick]: https://github.com/dtolnay/semver-trick
|
||||||
|
[30]: https://github.com/rust-num/num-traits/pull/30
|
||||||
|
|
||||||
|
|
||||||
|
# Release 0.1.43 (2018-02-06)
|
||||||
|
|
||||||
|
- All items are now [re-exported from num-traits 0.2][31] for compatibility.
|
||||||
|
|
||||||
|
[31]: https://github.com/rust-num/num-traits/pull/31
|
||||||
|
|
||||||
|
|
||||||
|
# Release 0.1.42 (2018-01-22)
|
||||||
|
|
||||||
|
- [num-traits now has its own source repository][num-356] at [rust-num/num-traits][home].
|
||||||
|
- [`ParseFloatError` now implements `Display`][22].
|
||||||
|
- [The new `AsPrimitive` trait][17] implements generic casting with the `as` operator.
|
||||||
|
- [The new `CheckedShl` and `CheckedShr` traits][21] implement generic
|
||||||
|
support for the `checked_shl` and `checked_shr` methods on primitive integers.
|
||||||
|
- [The new `Real` trait][23] offers a subset of `Float` functionality that may be applicable to more
|
||||||
|
types, with a blanket implementation for all existing `T: Float` types.
|
||||||
|
|
||||||
|
Thanks to @cuviper, @Enet4, @fabianschuiki, @svartalf, and @yoanlcq for their contributions!
|
||||||
|
|
||||||
|
[home]: https://github.com/rust-num/num-traits
|
||||||
|
[num-356]: https://github.com/rust-num/num/pull/356
|
||||||
|
[17]: https://github.com/rust-num/num-traits/pull/17
|
||||||
|
[21]: https://github.com/rust-num/num-traits/pull/21
|
||||||
|
[22]: https://github.com/rust-num/num-traits/pull/22
|
||||||
|
[23]: https://github.com/rust-num/num-traits/pull/23
|
||||||
|
|
||||||
|
|
||||||
|
# Prior releases
|
||||||
|
|
||||||
|
No prior release notes were kept. Thanks all the same to the many
|
||||||
|
contributors that have made this crate what it is!
|
|
@ -1,252 +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};
|
|
||||||
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 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);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
|
@ -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,38 +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"]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
name = "num-bigint"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
version = "0.1.38"
|
|
||||||
|
|
||||||
[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,586 +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::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
|
|
||||||
}
|
|
||||||
|
|
||||||
/// 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.normalize(), rem)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Only for the Add impl:
|
|
||||||
#[must_use]
|
|
||||||
#[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
|
|
||||||
fn mac_digit(acc: &mut [BigDigit], b: &[BigDigit], c: BigDigit) {
|
|
||||||
if c == 0 {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
let mut b_iter = b.iter();
|
|
||||||
let mut carry = 0;
|
|
||||||
|
|
||||||
for ai in acc.iter_mut() {
|
|
||||||
if let Some(bi) = b_iter.next() {
|
|
||||||
*ai = mac_with_carry(*ai, *bi, c, &mut carry);
|
|
||||||
} else if carry != 0 {
|
|
||||||
*ai = mac_with_carry(*ai, 0, c, &mut carry);
|
|
||||||
} else {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
assert!(carry == 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// 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)
|
|
||||||
};
|
|
||||||
|
|
||||||
// Karatsuba multiplication is slower than long multiplication for small x and y:
|
|
||||||
//
|
|
||||||
if x.len() <= 4 {
|
|
||||||
for (i, xi) in x.iter().enumerate() {
|
|
||||||
mac_digit(&mut acc[i..], y, *xi);
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/*
|
|
||||||
* 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 = 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 = 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 = p.normalize();
|
|
||||||
|
|
||||||
sub2(&mut acc[b..], &p.data[..]);
|
|
||||||
},
|
|
||||||
Minus => {
|
|
||||||
mac3(&mut acc[b..], &j0.data[..], &j1.data[..]);
|
|
||||||
},
|
|
||||||
NoSign => (),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
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.normalize()
|
|
||||||
}
|
|
||||||
|
|
||||||
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 = a.normalize();
|
|
||||||
|
|
||||||
tmp = q0;
|
|
||||||
}
|
|
||||||
|
|
||||||
debug_assert!(a < b);
|
|
||||||
|
|
||||||
(q.normalize(), 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);
|
|
||||||
}
|
|
||||||
}
|
|
1107
bigint/src/bigint.rs
1107
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,144 +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;
|
|
||||||
|
|
||||||
#[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,133 +0,0 @@
|
||||||
|
|
||||||
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)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// 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);
|
|
||||||
};
|
|
||||||
}
|
|
|
@ -1,954 +0,0 @@
|
||||||
use {BigDigit, BigUint, big_digit};
|
|
||||||
use {Sign, BigInt, RandBigInt, ToBigInt};
|
|
||||||
use Sign::{Minus, NoSign, Plus};
|
|
||||||
|
|
||||||
use std::cmp::Ordering::{Less, Equal, Greater};
|
|
||||||
use std::{f32, f64};
|
|
||||||
use std::{i8, i16, i32, i64, isize};
|
|
||||||
use std::iter::repeat;
|
|
||||||
use std::{u8, u16, u32, u64, usize};
|
|
||||||
use std::ops::Neg;
|
|
||||||
|
|
||||||
use rand::thread_rng;
|
|
||||||
|
|
||||||
use integer::Integer;
|
|
||||||
use traits::{Zero, One, Signed, ToPrimitive, FromPrimitive, Num, Float};
|
|
||||||
|
|
||||||
/// Assert that an op works for all val/ref combinations
|
|
||||||
macro_rules! assert_op {
|
|
||||||
($left:ident $op:tt $right:ident == $expected:expr) => {
|
|
||||||
assert_eq!((&$left) $op (&$right), $expected);
|
|
||||||
assert_eq!((&$left) $op $right.clone(), $expected);
|
|
||||||
assert_eq!($left.clone() $op (&$right), $expected);
|
|
||||||
assert_eq!($left.clone() $op $right.clone(), $expected);
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_from_biguint() {
|
|
||||||
fn check(inp_s: Sign, inp_n: usize, ans_s: Sign, ans_n: usize) {
|
|
||||||
let inp = BigInt::from_biguint(inp_s, FromPrimitive::from_usize(inp_n).unwrap());
|
|
||||||
let ans = BigInt {
|
|
||||||
sign: ans_s,
|
|
||||||
data: FromPrimitive::from_usize(ans_n).unwrap(),
|
|
||||||
};
|
|
||||||
assert_eq!(inp, ans);
|
|
||||||
}
|
|
||||||
check(Plus, 1, Plus, 1);
|
|
||||||
check(Plus, 0, NoSign, 0);
|
|
||||||
check(Minus, 1, Minus, 1);
|
|
||||||
check(NoSign, 1, NoSign, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_from_bytes_be() {
|
|
||||||
fn check(s: &str, result: &str) {
|
|
||||||
assert_eq!(BigInt::from_bytes_be(Plus, s.as_bytes()),
|
|
||||||
BigInt::parse_bytes(result.as_bytes(), 10).unwrap());
|
|
||||||
}
|
|
||||||
check("A", "65");
|
|
||||||
check("AA", "16705");
|
|
||||||
check("AB", "16706");
|
|
||||||
check("Hello world!", "22405534230753963835153736737");
|
|
||||||
assert_eq!(BigInt::from_bytes_be(Plus, &[]), Zero::zero());
|
|
||||||
assert_eq!(BigInt::from_bytes_be(Minus, &[]), Zero::zero());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_to_bytes_be() {
|
|
||||||
fn check(s: &str, result: &str) {
|
|
||||||
let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap();
|
|
||||||
let (sign, v) = b.to_bytes_be();
|
|
||||||
assert_eq!((Plus, s.as_bytes()), (sign, &*v));
|
|
||||||
}
|
|
||||||
check("A", "65");
|
|
||||||
check("AA", "16705");
|
|
||||||
check("AB", "16706");
|
|
||||||
check("Hello world!", "22405534230753963835153736737");
|
|
||||||
let b: BigInt = Zero::zero();
|
|
||||||
assert_eq!(b.to_bytes_be(), (NoSign, vec![0]));
|
|
||||||
|
|
||||||
// Test with leading/trailing zero bytes and a full BigDigit of value 0
|
|
||||||
let b = BigInt::from_str_radix("00010000000000000200", 16).unwrap();
|
|
||||||
assert_eq!(b.to_bytes_be(), (Plus, vec![1, 0, 0, 0, 0, 0, 0, 2, 0]));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_from_bytes_le() {
|
|
||||||
fn check(s: &str, result: &str) {
|
|
||||||
assert_eq!(BigInt::from_bytes_le(Plus, s.as_bytes()),
|
|
||||||
BigInt::parse_bytes(result.as_bytes(), 10).unwrap());
|
|
||||||
}
|
|
||||||
check("A", "65");
|
|
||||||
check("AA", "16705");
|
|
||||||
check("BA", "16706");
|
|
||||||
check("!dlrow olleH", "22405534230753963835153736737");
|
|
||||||
assert_eq!(BigInt::from_bytes_le(Plus, &[]), Zero::zero());
|
|
||||||
assert_eq!(BigInt::from_bytes_le(Minus, &[]), Zero::zero());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_to_bytes_le() {
|
|
||||||
fn check(s: &str, result: &str) {
|
|
||||||
let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap();
|
|
||||||
let (sign, v) = b.to_bytes_le();
|
|
||||||
assert_eq!((Plus, s.as_bytes()), (sign, &*v));
|
|
||||||
}
|
|
||||||
check("A", "65");
|
|
||||||
check("AA", "16705");
|
|
||||||
check("BA", "16706");
|
|
||||||
check("!dlrow olleH", "22405534230753963835153736737");
|
|
||||||
let b: BigInt = Zero::zero();
|
|
||||||
assert_eq!(b.to_bytes_le(), (NoSign, vec![0]));
|
|
||||||
|
|
||||||
// Test with leading/trailing zero bytes and a full BigDigit of value 0
|
|
||||||
let b = BigInt::from_str_radix("00010000000000000200", 16).unwrap();
|
|
||||||
assert_eq!(b.to_bytes_le(), (Plus, vec![0, 2, 0, 0, 0, 0, 0, 0, 1]));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_cmp() {
|
|
||||||
let vs: [&[BigDigit]; 4] = [&[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1]];
|
|
||||||
let mut nums = Vec::new();
|
|
||||||
for s in vs.iter().rev() {
|
|
||||||
nums.push(BigInt::from_slice(Minus, *s));
|
|
||||||
}
|
|
||||||
nums.push(Zero::zero());
|
|
||||||
nums.extend(vs.iter().map(|s| BigInt::from_slice(Plus, *s)));
|
|
||||||
|
|
||||||
for (i, ni) in nums.iter().enumerate() {
|
|
||||||
for (j0, nj) in nums[i..].iter().enumerate() {
|
|
||||||
let j = i + j0;
|
|
||||||
if i == j {
|
|
||||||
assert_eq!(ni.cmp(nj), Equal);
|
|
||||||
assert_eq!(nj.cmp(ni), Equal);
|
|
||||||
assert_eq!(ni, nj);
|
|
||||||
assert!(!(ni != nj));
|
|
||||||
assert!(ni <= nj);
|
|
||||||
assert!(ni >= nj);
|
|
||||||
assert!(!(ni < nj));
|
|
||||||
assert!(!(ni > nj));
|
|
||||||
} else {
|
|
||||||
assert_eq!(ni.cmp(nj), Less);
|
|
||||||
assert_eq!(nj.cmp(ni), Greater);
|
|
||||||
|
|
||||||
assert!(!(ni == nj));
|
|
||||||
assert!(ni != nj);
|
|
||||||
|
|
||||||
assert!(ni <= nj);
|
|
||||||
assert!(!(ni >= nj));
|
|
||||||
assert!(ni < nj);
|
|
||||||
assert!(!(ni > nj));
|
|
||||||
|
|
||||||
assert!(!(nj <= ni));
|
|
||||||
assert!(nj >= ni);
|
|
||||||
assert!(!(nj < ni));
|
|
||||||
assert!(nj > ni);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_hash() {
|
|
||||||
use hash;
|
|
||||||
|
|
||||||
let a = BigInt::new(NoSign, vec![]);
|
|
||||||
let b = BigInt::new(NoSign, vec![0]);
|
|
||||||
let c = BigInt::new(Plus, vec![1]);
|
|
||||||
let d = BigInt::new(Plus, vec![1, 0, 0, 0, 0, 0]);
|
|
||||||
let e = BigInt::new(Plus, vec![0, 0, 0, 0, 0, 1]);
|
|
||||||
let f = BigInt::new(Minus, vec![1]);
|
|
||||||
assert!(hash(&a) == hash(&b));
|
|
||||||
assert!(hash(&b) != hash(&c));
|
|
||||||
assert!(hash(&c) == hash(&d));
|
|
||||||
assert!(hash(&d) != hash(&e));
|
|
||||||
assert!(hash(&c) != hash(&f));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_convert_i64() {
|
|
||||||
fn check(b1: BigInt, i: i64) {
|
|
||||||
let b2: BigInt = FromPrimitive::from_i64(i).unwrap();
|
|
||||||
assert!(b1 == b2);
|
|
||||||
assert!(b1.to_i64().unwrap() == i);
|
|
||||||
}
|
|
||||||
|
|
||||||
check(Zero::zero(), 0);
|
|
||||||
check(One::one(), 1);
|
|
||||||
check(i64::MIN.to_bigint().unwrap(), i64::MIN);
|
|
||||||
check(i64::MAX.to_bigint().unwrap(), i64::MAX);
|
|
||||||
|
|
||||||
assert_eq!((i64::MAX as u64 + 1).to_bigint().unwrap().to_i64(), None);
|
|
||||||
|
|
||||||
assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(),
|
|
||||||
None);
|
|
||||||
|
|
||||||
assert_eq!(BigInt::from_biguint(Minus,
|
|
||||||
BigUint::new(vec![1, 0, 0, 1 << (big_digit::BITS - 1)]))
|
|
||||||
.to_i64(),
|
|
||||||
None);
|
|
||||||
|
|
||||||
assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(),
|
|
||||||
None);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_convert_u64() {
|
|
||||||
fn check(b1: BigInt, u: u64) {
|
|
||||||
let b2: BigInt = FromPrimitive::from_u64(u).unwrap();
|
|
||||||
assert!(b1 == b2);
|
|
||||||
assert!(b1.to_u64().unwrap() == u);
|
|
||||||
}
|
|
||||||
|
|
||||||
check(Zero::zero(), 0);
|
|
||||||
check(One::one(), 1);
|
|
||||||
check(u64::MIN.to_bigint().unwrap(), u64::MIN);
|
|
||||||
check(u64::MAX.to_bigint().unwrap(), u64::MAX);
|
|
||||||
|
|
||||||
assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(),
|
|
||||||
None);
|
|
||||||
|
|
||||||
let max_value: BigUint = FromPrimitive::from_u64(u64::MAX).unwrap();
|
|
||||||
assert_eq!(BigInt::from_biguint(Minus, max_value).to_u64(), None);
|
|
||||||
assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(),
|
|
||||||
None);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_convert_f32() {
|
|
||||||
fn check(b1: &BigInt, f: f32) {
|
|
||||||
let b2 = BigInt::from_f32(f).unwrap();
|
|
||||||
assert_eq!(b1, &b2);
|
|
||||||
assert_eq!(b1.to_f32().unwrap(), f);
|
|
||||||
let neg_b1 = -b1;
|
|
||||||
let neg_b2 = BigInt::from_f32(-f).unwrap();
|
|
||||||
assert_eq!(neg_b1, neg_b2);
|
|
||||||
assert_eq!(neg_b1.to_f32().unwrap(), -f);
|
|
||||||
}
|
|
||||||
|
|
||||||
check(&BigInt::zero(), 0.0);
|
|
||||||
check(&BigInt::one(), 1.0);
|
|
||||||
check(&BigInt::from(u16::MAX), 2.0.powi(16) - 1.0);
|
|
||||||
check(&BigInt::from(1u64 << 32), 2.0.powi(32));
|
|
||||||
check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64));
|
|
||||||
check(&((BigInt::one() << 100) + (BigInt::one() << 123)),
|
|
||||||
2.0.powi(100) + 2.0.powi(123));
|
|
||||||
check(&(BigInt::one() << 127), 2.0.powi(127));
|
|
||||||
check(&(BigInt::from((1u64 << 24) - 1) << (128 - 24)), f32::MAX);
|
|
||||||
|
|
||||||
// keeping all 24 digits with the bits at different offsets to the BigDigits
|
|
||||||
let x: u32 = 0b00000000101111011111011011011101;
|
|
||||||
let mut f = x as f32;
|
|
||||||
let mut b = BigInt::from(x);
|
|
||||||
for _ in 0..64 {
|
|
||||||
check(&b, f);
|
|
||||||
f *= 2.0;
|
|
||||||
b = b << 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// this number when rounded to f64 then f32 isn't the same as when rounded straight to f32
|
|
||||||
let mut n: i64 = 0b0000000000111111111111111111111111011111111111111111111111111111;
|
|
||||||
assert!((n as f64) as f32 != n as f32);
|
|
||||||
assert_eq!(BigInt::from(n).to_f32(), Some(n as f32));
|
|
||||||
n = -n;
|
|
||||||
assert!((n as f64) as f32 != n as f32);
|
|
||||||
assert_eq!(BigInt::from(n).to_f32(), Some(n as f32));
|
|
||||||
|
|
||||||
// test rounding up with the bits at different offsets to the BigDigits
|
|
||||||
let mut f = ((1u64 << 25) - 1) as f32;
|
|
||||||
let mut b = BigInt::from(1u64 << 25);
|
|
||||||
for _ in 0..64 {
|
|
||||||
assert_eq!(b.to_f32(), Some(f));
|
|
||||||
f *= 2.0;
|
|
||||||
b = b << 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// rounding
|
|
||||||
assert_eq!(BigInt::from_f32(-f32::consts::PI),
|
|
||||||
Some(BigInt::from(-3i32)));
|
|
||||||
assert_eq!(BigInt::from_f32(-f32::consts::E), Some(BigInt::from(-2i32)));
|
|
||||||
assert_eq!(BigInt::from_f32(-0.99999), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f32(-0.5), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f32(-0.0), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE / 2.0),
|
|
||||||
Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f32(0.5), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f32(0.99999), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f32(f32::consts::E), Some(BigInt::from(2u32)));
|
|
||||||
assert_eq!(BigInt::from_f32(f32::consts::PI), Some(BigInt::from(3u32)));
|
|
||||||
|
|
||||||
// special float values
|
|
||||||
assert_eq!(BigInt::from_f32(f32::NAN), None);
|
|
||||||
assert_eq!(BigInt::from_f32(f32::INFINITY), None);
|
|
||||||
assert_eq!(BigInt::from_f32(f32::NEG_INFINITY), None);
|
|
||||||
|
|
||||||
// largest BigInt that will round to a finite f32 value
|
|
||||||
let big_num = (BigInt::one() << 128) - BigInt::one() - (BigInt::one() << (128 - 25));
|
|
||||||
assert_eq!(big_num.to_f32(), Some(f32::MAX));
|
|
||||||
assert_eq!((&big_num + BigInt::one()).to_f32(), None);
|
|
||||||
assert_eq!((-&big_num).to_f32(), Some(f32::MIN));
|
|
||||||
assert_eq!(((-&big_num) - BigInt::one()).to_f32(), None);
|
|
||||||
|
|
||||||
assert_eq!(((BigInt::one() << 128) - BigInt::one()).to_f32(), None);
|
|
||||||
assert_eq!((BigInt::one() << 128).to_f32(), None);
|
|
||||||
assert_eq!((-((BigInt::one() << 128) - BigInt::one())).to_f32(), None);
|
|
||||||
assert_eq!((-(BigInt::one() << 128)).to_f32(), None);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_convert_f64() {
|
|
||||||
fn check(b1: &BigInt, f: f64) {
|
|
||||||
let b2 = BigInt::from_f64(f).unwrap();
|
|
||||||
assert_eq!(b1, &b2);
|
|
||||||
assert_eq!(b1.to_f64().unwrap(), f);
|
|
||||||
let neg_b1 = -b1;
|
|
||||||
let neg_b2 = BigInt::from_f64(-f).unwrap();
|
|
||||||
assert_eq!(neg_b1, neg_b2);
|
|
||||||
assert_eq!(neg_b1.to_f64().unwrap(), -f);
|
|
||||||
}
|
|
||||||
|
|
||||||
check(&BigInt::zero(), 0.0);
|
|
||||||
check(&BigInt::one(), 1.0);
|
|
||||||
check(&BigInt::from(u32::MAX), 2.0.powi(32) - 1.0);
|
|
||||||
check(&BigInt::from(1u64 << 32), 2.0.powi(32));
|
|
||||||
check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64));
|
|
||||||
check(&((BigInt::one() << 100) + (BigInt::one() << 152)),
|
|
||||||
2.0.powi(100) + 2.0.powi(152));
|
|
||||||
check(&(BigInt::one() << 1023), 2.0.powi(1023));
|
|
||||||
check(&(BigInt::from((1u64 << 53) - 1) << (1024 - 53)), f64::MAX);
|
|
||||||
|
|
||||||
// keeping all 53 digits with the bits at different offsets to the BigDigits
|
|
||||||
let x: u64 = 0b0000000000011110111110110111111101110111101111011111011011011101;
|
|
||||||
let mut f = x as f64;
|
|
||||||
let mut b = BigInt::from(x);
|
|
||||||
for _ in 0..128 {
|
|
||||||
check(&b, f);
|
|
||||||
f *= 2.0;
|
|
||||||
b = b << 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// test rounding up with the bits at different offsets to the BigDigits
|
|
||||||
let mut f = ((1u64 << 54) - 1) as f64;
|
|
||||||
let mut b = BigInt::from(1u64 << 54);
|
|
||||||
for _ in 0..128 {
|
|
||||||
assert_eq!(b.to_f64(), Some(f));
|
|
||||||
f *= 2.0;
|
|
||||||
b = b << 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// rounding
|
|
||||||
assert_eq!(BigInt::from_f64(-f64::consts::PI),
|
|
||||||
Some(BigInt::from(-3i32)));
|
|
||||||
assert_eq!(BigInt::from_f64(-f64::consts::E), Some(BigInt::from(-2i32)));
|
|
||||||
assert_eq!(BigInt::from_f64(-0.99999), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f64(-0.5), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f64(-0.0), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE / 2.0),
|
|
||||||
Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f64(0.5), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f64(0.99999), Some(BigInt::zero()));
|
|
||||||
assert_eq!(BigInt::from_f64(f64::consts::E), Some(BigInt::from(2u32)));
|
|
||||||
assert_eq!(BigInt::from_f64(f64::consts::PI), Some(BigInt::from(3u32)));
|
|
||||||
|
|
||||||
// special float values
|
|
||||||
assert_eq!(BigInt::from_f64(f64::NAN), None);
|
|
||||||
assert_eq!(BigInt::from_f64(f64::INFINITY), None);
|
|
||||||
assert_eq!(BigInt::from_f64(f64::NEG_INFINITY), None);
|
|
||||||
|
|
||||||
// largest BigInt that will round to a finite f64 value
|
|
||||||
let big_num = (BigInt::one() << 1024) - BigInt::one() - (BigInt::one() << (1024 - 54));
|
|
||||||
assert_eq!(big_num.to_f64(), Some(f64::MAX));
|
|
||||||
assert_eq!((&big_num + BigInt::one()).to_f64(), None);
|
|
||||||
assert_eq!((-&big_num).to_f64(), Some(f64::MIN));
|
|
||||||
assert_eq!(((-&big_num) - BigInt::one()).to_f64(), None);
|
|
||||||
|
|
||||||
assert_eq!(((BigInt::one() << 1024) - BigInt::one()).to_f64(), None);
|
|
||||||
assert_eq!((BigInt::one() << 1024).to_f64(), None);
|
|
||||||
assert_eq!((-((BigInt::one() << 1024) - BigInt::one())).to_f64(), None);
|
|
||||||
assert_eq!((-(BigInt::one() << 1024)).to_f64(), None);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_convert_to_biguint() {
|
|
||||||
fn check(n: BigInt, ans_1: BigUint) {
|
|
||||||
assert_eq!(n.to_biguint().unwrap(), ans_1);
|
|
||||||
assert_eq!(n.to_biguint().unwrap().to_bigint().unwrap(), n);
|
|
||||||
}
|
|
||||||
let zero: BigInt = Zero::zero();
|
|
||||||
let unsigned_zero: BigUint = Zero::zero();
|
|
||||||
let positive = BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3]));
|
|
||||||
let negative = -&positive;
|
|
||||||
|
|
||||||
check(zero, unsigned_zero);
|
|
||||||
check(positive, BigUint::new(vec![1, 2, 3]));
|
|
||||||
|
|
||||||
assert_eq!(negative.to_biguint(), None);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_convert_from_uint() {
|
|
||||||
macro_rules! check {
|
|
||||||
($ty:ident, $max:expr) => {
|
|
||||||
assert_eq!(BigInt::from($ty::zero()), BigInt::zero());
|
|
||||||
assert_eq!(BigInt::from($ty::one()), BigInt::one());
|
|
||||||
assert_eq!(BigInt::from($ty::MAX - $ty::one()), $max - BigInt::one());
|
|
||||||
assert_eq!(BigInt::from($ty::MAX), $max);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
check!(u8, BigInt::from_slice(Plus, &[u8::MAX as BigDigit]));
|
|
||||||
check!(u16, BigInt::from_slice(Plus, &[u16::MAX as BigDigit]));
|
|
||||||
check!(u32, BigInt::from_slice(Plus, &[u32::MAX as BigDigit]));
|
|
||||||
check!(u64,
|
|
||||||
BigInt::from_slice(Plus, &[u32::MAX as BigDigit, u32::MAX as BigDigit]));
|
|
||||||
check!(usize, BigInt::from(usize::MAX as u64));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_convert_from_int() {
|
|
||||||
macro_rules! check {
|
|
||||||
($ty:ident, $min:expr, $max:expr) => {
|
|
||||||
assert_eq!(BigInt::from($ty::MIN), $min);
|
|
||||||
assert_eq!(BigInt::from($ty::MIN + $ty::one()), $min + BigInt::one());
|
|
||||||
assert_eq!(BigInt::from(-$ty::one()), -BigInt::one());
|
|
||||||
assert_eq!(BigInt::from($ty::zero()), BigInt::zero());
|
|
||||||
assert_eq!(BigInt::from($ty::one()), BigInt::one());
|
|
||||||
assert_eq!(BigInt::from($ty::MAX - $ty::one()), $max - BigInt::one());
|
|
||||||
assert_eq!(BigInt::from($ty::MAX), $max);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
check!(i8,
|
|
||||||
BigInt::from_slice(Minus, &[1 << 7]),
|
|
||||||
BigInt::from_slice(Plus, &[i8::MAX as BigDigit]));
|
|
||||||
check!(i16,
|
|
||||||
BigInt::from_slice(Minus, &[1 << 15]),
|
|
||||||
BigInt::from_slice(Plus, &[i16::MAX as BigDigit]));
|
|
||||||
check!(i32,
|
|
||||||
BigInt::from_slice(Minus, &[1 << 31]),
|
|
||||||
BigInt::from_slice(Plus, &[i32::MAX as BigDigit]));
|
|
||||||
check!(i64,
|
|
||||||
BigInt::from_slice(Minus, &[0, 1 << 31]),
|
|
||||||
BigInt::from_slice(Plus, &[u32::MAX as BigDigit, i32::MAX as BigDigit]));
|
|
||||||
check!(isize,
|
|
||||||
BigInt::from(isize::MIN as i64),
|
|
||||||
BigInt::from(isize::MAX as i64));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_convert_from_biguint() {
|
|
||||||
assert_eq!(BigInt::from(BigUint::zero()), BigInt::zero());
|
|
||||||
assert_eq!(BigInt::from(BigUint::one()), BigInt::one());
|
|
||||||
assert_eq!(BigInt::from(BigUint::from_slice(&[1, 2, 3])),
|
|
||||||
BigInt::from_slice(Plus, &[1, 2, 3]));
|
|
||||||
}
|
|
||||||
|
|
||||||
const N1: BigDigit = -1i32 as BigDigit;
|
|
||||||
const N2: BigDigit = -2i32 as BigDigit;
|
|
||||||
|
|
||||||
const SUM_TRIPLES: &'static [(&'static [BigDigit],
|
|
||||||
&'static [BigDigit],
|
|
||||||
&'static [BigDigit])] = &[(&[], &[], &[]),
|
|
||||||
(&[], &[1], &[1]),
|
|
||||||
(&[1], &[1], &[2]),
|
|
||||||
(&[1], &[1, 1], &[2, 1]),
|
|
||||||
(&[1], &[N1], &[0, 1]),
|
|
||||||
(&[1], &[N1, N1], &[0, 0, 1]),
|
|
||||||
(&[N1, N1], &[N1, N1], &[N2, N1, 1]),
|
|
||||||
(&[1, 1, 1], &[N1, N1], &[0, 1, 2]),
|
|
||||||
(&[2, 2, 1], &[N1, N2], &[1, 1, 2])];
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_add() {
|
|
||||||
for elm in SUM_TRIPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
let (na, nb, nc) = (-&a, -&b, -&c);
|
|
||||||
|
|
||||||
assert_op!(a + b == c);
|
|
||||||
assert_op!(b + a == c);
|
|
||||||
assert_op!(c + na == b);
|
|
||||||
assert_op!(c + nb == a);
|
|
||||||
assert_op!(a + nc == nb);
|
|
||||||
assert_op!(b + nc == na);
|
|
||||||
assert_op!(na + nb == nc);
|
|
||||||
assert_op!(a + na == Zero::zero());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_sub() {
|
|
||||||
for elm in SUM_TRIPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
let (na, nb, nc) = (-&a, -&b, -&c);
|
|
||||||
|
|
||||||
assert_op!(c - a == b);
|
|
||||||
assert_op!(c - b == a);
|
|
||||||
assert_op!(nb - a == nc);
|
|
||||||
assert_op!(na - b == nc);
|
|
||||||
assert_op!(b - na == c);
|
|
||||||
assert_op!(a - nb == c);
|
|
||||||
assert_op!(nc - na == nb);
|
|
||||||
assert_op!(a - a == Zero::zero());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const M: u32 = ::std::u32::MAX;
|
|
||||||
static MUL_TRIPLES: &'static [(&'static [BigDigit],
|
|
||||||
&'static [BigDigit],
|
|
||||||
&'static [BigDigit])] = &[(&[], &[], &[]),
|
|
||||||
(&[], &[1], &[]),
|
|
||||||
(&[2], &[], &[]),
|
|
||||||
(&[1], &[1], &[1]),
|
|
||||||
(&[2], &[3], &[6]),
|
|
||||||
(&[1], &[1, 1, 1], &[1, 1, 1]),
|
|
||||||
(&[1, 2, 3], &[3], &[3, 6, 9]),
|
|
||||||
(&[1, 1, 1], &[N1], &[N1, N1, N1]),
|
|
||||||
(&[1, 2, 3], &[N1], &[N1, N2, N2, 2]),
|
|
||||||
(&[1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]),
|
|
||||||
(&[N1], &[N1], &[1, N2]),
|
|
||||||
(&[N1, N1], &[N1], &[1, N1, N2]),
|
|
||||||
(&[N1, N1, N1], &[N1], &[1, N1, N1, N2]),
|
|
||||||
(&[N1, N1, N1, N1], &[N1], &[1, N1, N1, N1, N2]),
|
|
||||||
(&[M / 2 + 1], &[2], &[0, 1]),
|
|
||||||
(&[0, M / 2 + 1], &[2], &[0, 0, 1]),
|
|
||||||
(&[1, 2], &[1, 2, 3], &[1, 4, 7, 6]),
|
|
||||||
(&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]),
|
|
||||||
(&[N1, N1, N1],
|
|
||||||
&[N1, N1, N1, N1],
|
|
||||||
&[1, 0, 0, N1, N2, N1, N1]),
|
|
||||||
(&[0, 0, 1], &[1, 2, 3], &[0, 0, 1, 2, 3]),
|
|
||||||
(&[0, 0, 1], &[0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])];
|
|
||||||
|
|
||||||
static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit],
|
|
||||||
&'static [BigDigit],
|
|
||||||
&'static [BigDigit],
|
|
||||||
&'static [BigDigit])] = &[(&[1], &[2], &[], &[1]),
|
|
||||||
(&[1, 1], &[2], &[M / 2 + 1], &[1]),
|
|
||||||
(&[1, 1, 1], &[2], &[M / 2 + 1, M / 2 + 1], &[1]),
|
|
||||||
(&[0, 1], &[N1], &[1], &[1]),
|
|
||||||
(&[N1, N1], &[N2], &[2, 1], &[3])];
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_mul() {
|
|
||||||
for elm in MUL_TRIPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
let (na, nb, nc) = (-&a, -&b, -&c);
|
|
||||||
|
|
||||||
assert_op!(a * b == c);
|
|
||||||
assert_op!(b * a == c);
|
|
||||||
assert_op!(na * nb == c);
|
|
||||||
|
|
||||||
assert_op!(na * b == nc);
|
|
||||||
assert_op!(nb * a == nc);
|
|
||||||
}
|
|
||||||
|
|
||||||
for elm in DIV_REM_QUADRUPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec, d_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
let d = BigInt::from_slice(Plus, d_vec);
|
|
||||||
|
|
||||||
assert!(a == &b * &c + &d);
|
|
||||||
assert!(a == &c * &b + &d);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_div_mod_floor() {
|
|
||||||
fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt, ans_m: &BigInt) {
|
|
||||||
let (d, m) = a.div_mod_floor(b);
|
|
||||||
if !m.is_zero() {
|
|
||||||
assert_eq!(m.sign, b.sign);
|
|
||||||
}
|
|
||||||
assert!(m.abs() <= b.abs());
|
|
||||||
assert!(*a == b * &d + &m);
|
|
||||||
assert!(d == *ans_d);
|
|
||||||
assert!(m == *ans_m);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) {
|
|
||||||
if m.is_zero() {
|
|
||||||
check_sub(a, b, d, m);
|
|
||||||
check_sub(a, &b.neg(), &d.neg(), m);
|
|
||||||
check_sub(&a.neg(), b, &d.neg(), m);
|
|
||||||
check_sub(&a.neg(), &b.neg(), d, m);
|
|
||||||
} else {
|
|
||||||
let one: BigInt = One::one();
|
|
||||||
check_sub(a, b, d, m);
|
|
||||||
check_sub(a, &b.neg(), &(d.neg() - &one), &(m - b));
|
|
||||||
check_sub(&a.neg(), b, &(d.neg() - &one), &(b - m));
|
|
||||||
check_sub(&a.neg(), &b.neg(), d, &m.neg());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for elm in MUL_TRIPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
|
|
||||||
if !a.is_zero() {
|
|
||||||
check(&c, &a, &b, &Zero::zero());
|
|
||||||
}
|
|
||||||
if !b.is_zero() {
|
|
||||||
check(&c, &b, &a, &Zero::zero());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for elm in DIV_REM_QUADRUPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec, d_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
let d = BigInt::from_slice(Plus, d_vec);
|
|
||||||
|
|
||||||
if !b.is_zero() {
|
|
||||||
check(&a, &b, &c, &d);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_div_rem() {
|
|
||||||
fn check_sub(a: &BigInt, b: &BigInt, ans_q: &BigInt, ans_r: &BigInt) {
|
|
||||||
let (q, r) = a.div_rem(b);
|
|
||||||
if !r.is_zero() {
|
|
||||||
assert_eq!(r.sign, a.sign);
|
|
||||||
}
|
|
||||||
assert!(r.abs() <= b.abs());
|
|
||||||
assert!(*a == b * &q + &r);
|
|
||||||
assert!(q == *ans_q);
|
|
||||||
assert!(r == *ans_r);
|
|
||||||
|
|
||||||
let (a, b, ans_q, ans_r) = (a.clone(), b.clone(), ans_q.clone(), ans_r.clone());
|
|
||||||
assert_op!(a / b == ans_q);
|
|
||||||
assert_op!(a % b == ans_r);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) {
|
|
||||||
check_sub(a, b, q, r);
|
|
||||||
check_sub(a, &b.neg(), &q.neg(), r);
|
|
||||||
check_sub(&a.neg(), b, &q.neg(), &r.neg());
|
|
||||||
check_sub(&a.neg(), &b.neg(), q, &r.neg());
|
|
||||||
}
|
|
||||||
for elm in MUL_TRIPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
|
|
||||||
if !a.is_zero() {
|
|
||||||
check(&c, &a, &b, &Zero::zero());
|
|
||||||
}
|
|
||||||
if !b.is_zero() {
|
|
||||||
check(&c, &b, &a, &Zero::zero());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for elm in DIV_REM_QUADRUPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec, d_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
let d = BigInt::from_slice(Plus, d_vec);
|
|
||||||
|
|
||||||
if !b.is_zero() {
|
|
||||||
check(&a, &b, &c, &d);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_checked_add() {
|
|
||||||
for elm in SUM_TRIPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
|
|
||||||
assert!(a.checked_add(&b).unwrap() == c);
|
|
||||||
assert!(b.checked_add(&a).unwrap() == c);
|
|
||||||
assert!(c.checked_add(&(-&a)).unwrap() == b);
|
|
||||||
assert!(c.checked_add(&(-&b)).unwrap() == a);
|
|
||||||
assert!(a.checked_add(&(-&c)).unwrap() == (-&b));
|
|
||||||
assert!(b.checked_add(&(-&c)).unwrap() == (-&a));
|
|
||||||
assert!((-&a).checked_add(&(-&b)).unwrap() == (-&c));
|
|
||||||
assert!(a.checked_add(&(-&a)).unwrap() == Zero::zero());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_checked_sub() {
|
|
||||||
for elm in SUM_TRIPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
|
|
||||||
assert!(c.checked_sub(&a).unwrap() == b);
|
|
||||||
assert!(c.checked_sub(&b).unwrap() == a);
|
|
||||||
assert!((-&b).checked_sub(&a).unwrap() == (-&c));
|
|
||||||
assert!((-&a).checked_sub(&b).unwrap() == (-&c));
|
|
||||||
assert!(b.checked_sub(&(-&a)).unwrap() == c);
|
|
||||||
assert!(a.checked_sub(&(-&b)).unwrap() == c);
|
|
||||||
assert!((-&c).checked_sub(&(-&a)).unwrap() == (-&b));
|
|
||||||
assert!(a.checked_sub(&a).unwrap() == Zero::zero());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_checked_mul() {
|
|
||||||
for elm in MUL_TRIPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
|
|
||||||
assert!(a.checked_mul(&b).unwrap() == c);
|
|
||||||
assert!(b.checked_mul(&a).unwrap() == c);
|
|
||||||
|
|
||||||
assert!((-&a).checked_mul(&b).unwrap() == -&c);
|
|
||||||
assert!((-&b).checked_mul(&a).unwrap() == -&c);
|
|
||||||
}
|
|
||||||
|
|
||||||
for elm in DIV_REM_QUADRUPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec, d_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
let d = BigInt::from_slice(Plus, d_vec);
|
|
||||||
|
|
||||||
assert!(a == b.checked_mul(&c).unwrap() + &d);
|
|
||||||
assert!(a == c.checked_mul(&b).unwrap() + &d);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn test_checked_div() {
|
|
||||||
for elm in MUL_TRIPLES.iter() {
|
|
||||||
let (a_vec, b_vec, c_vec) = *elm;
|
|
||||||
let a = BigInt::from_slice(Plus, a_vec);
|
|
||||||
let b = BigInt::from_slice(Plus, b_vec);
|
|
||||||
let c = BigInt::from_slice(Plus, c_vec);
|
|
||||||
|
|
||||||
if !a.is_zero() {
|
|
||||||
assert!(c.checked_div(&a).unwrap() == b);
|
|
||||||
assert!((-&c).checked_div(&(-&a)).unwrap() == b);
|
|
||||||
assert!((-&c).checked_div(&a).unwrap() == -&b);
|
|
||||||
}
|
|
||||||
if !b.is_zero() {
|
|
||||||
assert!(c.checked_div(&b).unwrap() == a);
|
|
||||||
assert!((-&c).checked_div(&(-&b)).unwrap() == a);
|
|
||||||
assert!((-&c).checked_div(&b).unwrap() == -&a);
|
|
||||||
}
|
|
||||||
|
|
||||||
assert!(c.checked_div(&Zero::zero()).is_none());
|
|
||||||
assert!((-&c).checked_div(&Zero::zero()).is_none());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_gcd() {
|
|
||||||
fn check(a: isize, b: isize, c: isize) {
|
|
||||||
let big_a: BigInt = FromPrimitive::from_isize(a).unwrap();
|
|
||||||
let big_b: BigInt = FromPrimitive::from_isize(b).unwrap();
|
|
||||||
let big_c: BigInt = FromPrimitive::from_isize(c).unwrap();
|
|
||||||
|
|
||||||
assert_eq!(big_a.gcd(&big_b), big_c);
|
|
||||||
}
|
|
||||||
|
|
||||||
check(10, 2, 2);
|
|
||||||
check(10, 3, 1);
|
|
||||||
check(0, 3, 3);
|
|
||||||
check(3, 3, 3);
|
|
||||||
check(56, 42, 14);
|
|
||||||
check(3, -3, 3);
|
|
||||||
check(-6, 3, 3);
|
|
||||||
check(-4, -2, 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_lcm() {
|
|
||||||
fn check(a: isize, b: isize, c: isize) {
|
|
||||||
let big_a: BigInt = FromPrimitive::from_isize(a).unwrap();
|
|
||||||
let big_b: BigInt = FromPrimitive::from_isize(b).unwrap();
|
|
||||||
let big_c: BigInt = FromPrimitive::from_isize(c).unwrap();
|
|
||||||
|
|
||||||
assert_eq!(big_a.lcm(&big_b), big_c);
|
|
||||||
}
|
|
||||||
|
|
||||||
check(1, 0, 0);
|
|
||||||
check(0, 1, 0);
|
|
||||||
check(1, 1, 1);
|
|
||||||
check(-1, 1, 1);
|
|
||||||
check(1, -1, 1);
|
|
||||||
check(-1, -1, 1);
|
|
||||||
check(8, 9, 72);
|
|
||||||
check(11, 5, 55);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_abs_sub() {
|
|
||||||
let zero: BigInt = Zero::zero();
|
|
||||||
let one: BigInt = One::one();
|
|
||||||
assert_eq!((-&one).abs_sub(&one), zero);
|
|
||||||
let one: BigInt = One::one();
|
|
||||||
let zero: BigInt = Zero::zero();
|
|
||||||
assert_eq!(one.abs_sub(&one), zero);
|
|
||||||
let one: BigInt = One::one();
|
|
||||||
let zero: BigInt = Zero::zero();
|
|
||||||
assert_eq!(one.abs_sub(&zero), one);
|
|
||||||
let one: BigInt = One::one();
|
|
||||||
let two: BigInt = FromPrimitive::from_isize(2).unwrap();
|
|
||||||
assert_eq!(one.abs_sub(&-&one), two);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_from_str_radix() {
|
|
||||||
fn check(s: &str, ans: Option<isize>) {
|
|
||||||
let ans = ans.map(|n| {
|
|
||||||
let x: BigInt = FromPrimitive::from_isize(n).unwrap();
|
|
||||||
x
|
|
||||||
});
|
|
||||||
assert_eq!(BigInt::from_str_radix(s, 10).ok(), ans);
|
|
||||||
}
|
|
||||||
check("10", Some(10));
|
|
||||||
check("1", Some(1));
|
|
||||||
check("0", Some(0));
|
|
||||||
check("-1", Some(-1));
|
|
||||||
check("-10", Some(-10));
|
|
||||||
check("+10", Some(10));
|
|
||||||
check("--7", None);
|
|
||||||
check("++5", None);
|
|
||||||
check("+-9", None);
|
|
||||||
check("-+3", None);
|
|
||||||
check("Z", None);
|
|
||||||
check("_", None);
|
|
||||||
|
|
||||||
// issue 10522, this hit an edge case that caused it to
|
|
||||||
// attempt to allocate a vector of size (-1u) == huge.
|
|
||||||
let x: BigInt = format!("1{}", repeat("0").take(36).collect::<String>()).parse().unwrap();
|
|
||||||
let _y = x.to_string();
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_lower_hex() {
|
|
||||||
let a = BigInt::parse_bytes(b"A", 16).unwrap();
|
|
||||||
let hello = BigInt::parse_bytes("-22405534230753963835153736737".as_bytes(), 10).unwrap();
|
|
||||||
|
|
||||||
assert_eq!(format!("{:x}", a), "a");
|
|
||||||
assert_eq!(format!("{:x}", hello), "-48656c6c6f20776f726c6421");
|
|
||||||
assert_eq!(format!("{:♥>+#8x}", a), "♥♥♥♥+0xa");
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_upper_hex() {
|
|
||||||
let a = BigInt::parse_bytes(b"A", 16).unwrap();
|
|
||||||
let hello = BigInt::parse_bytes("-22405534230753963835153736737".as_bytes(), 10).unwrap();
|
|
||||||
|
|
||||||
assert_eq!(format!("{:X}", a), "A");
|
|
||||||
assert_eq!(format!("{:X}", hello), "-48656C6C6F20776F726C6421");
|
|
||||||
assert_eq!(format!("{:♥>+#8X}", a), "♥♥♥♥+0xA");
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_binary() {
|
|
||||||
let a = BigInt::parse_bytes(b"A", 16).unwrap();
|
|
||||||
let hello = BigInt::parse_bytes("-224055342307539".as_bytes(), 10).unwrap();
|
|
||||||
|
|
||||||
assert_eq!(format!("{:b}", a), "1010");
|
|
||||||
assert_eq!(format!("{:b}", hello),
|
|
||||||
"-110010111100011011110011000101101001100011010011");
|
|
||||||
assert_eq!(format!("{:♥>+#8b}", a), "♥+0b1010");
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_octal() {
|
|
||||||
let a = BigInt::parse_bytes(b"A", 16).unwrap();
|
|
||||||
let hello = BigInt::parse_bytes("-22405534230753963835153736737".as_bytes(), 10).unwrap();
|
|
||||||
|
|
||||||
assert_eq!(format!("{:o}", a), "12");
|
|
||||||
assert_eq!(format!("{:o}", hello), "-22062554330674403566756233062041");
|
|
||||||
assert_eq!(format!("{:♥>+#8o}", a), "♥♥♥+0o12");
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_display() {
|
|
||||||
let a = BigInt::parse_bytes(b"A", 16).unwrap();
|
|
||||||
let hello = BigInt::parse_bytes("-22405534230753963835153736737".as_bytes(), 10).unwrap();
|
|
||||||
|
|
||||||
assert_eq!(format!("{}", a), "10");
|
|
||||||
assert_eq!(format!("{}", hello), "-22405534230753963835153736737");
|
|
||||||
assert_eq!(format!("{:♥>+#8}", a), "♥♥♥♥♥+10");
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_neg() {
|
|
||||||
assert!(-BigInt::new(Plus, vec![1, 1, 1]) == BigInt::new(Minus, vec![1, 1, 1]));
|
|
||||||
assert!(-BigInt::new(Minus, vec![1, 1, 1]) == BigInt::new(Plus, vec![1, 1, 1]));
|
|
||||||
let zero: BigInt = Zero::zero();
|
|
||||||
assert_eq!(-&zero, zero);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_rand() {
|
|
||||||
let mut rng = thread_rng();
|
|
||||||
let _n: BigInt = rng.gen_bigint(137);
|
|
||||||
assert!(rng.gen_bigint(0).is_zero());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_rand_range() {
|
|
||||||
let mut rng = thread_rng();
|
|
||||||
|
|
||||||
for _ in 0..10 {
|
|
||||||
assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_usize(236).unwrap(),
|
|
||||||
&FromPrimitive::from_usize(237).unwrap()),
|
|
||||||
FromPrimitive::from_usize(236).unwrap());
|
|
||||||
}
|
|
||||||
|
|
||||||
fn check(l: BigInt, u: BigInt) {
|
|
||||||
let mut rng = thread_rng();
|
|
||||||
for _ in 0..1000 {
|
|
||||||
let n: BigInt = rng.gen_bigint_range(&l, &u);
|
|
||||||
assert!(n >= l);
|
|
||||||
assert!(n < u);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
let l: BigInt = FromPrimitive::from_usize(403469000 + 2352).unwrap();
|
|
||||||
let u: BigInt = FromPrimitive::from_usize(403469000 + 3513).unwrap();
|
|
||||||
check(l.clone(), u.clone());
|
|
||||||
check(-l.clone(), u.clone());
|
|
||||||
check(-u.clone(), -l.clone());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
#[should_panic]
|
|
||||||
fn test_zero_rand_range() {
|
|
||||||
thread_rng().gen_bigint_range(&FromPrimitive::from_isize(54).unwrap(),
|
|
||||||
&FromPrimitive::from_isize(54).unwrap());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
#[should_panic]
|
|
||||||
fn test_negative_rand_range() {
|
|
||||||
let mut rng = thread_rng();
|
|
||||||
let l = FromPrimitive::from_usize(2352).unwrap();
|
|
||||||
let u = FromPrimitive::from_usize(3513).unwrap();
|
|
||||||
// Switching u and l should fail:
|
|
||||||
let _n: BigInt = rng.gen_bigint_range(&u, &l);
|
|
||||||
}
|
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,3 @@
|
||||||
|
status = [
|
||||||
|
"continuous-integration/travis-ci/push",
|
||||||
|
]
|
|
@ -0,0 +1,14 @@
|
||||||
|
extern crate autocfg;
|
||||||
|
|
||||||
|
use std::env;
|
||||||
|
|
||||||
|
fn main() {
|
||||||
|
let ac = autocfg::new();
|
||||||
|
if ac.probe_type("i128") {
|
||||||
|
println!("cargo:rustc-cfg=has_i128");
|
||||||
|
} else if env::var_os("CARGO_FEATURE_I128").is_some() {
|
||||||
|
panic!("i128 support was not detected!");
|
||||||
|
}
|
||||||
|
|
||||||
|
autocfg::rerun_path(file!());
|
||||||
|
}
|
|
@ -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
|
|
11
ci/rustup.sh
11
ci/rustup.sh
|
@ -1,12 +1,11 @@
|
||||||
#!/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
|
||||||
|
|
||||||
for toolchain in 1.8.0 1.15.0 beta nightly; do
|
export TRAVIS_RUST_VERSION
|
||||||
run="rustup run $toolchain"
|
for TRAVIS_RUST_VERSION in 1.8.0 1.15.0 1.20.0 stable beta nightly; do
|
||||||
$run cargo build --verbose
|
run="rustup run $TRAVIS_RUST_VERSION"
|
||||||
$run $PWD/ci/test_full.sh $toolchain
|
$run $PWD/ci/test_full.sh
|
||||||
$run cargo doc
|
|
||||||
done
|
done
|
||||||
|
|
|
@ -2,48 +2,26 @@
|
||||||
|
|
||||||
set -ex
|
set -ex
|
||||||
|
|
||||||
echo Testing num on rustc ${TRAVIS_RUST_VERSION:=$1}
|
echo Testing num-traits on rustc ${TRAVIS_RUST_VERSION}
|
||||||
|
|
||||||
# All of these packages should build and test everywhere.
|
# num-traits should build and test everywhere.
|
||||||
for package in bigint complex integer iter rational traits; do
|
cargo build --verbose
|
||||||
cargo build --manifest-path $package/Cargo.toml
|
cargo test --verbose
|
||||||
cargo test --manifest-path $package/Cargo.toml
|
|
||||||
done
|
|
||||||
|
|
||||||
# They all should build with minimal features too
|
# test `no_std`
|
||||||
for package in bigint complex integer iter rational traits; do
|
cargo build --verbose --no-default-features
|
||||||
cargo build --manifest-path $package/Cargo.toml --no-default-features
|
cargo test --verbose --no-default-features
|
||||||
cargo test --manifest-path $package/Cargo.toml --no-default-features
|
|
||||||
done
|
|
||||||
|
|
||||||
# Each isolated feature should also work everywhere.
|
if [[ "$TRAVIS_RUST_VERSION" =~ ^(nightly|beta|stable)$ ]]; then
|
||||||
for feature in '' bigint rational complex; do
|
# test `i128`
|
||||||
cargo build --verbose --no-default-features --features="$feature"
|
cargo build --verbose --features=i128
|
||||||
cargo test --verbose --no-default-features --features="$feature"
|
cargo test --verbose --features=i128
|
||||||
done
|
|
||||||
|
|
||||||
# Build test for the serde feature
|
# test with std and libm (libm build fails on Rust 1.26 and earlier)
|
||||||
cargo build --verbose --features "serde"
|
cargo build --verbose --features "libm"
|
||||||
|
cargo test --verbose --features "libm"
|
||||||
|
|
||||||
# Downgrade serde and build test the 0.7.0 channel as well
|
# test `no_std` with libm (libm build fails on Rust 1.26 and earlier)
|
||||||
cargo update -p serde --precise 0.7.0
|
cargo build --verbose --no-default-features --features "libm"
|
||||||
cargo build --verbose --features "serde"
|
cargo test --verbose --no-default-features --features "libm"
|
||||||
|
fi
|
||||||
|
|
||||||
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
|
|
||||||
|
|
||||||
# num-macros only works on nightly, soon to be deprecated
|
|
||||||
cargo build --verbose --manifest-path=macros/Cargo.toml
|
|
||||||
cargo test --verbose --manifest-path=macros/Cargo.toml
|
|
||||||
|
|
||||||
# benchmarks only work on nightly
|
|
||||||
cargo bench --verbose
|
|
||||||
|
|
|
@ -1,29 +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"]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
name = "num-complex"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
version = "0.1.38"
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
|
|
||||||
[dependencies.num-traits]
|
|
||||||
optional = false
|
|
||||||
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 = ["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.
|
|
1402
complex/src/lib.rs
1402
complex/src/lib.rs
File diff suppressed because it is too large
Load Diff
|
@ -1,26 +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"]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
name = "num-derive"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
version = "0.1.40"
|
|
||||||
|
|
||||||
[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,70 +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()
|
|
||||||
}
|
|
|
@ -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,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)]
|
|
||||||
enum Color {}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_empty_enum() {
|
|
||||||
let v: [Option<Color>; 1] = [num::FromPrimitive::from_u64(0)];
|
|
||||||
|
|
||||||
assert_eq!(v, [None]);
|
|
||||||
}
|
|
|
@ -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,
|
|
||||||
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]);
|
|
||||||
}
|
|
|
@ -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,14 +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"]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
name = "num-integer"
|
|
||||||
version = "0.1.34"
|
|
||||||
|
|
||||||
[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,22 +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"]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
name = "num-iter"
|
|
||||||
version = "0.1.33"
|
|
||||||
|
|
||||||
[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,17 +0,0 @@
|
||||||
[package]
|
|
||||||
name = "num-macros"
|
|
||||||
version = "0.1.38"
|
|
||||||
authors = ["The Rust Project Developers"]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
homepage = "https://github.com/rust-num/num"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
documentation = "http://rust-num.github.io/num"
|
|
||||||
keywords = ["mathematics", "numerics"]
|
|
||||||
description = "Numeric syntax extensions"
|
|
||||||
|
|
||||||
[lib]
|
|
||||||
name = "num_macros"
|
|
||||||
plugin = true
|
|
||||||
|
|
||||||
[dev-dependencies]
|
|
||||||
num = { path = "..", version = "0.1" }
|
|
|
@ -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,204 +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.
|
|
||||||
|
|
||||||
#![feature(plugin_registrar, rustc_private)]
|
|
||||||
#![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 syntax;
|
|
||||||
extern crate syntax_ext;
|
|
||||||
extern crate rustc_plugin;
|
|
||||||
|
|
||||||
use syntax::ast::{MetaItem, Expr, BinOpKind};
|
|
||||||
use syntax::ast;
|
|
||||||
use syntax::codemap::Span;
|
|
||||||
use syntax::ext::base::{ExtCtxt, Annotatable};
|
|
||||||
use syntax::ext::build::AstBuilder;
|
|
||||||
use syntax_ext::deriving::generic::*;
|
|
||||||
use syntax_ext::deriving::generic::ty::*;
|
|
||||||
use syntax::symbol::Symbol;
|
|
||||||
use syntax::ptr::P;
|
|
||||||
use syntax::ext::base::MultiDecorator;
|
|
||||||
|
|
||||||
use rustc_plugin::Registry;
|
|
||||||
|
|
||||||
macro_rules! pathvec {
|
|
||||||
($($x:ident)::+) => (
|
|
||||||
vec![ $( stringify!($x) ),+ ]
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! path {
|
|
||||||
($($x:tt)*) => (
|
|
||||||
::syntax_ext::deriving::generic::ty::Path::new( pathvec!( $($x)* ) )
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! path_local {
|
|
||||||
($x:ident) => (
|
|
||||||
::syntax_ext::deriving::generic::ty::Path::new_local(stringify!($x))
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! pathvec_std {
|
|
||||||
($cx:expr, $first:ident :: $($rest:ident)::+) => ({
|
|
||||||
let mut v = pathvec!($($rest)::+);
|
|
||||||
if let Some(s) = $cx.crate_root {
|
|
||||||
v.insert(0, s);
|
|
||||||
}
|
|
||||||
v
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
|
|
||||||
span: Span,
|
|
||||||
mitem: &MetaItem,
|
|
||||||
item: &Annotatable,
|
|
||||||
push: &mut FnMut(Annotatable))
|
|
||||||
{
|
|
||||||
let inline = cx.meta_word(span, Symbol::intern("inline"));
|
|
||||||
let attrs = vec!(cx.attribute(span, inline));
|
|
||||||
let trait_def = TraitDef {
|
|
||||||
is_unsafe: false,
|
|
||||||
span: span,
|
|
||||||
attributes: Vec::new(),
|
|
||||||
path: path!(num::FromPrimitive),
|
|
||||||
additional_bounds: Vec::new(),
|
|
||||||
generics: LifetimeBounds::empty(),
|
|
||||||
methods: vec!(
|
|
||||||
MethodDef {
|
|
||||||
name: "from_i64",
|
|
||||||
is_unsafe: false,
|
|
||||||
unify_fieldless_variants: false,
|
|
||||||
generics: LifetimeBounds::empty(),
|
|
||||||
explicit_self: None,
|
|
||||||
args: vec!(Literal(path_local!(i64))),
|
|
||||||
ret_ty: Literal(Path::new_(pathvec_std!(cx, core::option::Option),
|
|
||||||
None,
|
|
||||||
vec!(Box::new(Self_)),
|
|
||||||
true)),
|
|
||||||
// #[inline] liable to cause code-bloat
|
|
||||||
attributes: attrs.clone(),
|
|
||||||
combine_substructure: combine_substructure(Box::new(|c, s, sub| {
|
|
||||||
cs_from("i64", c, s, sub)
|
|
||||||
})),
|
|
||||||
},
|
|
||||||
MethodDef {
|
|
||||||
name: "from_u64",
|
|
||||||
is_unsafe: false,
|
|
||||||
unify_fieldless_variants: false,
|
|
||||||
generics: LifetimeBounds::empty(),
|
|
||||||
explicit_self: None,
|
|
||||||
args: vec!(Literal(path_local!(u64))),
|
|
||||||
ret_ty: Literal(Path::new_(pathvec_std!(cx, core::option::Option),
|
|
||||||
None,
|
|
||||||
vec!(Box::new(Self_)),
|
|
||||||
true)),
|
|
||||||
// #[inline] liable to cause code-bloat
|
|
||||||
attributes: attrs,
|
|
||||||
combine_substructure: combine_substructure(Box::new(|c, s, sub| {
|
|
||||||
cs_from("u64", c, s, sub)
|
|
||||||
})),
|
|
||||||
}
|
|
||||||
),
|
|
||||||
associated_types: Vec::new(),
|
|
||||||
supports_unions: false,
|
|
||||||
};
|
|
||||||
|
|
||||||
trait_def.expand(cx, mitem, &item, push)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
|
|
||||||
if substr.nonself_args.len() != 1 {
|
|
||||||
cx.span_bug(trait_span, "incorrect number of arguments in `derive(FromPrimitive)`")
|
|
||||||
}
|
|
||||||
|
|
||||||
let n = &substr.nonself_args[0];
|
|
||||||
|
|
||||||
match *substr.fields {
|
|
||||||
StaticStruct(..) => {
|
|
||||||
cx.span_err(trait_span, "`FromPrimitive` cannot be derived for structs");
|
|
||||||
return cx.expr_fail(trait_span, Symbol::intern(""));
|
|
||||||
}
|
|
||||||
StaticEnum(enum_def, _) => {
|
|
||||||
if enum_def.variants.is_empty() {
|
|
||||||
cx.span_err(trait_span,
|
|
||||||
"`FromPrimitive` cannot be derived for enums with no variants");
|
|
||||||
return cx.expr_fail(trait_span, Symbol::intern(""));
|
|
||||||
}
|
|
||||||
|
|
||||||
let mut arms = Vec::new();
|
|
||||||
|
|
||||||
for variant in &enum_def.variants {
|
|
||||||
match variant.node.data {
|
|
||||||
ast::VariantData::Unit(..) => {
|
|
||||||
let span = variant.span;
|
|
||||||
|
|
||||||
// expr for `$n == $variant as $name`
|
|
||||||
let path = cx.path(span, vec![substr.type_ident, variant.node.name]);
|
|
||||||
let variant = cx.expr_path(path);
|
|
||||||
let ty = cx.ty_ident(span, cx.ident_of(name));
|
|
||||||
let cast = cx.expr_cast(span, variant.clone(), ty);
|
|
||||||
let guard = cx.expr_binary(span, BinOpKind::Eq, n.clone(), cast);
|
|
||||||
|
|
||||||
// expr for `Some($variant)`
|
|
||||||
let body = cx.expr_some(span, variant);
|
|
||||||
|
|
||||||
// arm for `_ if $guard => $body`
|
|
||||||
let arm = ast::Arm {
|
|
||||||
attrs: vec!(),
|
|
||||||
pats: vec!(cx.pat_wild(span)),
|
|
||||||
guard: Some(guard),
|
|
||||||
body: body,
|
|
||||||
};
|
|
||||||
|
|
||||||
arms.push(arm);
|
|
||||||
}
|
|
||||||
ast::VariantData::Tuple(..) => {
|
|
||||||
cx.span_err(trait_span,
|
|
||||||
"`FromPrimitive` cannot be derived for \
|
|
||||||
enum variants with arguments");
|
|
||||||
return cx.expr_fail(trait_span,
|
|
||||||
Symbol::intern(""));
|
|
||||||
}
|
|
||||||
ast::VariantData::Struct(..) => {
|
|
||||||
cx.span_err(trait_span,
|
|
||||||
"`FromPrimitive` cannot be derived for enums \
|
|
||||||
with struct variants");
|
|
||||||
return cx.expr_fail(trait_span,
|
|
||||||
Symbol::intern(""));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// arm for `_ => None`
|
|
||||||
let arm = ast::Arm {
|
|
||||||
attrs: vec!(),
|
|
||||||
pats: vec!(cx.pat_wild(trait_span)),
|
|
||||||
guard: None,
|
|
||||||
body: cx.expr_none(trait_span),
|
|
||||||
};
|
|
||||||
arms.push(arm);
|
|
||||||
|
|
||||||
cx.expr_match(trait_span, n.clone(), arms)
|
|
||||||
}
|
|
||||||
_ => cx.span_bug(trait_span, "expected StaticEnum in derive(FromPrimitive)")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[plugin_registrar]
|
|
||||||
#[doc(hidden)]
|
|
||||||
pub fn plugin_registrar(reg: &mut Registry) {
|
|
||||||
reg.register_syntax_extension(
|
|
||||||
Symbol::intern("derive_NumFromPrimitive"),
|
|
||||||
MultiDecorator(Box::new(expand_deriving_from_primitive)));
|
|
||||||
}
|
|
|
@ -1,36 +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.
|
|
||||||
|
|
||||||
#![feature(custom_derive, plugin)]
|
|
||||||
#![plugin(num_macros)]
|
|
||||||
|
|
||||||
extern crate num;
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, NumFromPrimitive)]
|
|
||||||
enum Color {
|
|
||||||
Red,
|
|
||||||
Blue,
|
|
||||||
Green,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_from_primitive() {
|
|
||||||
let v: Vec<Option<Color>> = vec![
|
|
||||||
num::FromPrimitive::from_u64(0),
|
|
||||||
num::FromPrimitive::from_u64(1),
|
|
||||||
num::FromPrimitive::from_u64(2),
|
|
||||||
num::FromPrimitive::from_u64(3),
|
|
||||||
];
|
|
||||||
|
|
||||||
assert_eq!(
|
|
||||||
v,
|
|
||||||
vec![Some(Color::Red), Some(Color::Blue), Some(Color::Green), None]
|
|
||||||
);
|
|
||||||
}
|
|
|
@ -1,37 +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"]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
name = "num-rational"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
version = "0.1.37"
|
|
||||||
|
|
||||||
[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.
|
|
1385
rational/src/lib.rs
1385
rational/src/lib.rs
File diff suppressed because it is too large
Load Diff
|
@ -1,7 +1,9 @@
|
||||||
use std::{usize, u8, u16, u32, u64};
|
use core::num::Wrapping;
|
||||||
use std::{isize, i8, i16, i32, i64};
|
use core::{f32, f64};
|
||||||
use std::{f32, f64};
|
#[cfg(has_i128)]
|
||||||
use std::num::Wrapping;
|
use core::{i128, u128};
|
||||||
|
use core::{i16, i32, i64, i8, isize};
|
||||||
|
use core::{u16, u32, u64, u8, usize};
|
||||||
|
|
||||||
/// Numbers which have upper and lower bounds
|
/// Numbers which have upper and lower bounds
|
||||||
pub trait Bounded {
|
pub trait Bounded {
|
||||||
|
@ -16,12 +18,16 @@ macro_rules! bounded_impl {
|
||||||
($t:ty, $min:expr, $max:expr) => {
|
($t:ty, $min:expr, $max:expr) => {
|
||||||
impl Bounded for $t {
|
impl Bounded for $t {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn min_value() -> $t { $min }
|
fn min_value() -> $t {
|
||||||
|
$min
|
||||||
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn max_value() -> $t { $max }
|
fn max_value() -> $t {
|
||||||
|
$max
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
bounded_impl!(usize, usize::MIN, usize::MAX);
|
bounded_impl!(usize, usize::MIN, usize::MAX);
|
||||||
|
@ -29,16 +35,24 @@ bounded_impl!(u8, u8::MIN, u8::MAX);
|
||||||
bounded_impl!(u16, u16::MIN, u16::MAX);
|
bounded_impl!(u16, u16::MIN, u16::MAX);
|
||||||
bounded_impl!(u32, u32::MIN, u32::MAX);
|
bounded_impl!(u32, u32::MIN, u32::MAX);
|
||||||
bounded_impl!(u64, u64::MIN, u64::MAX);
|
bounded_impl!(u64, u64::MIN, u64::MAX);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
bounded_impl!(u128, u128::MIN, u128::MAX);
|
||||||
|
|
||||||
bounded_impl!(isize, isize::MIN, isize::MAX);
|
bounded_impl!(isize, isize::MIN, isize::MAX);
|
||||||
bounded_impl!(i8, i8::MIN, i8::MAX);
|
bounded_impl!(i8, i8::MIN, i8::MAX);
|
||||||
bounded_impl!(i16, i16::MIN, i16::MAX);
|
bounded_impl!(i16, i16::MIN, i16::MAX);
|
||||||
bounded_impl!(i32, i32::MIN, i32::MAX);
|
bounded_impl!(i32, i32::MIN, i32::MAX);
|
||||||
bounded_impl!(i64, i64::MIN, i64::MAX);
|
bounded_impl!(i64, i64::MIN, i64::MAX);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
bounded_impl!(i128, i128::MIN, i128::MAX);
|
||||||
|
|
||||||
impl<T: Bounded> Bounded for Wrapping<T> {
|
impl<T: Bounded> Bounded for Wrapping<T> {
|
||||||
fn min_value() -> Self { Wrapping(T::min_value()) }
|
fn min_value() -> Self {
|
||||||
fn max_value() -> Self { Wrapping(T::max_value()) }
|
Wrapping(T::min_value())
|
||||||
|
}
|
||||||
|
fn max_value() -> Self {
|
||||||
|
Wrapping(T::max_value())
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
bounded_impl!(f32, f32::MIN, f32::MAX);
|
bounded_impl!(f32, f32::MIN, f32::MAX);
|
||||||
|
@ -53,9 +67,9 @@ macro_rules! for_each_tuple_ {
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
macro_rules! for_each_tuple {
|
macro_rules! for_each_tuple {
|
||||||
( $m:ident ) => (
|
($m:ident) => {
|
||||||
for_each_tuple_! { $m !! A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, }
|
for_each_tuple_! { $m !! A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, }
|
||||||
);
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
macro_rules! bounded_tuple {
|
macro_rules! bounded_tuple {
|
||||||
|
@ -76,21 +90,35 @@ macro_rules! bounded_tuple {
|
||||||
for_each_tuple!(bounded_tuple);
|
for_each_tuple!(bounded_tuple);
|
||||||
bounded_impl!(f64, f64::MIN, f64::MAX);
|
bounded_impl!(f64, f64::MIN, f64::MAX);
|
||||||
|
|
||||||
|
|
||||||
macro_rules! test_wrapping_bounded {
|
|
||||||
($($t:ty)+) => {
|
|
||||||
$(
|
|
||||||
assert_eq!(Wrapping::<$t>::min_value().0, <$t>::min_value());
|
|
||||||
assert_eq!(Wrapping::<$t>::max_value().0, <$t>::max_value());
|
|
||||||
)+
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn wrapping_bounded() {
|
fn wrapping_bounded() {
|
||||||
|
macro_rules! test_wrapping_bounded {
|
||||||
|
($($t:ty)+) => {
|
||||||
|
$(
|
||||||
|
assert_eq!(<Wrapping<$t> as Bounded>::min_value().0, <$t>::min_value());
|
||||||
|
assert_eq!(<Wrapping<$t> as Bounded>::max_value().0, <$t>::max_value());
|
||||||
|
)+
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
test_wrapping_bounded!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
|
test_wrapping_bounded!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
#[test]
|
||||||
|
fn wrapping_bounded_i128() {
|
||||||
|
macro_rules! test_wrapping_bounded {
|
||||||
|
($($t:ty)+) => {
|
||||||
|
$(
|
||||||
|
assert_eq!(<Wrapping<$t> as Bounded>::min_value().0, <$t>::min_value());
|
||||||
|
assert_eq!(<Wrapping<$t> as Bounded>::max_value().0, <$t>::max_value());
|
||||||
|
)+
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
test_wrapping_bounded!(u128 i128);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn wrapping_is_bounded() {
|
fn wrapping_is_bounded() {
|
||||||
fn require_bounded<T: Bounded>(_: &T) {}
|
fn require_bounded<T: Bounded>(_: &T) {}
|
|
@ -0,0 +1,762 @@
|
||||||
|
use core::mem::size_of;
|
||||||
|
use core::num::Wrapping;
|
||||||
|
use core::{f32, f64};
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
use core::{i128, u128};
|
||||||
|
use core::{i16, i32, i64, i8, isize};
|
||||||
|
use core::{u16, u32, u64, u8, usize};
|
||||||
|
|
||||||
|
use float::FloatCore;
|
||||||
|
|
||||||
|
/// A generic trait for converting a value to a number.
|
||||||
|
pub trait ToPrimitive {
|
||||||
|
/// Converts the value of `self` to an `isize`.
|
||||||
|
#[inline]
|
||||||
|
fn to_isize(&self) -> Option<isize> {
|
||||||
|
self.to_i64().as_ref().and_then(ToPrimitive::to_isize)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `i8`.
|
||||||
|
#[inline]
|
||||||
|
fn to_i8(&self) -> Option<i8> {
|
||||||
|
self.to_i64().as_ref().and_then(ToPrimitive::to_i8)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `i16`.
|
||||||
|
#[inline]
|
||||||
|
fn to_i16(&self) -> Option<i16> {
|
||||||
|
self.to_i64().as_ref().and_then(ToPrimitive::to_i16)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `i32`.
|
||||||
|
#[inline]
|
||||||
|
fn to_i32(&self) -> Option<i32> {
|
||||||
|
self.to_i64().as_ref().and_then(ToPrimitive::to_i32)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `i64`.
|
||||||
|
fn to_i64(&self) -> Option<i64>;
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `i128`.
|
||||||
|
///
|
||||||
|
/// This method is only available with feature `i128` enabled on Rust >= 1.26.
|
||||||
|
///
|
||||||
|
/// The default implementation converts through `to_i64()`. Types implementing
|
||||||
|
/// this trait should override this method if they can represent a greater range.
|
||||||
|
#[inline]
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_i128(&self) -> Option<i128> {
|
||||||
|
self.to_i64().map(From::from)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to a `usize`.
|
||||||
|
#[inline]
|
||||||
|
fn to_usize(&self) -> Option<usize> {
|
||||||
|
self.to_u64().as_ref().and_then(ToPrimitive::to_usize)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `u8`.
|
||||||
|
#[inline]
|
||||||
|
fn to_u8(&self) -> Option<u8> {
|
||||||
|
self.to_u64().as_ref().and_then(ToPrimitive::to_u8)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `u16`.
|
||||||
|
#[inline]
|
||||||
|
fn to_u16(&self) -> Option<u16> {
|
||||||
|
self.to_u64().as_ref().and_then(ToPrimitive::to_u16)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `u32`.
|
||||||
|
#[inline]
|
||||||
|
fn to_u32(&self) -> Option<u32> {
|
||||||
|
self.to_u64().as_ref().and_then(ToPrimitive::to_u32)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `u64`.
|
||||||
|
#[inline]
|
||||||
|
fn to_u64(&self) -> Option<u64>;
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `u128`.
|
||||||
|
///
|
||||||
|
/// This method is only available with feature `i128` enabled on Rust >= 1.26.
|
||||||
|
///
|
||||||
|
/// The default implementation converts through `to_u64()`. Types implementing
|
||||||
|
/// this trait should override this method if they can represent a greater range.
|
||||||
|
#[inline]
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_u128(&self) -> Option<u128> {
|
||||||
|
self.to_u64().map(From::from)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `f32`.
|
||||||
|
#[inline]
|
||||||
|
fn to_f32(&self) -> Option<f32> {
|
||||||
|
self.to_f64().as_ref().and_then(ToPrimitive::to_f32)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the value of `self` to an `f64`.
|
||||||
|
#[inline]
|
||||||
|
fn to_f64(&self) -> Option<f64> {
|
||||||
|
match self.to_i64() {
|
||||||
|
Some(i) => i.to_f64(),
|
||||||
|
None => self.to_u64().as_ref().and_then(ToPrimitive::to_f64),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_int_to_int {
|
||||||
|
($SrcT:ident : $( $(#[$cfg:meta])* fn $method:ident -> $DstT:ident ; )*) => {$(
|
||||||
|
#[inline]
|
||||||
|
$(#[$cfg])*
|
||||||
|
fn $method(&self) -> Option<$DstT> {
|
||||||
|
let min = $DstT::MIN as $SrcT;
|
||||||
|
let max = $DstT::MAX as $SrcT;
|
||||||
|
if size_of::<$SrcT>() <= size_of::<$DstT>() || (min <= *self && *self <= max) {
|
||||||
|
Some(*self as $DstT)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_int_to_uint {
|
||||||
|
($SrcT:ident : $( $(#[$cfg:meta])* fn $method:ident -> $DstT:ident ; )*) => {$(
|
||||||
|
#[inline]
|
||||||
|
$(#[$cfg])*
|
||||||
|
fn $method(&self) -> Option<$DstT> {
|
||||||
|
let max = $DstT::MAX as $SrcT;
|
||||||
|
if 0 <= *self && (size_of::<$SrcT>() <= size_of::<$DstT>() || *self <= max) {
|
||||||
|
Some(*self as $DstT)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_int {
|
||||||
|
($T:ident) => {
|
||||||
|
impl ToPrimitive for $T {
|
||||||
|
impl_to_primitive_int_to_int! { $T:
|
||||||
|
fn to_isize -> isize;
|
||||||
|
fn to_i8 -> i8;
|
||||||
|
fn to_i16 -> i16;
|
||||||
|
fn to_i32 -> i32;
|
||||||
|
fn to_i64 -> i64;
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_i128 -> i128;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_to_primitive_int_to_uint! { $T:
|
||||||
|
fn to_usize -> usize;
|
||||||
|
fn to_u8 -> u8;
|
||||||
|
fn to_u16 -> u16;
|
||||||
|
fn to_u32 -> u32;
|
||||||
|
fn to_u64 -> u64;
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_u128 -> u128;
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn to_f32(&self) -> Option<f32> {
|
||||||
|
Some(*self as f32)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn to_f64(&self) -> Option<f64> {
|
||||||
|
Some(*self as f64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_to_primitive_int!(isize);
|
||||||
|
impl_to_primitive_int!(i8);
|
||||||
|
impl_to_primitive_int!(i16);
|
||||||
|
impl_to_primitive_int!(i32);
|
||||||
|
impl_to_primitive_int!(i64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
impl_to_primitive_int!(i128);
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_uint_to_int {
|
||||||
|
($SrcT:ident : $( $(#[$cfg:meta])* fn $method:ident -> $DstT:ident ; )*) => {$(
|
||||||
|
#[inline]
|
||||||
|
$(#[$cfg])*
|
||||||
|
fn $method(&self) -> Option<$DstT> {
|
||||||
|
let max = $DstT::MAX as $SrcT;
|
||||||
|
if size_of::<$SrcT>() < size_of::<$DstT>() || *self <= max {
|
||||||
|
Some(*self as $DstT)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_uint_to_uint {
|
||||||
|
($SrcT:ident : $( $(#[$cfg:meta])* fn $method:ident -> $DstT:ident ; )*) => {$(
|
||||||
|
#[inline]
|
||||||
|
$(#[$cfg])*
|
||||||
|
fn $method(&self) -> Option<$DstT> {
|
||||||
|
let max = $DstT::MAX as $SrcT;
|
||||||
|
if size_of::<$SrcT>() <= size_of::<$DstT>() || *self <= max {
|
||||||
|
Some(*self as $DstT)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_uint {
|
||||||
|
($T:ident) => {
|
||||||
|
impl ToPrimitive for $T {
|
||||||
|
impl_to_primitive_uint_to_int! { $T:
|
||||||
|
fn to_isize -> isize;
|
||||||
|
fn to_i8 -> i8;
|
||||||
|
fn to_i16 -> i16;
|
||||||
|
fn to_i32 -> i32;
|
||||||
|
fn to_i64 -> i64;
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_i128 -> i128;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_to_primitive_uint_to_uint! { $T:
|
||||||
|
fn to_usize -> usize;
|
||||||
|
fn to_u8 -> u8;
|
||||||
|
fn to_u16 -> u16;
|
||||||
|
fn to_u32 -> u32;
|
||||||
|
fn to_u64 -> u64;
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_u128 -> u128;
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn to_f32(&self) -> Option<f32> {
|
||||||
|
Some(*self as f32)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn to_f64(&self) -> Option<f64> {
|
||||||
|
Some(*self as f64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_to_primitive_uint!(usize);
|
||||||
|
impl_to_primitive_uint!(u8);
|
||||||
|
impl_to_primitive_uint!(u16);
|
||||||
|
impl_to_primitive_uint!(u32);
|
||||||
|
impl_to_primitive_uint!(u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
impl_to_primitive_uint!(u128);
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_float_to_float {
|
||||||
|
($SrcT:ident : $( fn $method:ident -> $DstT:ident ; )*) => {$(
|
||||||
|
#[inline]
|
||||||
|
fn $method(&self) -> Option<$DstT> {
|
||||||
|
// Only finite values that are reducing size need to worry about overflow.
|
||||||
|
if size_of::<$SrcT>() > size_of::<$DstT>() && FloatCore::is_finite(*self) {
|
||||||
|
let n = *self as f64;
|
||||||
|
if n < $DstT::MIN as f64 || n > $DstT::MAX as f64 {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// We can safely cast NaN, +-inf, and finite values in range.
|
||||||
|
Some(*self as $DstT)
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_float_to_signed_int {
|
||||||
|
($f:ident : $( $(#[$cfg:meta])* fn $method:ident -> $i:ident ; )*) => {$(
|
||||||
|
#[inline]
|
||||||
|
$(#[$cfg])*
|
||||||
|
fn $method(&self) -> Option<$i> {
|
||||||
|
// Float as int truncates toward zero, so we want to allow values
|
||||||
|
// in the exclusive range `(MIN-1, MAX+1)`.
|
||||||
|
if size_of::<$f>() > size_of::<$i>() {
|
||||||
|
// With a larger size, we can represent the range exactly.
|
||||||
|
const MIN_M1: $f = $i::MIN as $f - 1.0;
|
||||||
|
const MAX_P1: $f = $i::MAX as $f + 1.0;
|
||||||
|
if *self > MIN_M1 && *self < MAX_P1 {
|
||||||
|
return Some(*self as $i);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// We can't represent `MIN-1` exactly, but there's no fractional part
|
||||||
|
// at this magnitude, so we can just use a `MIN` inclusive boundary.
|
||||||
|
const MIN: $f = $i::MIN as $f;
|
||||||
|
// We can't represent `MAX` exactly, but it will round up to exactly
|
||||||
|
// `MAX+1` (a power of two) when we cast it.
|
||||||
|
const MAX_P1: $f = $i::MAX as $f;
|
||||||
|
if *self >= MIN && *self < MAX_P1 {
|
||||||
|
return Some(*self as $i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_float_to_unsigned_int {
|
||||||
|
($f:ident : $( $(#[$cfg:meta])* fn $method:ident -> $u:ident ; )*) => {$(
|
||||||
|
#[inline]
|
||||||
|
$(#[$cfg])*
|
||||||
|
fn $method(&self) -> Option<$u> {
|
||||||
|
// Float as int truncates toward zero, so we want to allow values
|
||||||
|
// in the exclusive range `(-1, MAX+1)`.
|
||||||
|
if size_of::<$f>() > size_of::<$u>() {
|
||||||
|
// With a larger size, we can represent the range exactly.
|
||||||
|
const MAX_P1: $f = $u::MAX as $f + 1.0;
|
||||||
|
if *self > -1.0 && *self < MAX_P1 {
|
||||||
|
return Some(*self as $u);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// We can't represent `MAX` exactly, but it will round up to exactly
|
||||||
|
// `MAX+1` (a power of two) when we cast it.
|
||||||
|
// (`u128::MAX as f32` is infinity, but this is still ok.)
|
||||||
|
const MAX_P1: $f = $u::MAX as $f;
|
||||||
|
if *self > -1.0 && *self < MAX_P1 {
|
||||||
|
return Some(*self as $u);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_float {
|
||||||
|
($T:ident) => {
|
||||||
|
impl ToPrimitive for $T {
|
||||||
|
impl_to_primitive_float_to_signed_int! { $T:
|
||||||
|
fn to_isize -> isize;
|
||||||
|
fn to_i8 -> i8;
|
||||||
|
fn to_i16 -> i16;
|
||||||
|
fn to_i32 -> i32;
|
||||||
|
fn to_i64 -> i64;
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_i128 -> i128;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_to_primitive_float_to_unsigned_int! { $T:
|
||||||
|
fn to_usize -> usize;
|
||||||
|
fn to_u8 -> u8;
|
||||||
|
fn to_u16 -> u16;
|
||||||
|
fn to_u32 -> u32;
|
||||||
|
fn to_u64 -> u64;
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_u128 -> u128;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_to_primitive_float_to_float! { $T:
|
||||||
|
fn to_f32 -> f32;
|
||||||
|
fn to_f64 -> f64;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_to_primitive_float!(f32);
|
||||||
|
impl_to_primitive_float!(f64);
|
||||||
|
|
||||||
|
/// A generic trait for converting a number to a value.
|
||||||
|
pub trait FromPrimitive: Sized {
|
||||||
|
/// Convert an `isize` to return an optional value of this type. If the
|
||||||
|
/// value cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_isize(n: isize) -> Option<Self> {
|
||||||
|
n.to_i64().and_then(FromPrimitive::from_i64)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert an `i8` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_i8(n: i8) -> Option<Self> {
|
||||||
|
FromPrimitive::from_i64(From::from(n))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert an `i16` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_i16(n: i16) -> Option<Self> {
|
||||||
|
FromPrimitive::from_i64(From::from(n))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert an `i32` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_i32(n: i32) -> Option<Self> {
|
||||||
|
FromPrimitive::from_i64(From::from(n))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert an `i64` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
fn from_i64(n: i64) -> Option<Self>;
|
||||||
|
|
||||||
|
/// Convert an `i128` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
///
|
||||||
|
/// This method is only available with feature `i128` enabled on Rust >= 1.26.
|
||||||
|
///
|
||||||
|
/// The default implementation converts through `from_i64()`. Types implementing
|
||||||
|
/// this trait should override this method if they can represent a greater range.
|
||||||
|
#[inline]
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn from_i128(n: i128) -> Option<Self> {
|
||||||
|
n.to_i64().and_then(FromPrimitive::from_i64)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert a `usize` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_usize(n: usize) -> Option<Self> {
|
||||||
|
n.to_u64().and_then(FromPrimitive::from_u64)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert an `u8` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_u8(n: u8) -> Option<Self> {
|
||||||
|
FromPrimitive::from_u64(From::from(n))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert an `u16` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_u16(n: u16) -> Option<Self> {
|
||||||
|
FromPrimitive::from_u64(From::from(n))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert an `u32` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_u32(n: u32) -> Option<Self> {
|
||||||
|
FromPrimitive::from_u64(From::from(n))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert an `u64` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
fn from_u64(n: u64) -> Option<Self>;
|
||||||
|
|
||||||
|
/// Convert an `u128` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
///
|
||||||
|
/// This method is only available with feature `i128` enabled on Rust >= 1.26.
|
||||||
|
///
|
||||||
|
/// The default implementation converts through `from_u64()`. Types implementing
|
||||||
|
/// this trait should override this method if they can represent a greater range.
|
||||||
|
#[inline]
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn from_u128(n: u128) -> Option<Self> {
|
||||||
|
n.to_u64().and_then(FromPrimitive::from_u64)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert a `f32` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_f32(n: f32) -> Option<Self> {
|
||||||
|
FromPrimitive::from_f64(From::from(n))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert a `f64` to return an optional value of this type. If the
|
||||||
|
/// type cannot be represented by this value, then `None` is returned.
|
||||||
|
#[inline]
|
||||||
|
fn from_f64(n: f64) -> Option<Self> {
|
||||||
|
match n.to_i64() {
|
||||||
|
Some(i) => FromPrimitive::from_i64(i),
|
||||||
|
None => n.to_u64().and_then(FromPrimitive::from_u64),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_from_primitive {
|
||||||
|
($T:ty, $to_ty:ident) => {
|
||||||
|
#[allow(deprecated)]
|
||||||
|
impl FromPrimitive for $T {
|
||||||
|
#[inline]
|
||||||
|
fn from_isize(n: isize) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn from_i8(n: i8) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn from_i16(n: i16) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn from_i32(n: i32) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn from_i64(n: i64) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
#[inline]
|
||||||
|
fn from_i128(n: i128) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn from_usize(n: usize) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn from_u8(n: u8) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn from_u16(n: u16) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn from_u32(n: u32) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn from_u64(n: u64) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
#[inline]
|
||||||
|
fn from_u128(n: u128) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn from_f32(n: f32) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn from_f64(n: f64) -> Option<$T> {
|
||||||
|
n.$to_ty()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_from_primitive!(isize, to_isize);
|
||||||
|
impl_from_primitive!(i8, to_i8);
|
||||||
|
impl_from_primitive!(i16, to_i16);
|
||||||
|
impl_from_primitive!(i32, to_i32);
|
||||||
|
impl_from_primitive!(i64, to_i64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
impl_from_primitive!(i128, to_i128);
|
||||||
|
impl_from_primitive!(usize, to_usize);
|
||||||
|
impl_from_primitive!(u8, to_u8);
|
||||||
|
impl_from_primitive!(u16, to_u16);
|
||||||
|
impl_from_primitive!(u32, to_u32);
|
||||||
|
impl_from_primitive!(u64, to_u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
impl_from_primitive!(u128, to_u128);
|
||||||
|
impl_from_primitive!(f32, to_f32);
|
||||||
|
impl_from_primitive!(f64, to_f64);
|
||||||
|
|
||||||
|
macro_rules! impl_to_primitive_wrapping {
|
||||||
|
($( $(#[$cfg:meta])* fn $method:ident -> $i:ident ; )*) => {$(
|
||||||
|
#[inline]
|
||||||
|
$(#[$cfg])*
|
||||||
|
fn $method(&self) -> Option<$i> {
|
||||||
|
(self.0).$method()
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: ToPrimitive> ToPrimitive for Wrapping<T> {
|
||||||
|
impl_to_primitive_wrapping! {
|
||||||
|
fn to_isize -> isize;
|
||||||
|
fn to_i8 -> i8;
|
||||||
|
fn to_i16 -> i16;
|
||||||
|
fn to_i32 -> i32;
|
||||||
|
fn to_i64 -> i64;
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_i128 -> i128;
|
||||||
|
|
||||||
|
fn to_usize -> usize;
|
||||||
|
fn to_u8 -> u8;
|
||||||
|
fn to_u16 -> u16;
|
||||||
|
fn to_u32 -> u32;
|
||||||
|
fn to_u64 -> u64;
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn to_u128 -> u128;
|
||||||
|
|
||||||
|
fn to_f32 -> f32;
|
||||||
|
fn to_f64 -> f64;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_from_primitive_wrapping {
|
||||||
|
($( $(#[$cfg:meta])* fn $method:ident ( $i:ident ); )*) => {$(
|
||||||
|
#[inline]
|
||||||
|
$(#[$cfg])*
|
||||||
|
fn $method(n: $i) -> Option<Self> {
|
||||||
|
T::$method(n).map(Wrapping)
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: FromPrimitive> FromPrimitive for Wrapping<T> {
|
||||||
|
impl_from_primitive_wrapping! {
|
||||||
|
fn from_isize(isize);
|
||||||
|
fn from_i8(i8);
|
||||||
|
fn from_i16(i16);
|
||||||
|
fn from_i32(i32);
|
||||||
|
fn from_i64(i64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn from_i128(i128);
|
||||||
|
|
||||||
|
fn from_usize(usize);
|
||||||
|
fn from_u8(u8);
|
||||||
|
fn from_u16(u16);
|
||||||
|
fn from_u32(u32);
|
||||||
|
fn from_u64(u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn from_u128(u128);
|
||||||
|
|
||||||
|
fn from_f32(f32);
|
||||||
|
fn from_f64(f64);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cast from one machine scalar to another.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use num_traits as num;
|
||||||
|
/// let twenty: f32 = num::cast(0x14).unwrap();
|
||||||
|
/// assert_eq!(twenty, 20f32);
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
#[inline]
|
||||||
|
pub fn cast<T: NumCast, U: NumCast>(n: T) -> Option<U> {
|
||||||
|
NumCast::from(n)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An interface for casting between machine scalars.
|
||||||
|
pub trait NumCast: Sized + ToPrimitive {
|
||||||
|
/// Creates a number from another value that can be converted into
|
||||||
|
/// a primitive via the `ToPrimitive` trait.
|
||||||
|
fn from<T: ToPrimitive>(n: T) -> Option<Self>;
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_num_cast {
|
||||||
|
($T:ty, $conv:ident) => {
|
||||||
|
impl NumCast for $T {
|
||||||
|
#[inline]
|
||||||
|
#[allow(deprecated)]
|
||||||
|
fn from<N: ToPrimitive>(n: N) -> Option<$T> {
|
||||||
|
// `$conv` could be generated using `concat_idents!`, but that
|
||||||
|
// macro seems to be broken at the moment
|
||||||
|
n.$conv()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_num_cast!(u8, to_u8);
|
||||||
|
impl_num_cast!(u16, to_u16);
|
||||||
|
impl_num_cast!(u32, to_u32);
|
||||||
|
impl_num_cast!(u64, to_u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
impl_num_cast!(u128, to_u128);
|
||||||
|
impl_num_cast!(usize, to_usize);
|
||||||
|
impl_num_cast!(i8, to_i8);
|
||||||
|
impl_num_cast!(i16, to_i16);
|
||||||
|
impl_num_cast!(i32, to_i32);
|
||||||
|
impl_num_cast!(i64, to_i64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
impl_num_cast!(i128, to_i128);
|
||||||
|
impl_num_cast!(isize, to_isize);
|
||||||
|
impl_num_cast!(f32, to_f32);
|
||||||
|
impl_num_cast!(f64, to_f64);
|
||||||
|
|
||||||
|
impl<T: NumCast> NumCast for Wrapping<T> {
|
||||||
|
fn from<U: ToPrimitive>(n: U) -> Option<Self> {
|
||||||
|
T::from(n).map(Wrapping)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A generic interface for casting between machine scalars with the
|
||||||
|
/// `as` operator, which admits narrowing and precision loss.
|
||||||
|
/// Implementers of this trait `AsPrimitive` should behave like a primitive
|
||||||
|
/// numeric type (e.g. a newtype around another primitive), and the
|
||||||
|
/// intended conversion must never fail.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use num_traits::AsPrimitive;
|
||||||
|
/// let three: i32 = (3.14159265f32).as_();
|
||||||
|
/// assert_eq!(three, 3);
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// # Safety
|
||||||
|
///
|
||||||
|
/// Currently, some uses of the `as` operator are not entirely safe.
|
||||||
|
/// In particular, it is undefined behavior if:
|
||||||
|
///
|
||||||
|
/// - A truncated floating point value cannot fit in the target integer
|
||||||
|
/// type ([#10184](https://github.com/rust-lang/rust/issues/10184));
|
||||||
|
///
|
||||||
|
/// ```ignore
|
||||||
|
/// # use num_traits::AsPrimitive;
|
||||||
|
/// let x: u8 = (1.04E+17).as_(); // UB
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// - Or a floating point value does not fit in another floating
|
||||||
|
/// point type ([#15536](https://github.com/rust-lang/rust/issues/15536)).
|
||||||
|
///
|
||||||
|
/// ```ignore
|
||||||
|
/// # use num_traits::AsPrimitive;
|
||||||
|
/// let x: f32 = (1e300f64).as_(); // UB
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
pub trait AsPrimitive<T>: 'static + Copy
|
||||||
|
where
|
||||||
|
T: 'static + Copy,
|
||||||
|
{
|
||||||
|
/// Convert a value to another, using the `as` operator.
|
||||||
|
fn as_(self) -> T;
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_as_primitive {
|
||||||
|
(@ $T: ty => $(#[$cfg:meta])* impl $U: ty ) => {
|
||||||
|
$(#[$cfg])*
|
||||||
|
impl AsPrimitive<$U> for $T {
|
||||||
|
#[inline] fn as_(self) -> $U { self as $U }
|
||||||
|
}
|
||||||
|
};
|
||||||
|
(@ $T: ty => { $( $U: ty ),* } ) => {$(
|
||||||
|
impl_as_primitive!(@ $T => impl $U);
|
||||||
|
)*};
|
||||||
|
($T: ty => { $( $U: ty ),* } ) => {
|
||||||
|
impl_as_primitive!(@ $T => { $( $U ),* });
|
||||||
|
impl_as_primitive!(@ $T => { u8, u16, u32, u64, usize });
|
||||||
|
impl_as_primitive!(@ $T => #[cfg(has_i128)] impl u128);
|
||||||
|
impl_as_primitive!(@ $T => { i8, i16, i32, i64, isize });
|
||||||
|
impl_as_primitive!(@ $T => #[cfg(has_i128)] impl i128);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_as_primitive!(u8 => { char, f32, f64 });
|
||||||
|
impl_as_primitive!(i8 => { f32, f64 });
|
||||||
|
impl_as_primitive!(u16 => { f32, f64 });
|
||||||
|
impl_as_primitive!(i16 => { f32, f64 });
|
||||||
|
impl_as_primitive!(u32 => { f32, f64 });
|
||||||
|
impl_as_primitive!(i32 => { f32, f64 });
|
||||||
|
impl_as_primitive!(u64 => { f32, f64 });
|
||||||
|
impl_as_primitive!(i64 => { f32, f64 });
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
impl_as_primitive!(u128 => { f32, f64 });
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
impl_as_primitive!(i128 => { f32, f64 });
|
||||||
|
impl_as_primitive!(usize => { f32, f64 });
|
||||||
|
impl_as_primitive!(isize => { f32, f64 });
|
||||||
|
impl_as_primitive!(f32 => { f32, f64 });
|
||||||
|
impl_as_primitive!(f64 => { f32, f64 });
|
||||||
|
impl_as_primitive!(char => { char });
|
||||||
|
impl_as_primitive!(bool => {});
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,207 @@
|
||||||
|
use core::num::Wrapping;
|
||||||
|
use core::ops::{Add, Mul};
|
||||||
|
|
||||||
|
/// Defines an additive identity element for `Self`.
|
||||||
|
///
|
||||||
|
/// # Laws
|
||||||
|
///
|
||||||
|
/// ```{.text}
|
||||||
|
/// a + 0 = a ∀ a ∈ Self
|
||||||
|
/// 0 + a = a ∀ a ∈ Self
|
||||||
|
/// ```
|
||||||
|
pub trait Zero: Sized + Add<Self, Output = Self> {
|
||||||
|
/// Returns the additive identity element of `Self`, `0`.
|
||||||
|
/// # Purity
|
||||||
|
///
|
||||||
|
/// This function should return the same result at all times regardless of
|
||||||
|
/// external mutable state, for example values stored in TLS or in
|
||||||
|
/// `static mut`s.
|
||||||
|
// This cannot be an associated constant, because of bignums.
|
||||||
|
fn zero() -> Self;
|
||||||
|
|
||||||
|
/// Sets `self` to the additive identity element of `Self`, `0`.
|
||||||
|
fn set_zero(&mut self) {
|
||||||
|
*self = Zero::zero();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns `true` if `self` is equal to the additive identity.
|
||||||
|
#[inline]
|
||||||
|
fn is_zero(&self) -> bool;
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! zero_impl {
|
||||||
|
($t:ty, $v:expr) => {
|
||||||
|
impl Zero for $t {
|
||||||
|
#[inline]
|
||||||
|
fn zero() -> $t {
|
||||||
|
$v
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn is_zero(&self) -> bool {
|
||||||
|
*self == $v
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
zero_impl!(usize, 0);
|
||||||
|
zero_impl!(u8, 0);
|
||||||
|
zero_impl!(u16, 0);
|
||||||
|
zero_impl!(u32, 0);
|
||||||
|
zero_impl!(u64, 0);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
zero_impl!(u128, 0);
|
||||||
|
|
||||||
|
zero_impl!(isize, 0);
|
||||||
|
zero_impl!(i8, 0);
|
||||||
|
zero_impl!(i16, 0);
|
||||||
|
zero_impl!(i32, 0);
|
||||||
|
zero_impl!(i64, 0);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
zero_impl!(i128, 0);
|
||||||
|
|
||||||
|
zero_impl!(f32, 0.0);
|
||||||
|
zero_impl!(f64, 0.0);
|
||||||
|
|
||||||
|
impl<T: Zero> Zero for Wrapping<T>
|
||||||
|
where
|
||||||
|
Wrapping<T>: Add<Output = Wrapping<T>>,
|
||||||
|
{
|
||||||
|
fn is_zero(&self) -> bool {
|
||||||
|
self.0.is_zero()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn set_zero(&mut self) {
|
||||||
|
self.0.set_zero();
|
||||||
|
}
|
||||||
|
|
||||||
|
fn zero() -> Self {
|
||||||
|
Wrapping(T::zero())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Defines a multiplicative identity element for `Self`.
|
||||||
|
///
|
||||||
|
/// # Laws
|
||||||
|
///
|
||||||
|
/// ```{.text}
|
||||||
|
/// a * 1 = a ∀ a ∈ Self
|
||||||
|
/// 1 * a = a ∀ a ∈ Self
|
||||||
|
/// ```
|
||||||
|
pub trait One: Sized + Mul<Self, Output = Self> {
|
||||||
|
/// Returns the multiplicative identity element of `Self`, `1`.
|
||||||
|
///
|
||||||
|
/// # Purity
|
||||||
|
///
|
||||||
|
/// This function should return the same result at all times regardless of
|
||||||
|
/// external mutable state, for example values stored in TLS or in
|
||||||
|
/// `static mut`s.
|
||||||
|
// This cannot be an associated constant, because of bignums.
|
||||||
|
fn one() -> Self;
|
||||||
|
|
||||||
|
/// Sets `self` to the multiplicative identity element of `Self`, `1`.
|
||||||
|
fn set_one(&mut self) {
|
||||||
|
*self = One::one();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns `true` if `self` is equal to the multiplicative identity.
|
||||||
|
///
|
||||||
|
/// For performance reasons, it's best to implement this manually.
|
||||||
|
/// After a semver bump, this method will be required, and the
|
||||||
|
/// `where Self: PartialEq` bound will be removed.
|
||||||
|
#[inline]
|
||||||
|
fn is_one(&self) -> bool
|
||||||
|
where
|
||||||
|
Self: PartialEq,
|
||||||
|
{
|
||||||
|
*self == Self::one()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! one_impl {
|
||||||
|
($t:ty, $v:expr) => {
|
||||||
|
impl One for $t {
|
||||||
|
#[inline]
|
||||||
|
fn one() -> $t {
|
||||||
|
$v
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn is_one(&self) -> bool {
|
||||||
|
*self == $v
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
one_impl!(usize, 1);
|
||||||
|
one_impl!(u8, 1);
|
||||||
|
one_impl!(u16, 1);
|
||||||
|
one_impl!(u32, 1);
|
||||||
|
one_impl!(u64, 1);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
one_impl!(u128, 1);
|
||||||
|
|
||||||
|
one_impl!(isize, 1);
|
||||||
|
one_impl!(i8, 1);
|
||||||
|
one_impl!(i16, 1);
|
||||||
|
one_impl!(i32, 1);
|
||||||
|
one_impl!(i64, 1);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
one_impl!(i128, 1);
|
||||||
|
|
||||||
|
one_impl!(f32, 1.0);
|
||||||
|
one_impl!(f64, 1.0);
|
||||||
|
|
||||||
|
impl<T: One> One for Wrapping<T>
|
||||||
|
where
|
||||||
|
Wrapping<T>: Mul<Output = Wrapping<T>>,
|
||||||
|
{
|
||||||
|
fn set_one(&mut self) {
|
||||||
|
self.0.set_one();
|
||||||
|
}
|
||||||
|
|
||||||
|
fn one() -> Self {
|
||||||
|
Wrapping(T::one())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Some helper functions provided for backwards compatibility.
|
||||||
|
|
||||||
|
/// Returns the additive identity, `0`.
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn zero<T: Zero>() -> T {
|
||||||
|
Zero::zero()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the multiplicative identity, `1`.
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn one<T: One>() -> T {
|
||||||
|
One::one()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_identities() {
|
||||||
|
macro_rules! test_wrapping_identities {
|
||||||
|
($($t:ty)+) => {
|
||||||
|
$(
|
||||||
|
assert_eq!(zero::<$t>(), zero::<Wrapping<$t>>().0);
|
||||||
|
assert_eq!(one::<$t>(), one::<Wrapping<$t>>().0);
|
||||||
|
assert_eq!((0 as $t).is_zero(), Wrapping(0 as $t).is_zero());
|
||||||
|
assert_eq!((1 as $t).is_zero(), Wrapping(1 as $t).is_zero());
|
||||||
|
)+
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
test_wrapping_identities!(isize i8 i16 i32 i64 usize u8 u16 u32 u64);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_zero() {
|
||||||
|
fn require_zero<T: Zero>(_: &T) {}
|
||||||
|
require_zero(&Wrapping(42));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_one() {
|
||||||
|
fn require_one<T: One>(_: &T) {}
|
||||||
|
require_one(&Wrapping(42));
|
||||||
|
}
|
|
@ -1,26 +1,55 @@
|
||||||
use std::ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
|
use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
|
||||||
|
|
||||||
use {Num, NumCast};
|
|
||||||
use bounds::Bounded;
|
use bounds::Bounded;
|
||||||
use ops::checked::*;
|
use ops::checked::*;
|
||||||
use ops::saturating::Saturating;
|
use ops::saturating::Saturating;
|
||||||
|
use {Num, NumCast};
|
||||||
|
|
||||||
pub trait PrimInt
|
/// Generic trait for primitive integers.
|
||||||
: Sized
|
///
|
||||||
|
/// The `PrimInt` trait is an abstraction over the builtin primitive integer types (e.g., `u8`,
|
||||||
|
/// `u32`, `isize`, `i128`, ...). It inherits the basic numeric traits and extends them with
|
||||||
|
/// bitwise operators and non-wrapping arithmetic.
|
||||||
|
///
|
||||||
|
/// The trait explicitly inherits `Copy`, `Eq`, `Ord`, and `Sized`. The intention is that all
|
||||||
|
/// types implementing this trait behave like primitive types that are passed by value by default
|
||||||
|
/// and behave like builtin integers. Furthermore, the types are expected to expose the integer
|
||||||
|
/// value in binary representation and support bitwise operators. The standard bitwise operations
|
||||||
|
/// (e.g., bitwise-and, bitwise-or, right-shift, left-shift) are inherited and the trait extends
|
||||||
|
/// these with introspective queries (e.g., `PrimInt::count_ones()`, `PrimInt::leading_zeros()`),
|
||||||
|
/// bitwise combinators (e.g., `PrimInt::rotate_left()`), and endianness converters (e.g.,
|
||||||
|
/// `PrimInt::to_be()`).
|
||||||
|
///
|
||||||
|
/// All `PrimInt` types are expected to be fixed-width binary integers. The width can be queried
|
||||||
|
/// via `T::zero().count_zeros()`. The trait currently lacks a way to query the width at
|
||||||
|
/// compile-time.
|
||||||
|
///
|
||||||
|
/// While a default implementation for all builtin primitive integers is provided, the trait is in
|
||||||
|
/// no way restricted to these. Other integer types that fulfil the requirements are free to
|
||||||
|
/// implement the trait was well.
|
||||||
|
///
|
||||||
|
/// This trait and many of the method names originate in the unstable `core::num::Int` trait from
|
||||||
|
/// the rust standard library. The original trait was never stabilized and thus removed from the
|
||||||
|
/// standard library.
|
||||||
|
pub trait PrimInt:
|
||||||
|
Sized
|
||||||
+ Copy
|
+ Copy
|
||||||
+ Num + NumCast
|
+ Num
|
||||||
|
+ NumCast
|
||||||
+ Bounded
|
+ Bounded
|
||||||
+ PartialOrd + Ord + Eq
|
+ PartialOrd
|
||||||
+ Not<Output=Self>
|
+ Ord
|
||||||
+ BitAnd<Output=Self>
|
+ Eq
|
||||||
+ BitOr<Output=Self>
|
+ Not<Output = Self>
|
||||||
+ BitXor<Output=Self>
|
+ BitAnd<Output = Self>
|
||||||
+ Shl<usize, Output=Self>
|
+ BitOr<Output = Self>
|
||||||
+ Shr<usize, Output=Self>
|
+ BitXor<Output = Self>
|
||||||
+ CheckedAdd<Output=Self>
|
+ Shl<usize, Output = Self>
|
||||||
+ CheckedSub<Output=Self>
|
+ Shr<usize, Output = Self>
|
||||||
+ CheckedMul<Output=Self>
|
+ CheckedAdd<Output = Self>
|
||||||
+ CheckedDiv<Output=Self>
|
+ CheckedSub<Output = Self>
|
||||||
|
+ CheckedMul<Output = Self>
|
||||||
|
+ CheckedDiv<Output = Self>
|
||||||
+ Saturating
|
+ Saturating
|
||||||
{
|
{
|
||||||
/// Returns the number of ones in the binary representation of `self`.
|
/// Returns the number of ones in the binary representation of `self`.
|
||||||
|
@ -168,10 +197,10 @@ pub trait PrimInt
|
||||||
/// ```
|
/// ```
|
||||||
/// use num_traits::PrimInt;
|
/// use num_traits::PrimInt;
|
||||||
///
|
///
|
||||||
/// let n = 0xFEDCBA9876543210i64;
|
/// let n = -8i8; // 0b11111000
|
||||||
/// let m = 0x000FEDCBA9876543i64;
|
/// let m = 62i8; // 0b00111110
|
||||||
///
|
///
|
||||||
/// assert_eq!(n.unsigned_shr(12), m);
|
/// assert_eq!(n.unsigned_shr(2), m);
|
||||||
/// ```
|
/// ```
|
||||||
fn unsigned_shr(self, n: u32) -> Self;
|
fn unsigned_shr(self, n: u32) -> Self;
|
||||||
|
|
||||||
|
@ -278,7 +307,7 @@ pub trait PrimInt
|
||||||
}
|
}
|
||||||
|
|
||||||
macro_rules! prim_int_impl {
|
macro_rules! prim_int_impl {
|
||||||
($T:ty, $S:ty, $U:ty) => (
|
($T:ty, $S:ty, $U:ty) => {
|
||||||
impl PrimInt for $T {
|
impl PrimInt for $T {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn count_ones(self) -> u32 {
|
fn count_ones(self) -> u32 {
|
||||||
|
@ -360,7 +389,7 @@ macro_rules! prim_int_impl {
|
||||||
<$T>::pow(self, exp)
|
<$T>::pow(self, exp)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
)
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
// prim_int_impl!(type, signed, unsigned);
|
// prim_int_impl!(type, signed, unsigned);
|
||||||
|
@ -368,9 +397,13 @@ prim_int_impl!(u8, i8, u8);
|
||||||
prim_int_impl!(u16, i16, u16);
|
prim_int_impl!(u16, i16, u16);
|
||||||
prim_int_impl!(u32, i32, u32);
|
prim_int_impl!(u32, i32, u32);
|
||||||
prim_int_impl!(u64, i64, u64);
|
prim_int_impl!(u64, i64, u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
prim_int_impl!(u128, i128, u128);
|
||||||
prim_int_impl!(usize, isize, usize);
|
prim_int_impl!(usize, isize, usize);
|
||||||
prim_int_impl!(i8, i8, u8);
|
prim_int_impl!(i8, i8, u8);
|
||||||
prim_int_impl!(i16, i16, u16);
|
prim_int_impl!(i16, i16, u16);
|
||||||
prim_int_impl!(i32, i32, u32);
|
prim_int_impl!(i32, i32, u32);
|
||||||
prim_int_impl!(i64, i64, u64);
|
prim_int_impl!(i64, i64, u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
prim_int_impl!(i128, i128, u128);
|
||||||
prim_int_impl!(isize, isize, usize);
|
prim_int_impl!(isize, isize, usize);
|
633
src/lib.rs
633
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,565 @@
|
||||||
// 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,
|
//! ## Compatibility
|
||||||
//! new traits for generic programming on numeric properties like `Integer`,
|
|
||||||
//! and generic range iterators.
|
|
||||||
//!
|
//!
|
||||||
//! ## Example
|
//! The `num-traits` crate is tested for rustc 1.8 and greater.
|
||||||
//!
|
|
||||||
//! 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.2")]
|
||||||
extern crate num_integer;
|
#![deny(unconditional_recursion)]
|
||||||
extern crate num_iter;
|
#![no_std]
|
||||||
#[cfg(feature = "num-complex")]
|
#[cfg(feature = "std")]
|
||||||
extern crate num_complex;
|
extern crate std;
|
||||||
#[cfg(feature = "num-bigint")]
|
|
||||||
extern crate num_bigint;
|
|
||||||
#[cfg(feature = "num-rational")]
|
|
||||||
extern crate num_rational;
|
|
||||||
|
|
||||||
#[cfg(feature = "num-bigint")]
|
// Only `no_std` builds actually use `libm`.
|
||||||
pub use num_bigint::{BigInt, BigUint};
|
#[cfg(all(not(feature = "std"), feature = "libm"))]
|
||||||
#[cfg(feature = "num-rational")]
|
extern crate libm;
|
||||||
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")]
|
use core::fmt;
|
||||||
pub mod bigint {
|
use core::num::Wrapping;
|
||||||
pub use num_bigint::*;
|
use core::ops::{Add, Div, Mul, Rem, Sub};
|
||||||
|
use core::ops::{AddAssign, DivAssign, MulAssign, RemAssign, SubAssign};
|
||||||
|
|
||||||
|
pub use bounds::Bounded;
|
||||||
|
#[cfg(any(feature = "std", feature = "libm"))]
|
||||||
|
pub use float::Float;
|
||||||
|
pub use float::FloatConst;
|
||||||
|
// pub use real::{FloatCore, Real}; // NOTE: Don't do this, it breaks `use num_traits::*;`.
|
||||||
|
pub use cast::{cast, AsPrimitive, FromPrimitive, NumCast, ToPrimitive};
|
||||||
|
pub use identities::{one, zero, One, Zero};
|
||||||
|
pub use int::PrimInt;
|
||||||
|
pub use ops::checked::{
|
||||||
|
CheckedAdd, CheckedDiv, CheckedMul, CheckedNeg, CheckedRem, CheckedShl, CheckedShr, CheckedSub,
|
||||||
|
};
|
||||||
|
pub use ops::inv::Inv;
|
||||||
|
pub use ops::mul_add::{MulAdd, MulAddAssign};
|
||||||
|
pub use ops::saturating::Saturating;
|
||||||
|
pub use ops::wrapping::{WrappingAdd, WrappingMul, WrappingShl, WrappingShr, WrappingSub};
|
||||||
|
pub use pow::{checked_pow, pow, Pow};
|
||||||
|
pub use sign::{abs, abs_sub, signum, Signed, Unsigned};
|
||||||
|
|
||||||
|
#[macro_use]
|
||||||
|
mod macros;
|
||||||
|
|
||||||
|
pub mod bounds;
|
||||||
|
pub mod cast;
|
||||||
|
pub mod float;
|
||||||
|
pub mod identities;
|
||||||
|
pub mod int;
|
||||||
|
pub mod ops;
|
||||||
|
pub mod pow;
|
||||||
|
pub mod real;
|
||||||
|
pub mod sign;
|
||||||
|
|
||||||
|
/// 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>
|
||||||
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
pub mod integer {
|
impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
|
||||||
pub use num_integer::*;
|
T: Add<Rhs, Output = Output>
|
||||||
|
+ Sub<Rhs, Output = Output>
|
||||||
|
+ Mul<Rhs, Output = Output>
|
||||||
|
+ Div<Rhs, Output = Output>
|
||||||
|
+ Rem<Rhs, Output = Output>
|
||||||
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
pub mod iter {
|
/// The trait for `Num` types which also implement numeric operations taking
|
||||||
pub use num_iter::*;
|
/// 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>
|
||||||
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
pub mod traits {
|
impl<T, Rhs> NumAssignOps<Rhs> for T where
|
||||||
pub use num_traits::*;
|
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>
|
||||||
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(feature = "num-rational")]
|
/// The trait for `Num` types which also implement assignment operators.
|
||||||
pub mod rational {
|
///
|
||||||
pub use num_rational::*;
|
/// 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 = ::core::num::ParseIntError;
|
||||||
|
#[inline]
|
||||||
|
fn from_str_radix(s: &str, radix: u32)
|
||||||
|
-> Result<Self, ::core::num::ParseIntError>
|
||||||
|
{
|
||||||
|
<$t>::from_str_radix(s, radix)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*)
|
||||||
}
|
}
|
||||||
|
int_trait_impl!(Num for usize u8 u16 u32 u64 isize i8 i16 i32 i64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
int_trait_impl!(Num for u128 i128);
|
||||||
|
|
||||||
|
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: core::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,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Display for ParseFloatError {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
let description = match self.kind {
|
||||||
|
FloatErrorKind::Empty => "cannot parse float from empty string",
|
||||||
|
FloatErrorKind::Invalid => "invalid float literal",
|
||||||
|
};
|
||||||
|
|
||||||
|
description.fmt(f)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 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:ident)*) => ($(
|
||||||
|
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(core::$t::INFINITY),
|
||||||
|
"-inf" => return Ok(core::$t::NEG_INFINITY),
|
||||||
|
"NaN" => return Ok(core::$t::NAN),
|
||||||
|
_ => {},
|
||||||
|
}
|
||||||
|
|
||||||
|
fn slice_shift_char(src: &str) -> Option<(char, &str)> {
|
||||||
|
let mut chars = src.chars();
|
||||||
|
if let Some(ch) = chars.next() {
|
||||||
|
Some((ch, chars.as_str()))
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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(core::$t::INFINITY); }
|
||||||
|
if !is_positive && sig >= prev_sig
|
||||||
|
{ return Ok(core::$t::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(core::$t::INFINITY); }
|
||||||
|
if !is_positive && (prev_sig != (sig + digit as $t) / radix as $t)
|
||||||
|
{ return Ok(core::$t::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(core::$t::INFINITY); }
|
||||||
|
if !is_positive && sig > prev_sig
|
||||||
|
{ return Ok(core::$t::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 }),
|
||||||
|
};
|
||||||
|
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
fn pow(base: $t, exp: usize) -> $t {
|
||||||
|
Float::powi(base, exp as i32)
|
||||||
|
}
|
||||||
|
// otherwise uses the generic `pow` from the root
|
||||||
|
|
||||||
|
match (is_positive, exp) {
|
||||||
|
(true, Ok(exp)) => pow(base, exp),
|
||||||
|
(false, Ok(exp)) => 1.0 / pow(base, exp),
|
||||||
|
(_, 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.
|
||||||
|
///
|
||||||
|
/// **Panics** in debug mode if `!(min <= max)`.
|
||||||
|
#[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
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A value bounded by a minimum value
|
||||||
|
///
|
||||||
|
/// If input is less than min then this returns min.
|
||||||
|
/// Otherwise this returns input.
|
||||||
|
/// `clamp_min(std::f32::NAN, 1.0)` preserves `NAN` different from `f32::min(std::f32::NAN, 1.0)`.
|
||||||
|
///
|
||||||
|
/// **Panics** in debug mode if `!(min == min)`. (This occurs if `min` is `NAN`.)
|
||||||
|
#[inline]
|
||||||
|
pub fn clamp_min<T: PartialOrd>(input: T, min: T) -> T {
|
||||||
|
debug_assert!(min == min, "min must not be NAN");
|
||||||
|
if input < min {
|
||||||
|
min
|
||||||
|
} else {
|
||||||
|
input
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A value bounded by a maximum value
|
||||||
|
///
|
||||||
|
/// If input is greater than max then this returns max.
|
||||||
|
/// Otherwise this returns input.
|
||||||
|
/// `clamp_max(std::f32::NAN, 1.0)` preserves `NAN` different from `f32::max(std::f32::NAN, 1.0)`.
|
||||||
|
///
|
||||||
|
/// **Panics** in debug mode if `!(max == max)`. (This occurs if `max` is `NAN`.)
|
||||||
|
#[inline]
|
||||||
|
pub fn clamp_max<T: PartialOrd>(input: T, max: T) -> T {
|
||||||
|
debug_assert!(max == max, "max must not be NAN");
|
||||||
|
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));
|
||||||
|
assert_eq!(1, clamp_min(1, -1));
|
||||||
|
assert_eq!(-1, clamp_min(-2, -1));
|
||||||
|
assert_eq!(-1, clamp_max(1, -1));
|
||||||
|
assert_eq!(-2, clamp_max(-2, -1));
|
||||||
|
|
||||||
|
// 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));
|
||||||
|
assert_eq!(1.0, clamp_min(1.0, -1.0));
|
||||||
|
assert_eq!(-1.0, clamp_min(-2.0, -1.0));
|
||||||
|
assert_eq!(-1.0, clamp_max(1.0, -1.0));
|
||||||
|
assert_eq!(-2.0, clamp_max(-2.0, -1.0));
|
||||||
|
assert!(clamp(::core::f32::NAN, -1.0, 1.0).is_nan());
|
||||||
|
assert!(clamp_min(::core::f32::NAN, 1.0).is_nan());
|
||||||
|
assert!(clamp_max(::core::f32::NAN, 1.0).is_nan());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[should_panic]
|
||||||
|
#[cfg(debug_assertions)]
|
||||||
|
fn clamp_nan_min() {
|
||||||
|
clamp(0., ::core::f32::NAN, 1.);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[should_panic]
|
||||||
|
#[cfg(debug_assertions)]
|
||||||
|
fn clamp_nan_max() {
|
||||||
|
clamp(0., -1., ::core::f32::NAN);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[should_panic]
|
||||||
|
#[cfg(debug_assertions)]
|
||||||
|
fn clamp_nan_min_max() {
|
||||||
|
clamp(0., ::core::f32::NAN, ::core::f32::NAN);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[should_panic]
|
||||||
|
#[cfg(debug_assertions)]
|
||||||
|
fn clamp_min_nan_min() {
|
||||||
|
clamp_min(0., ::core::f32::NAN);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[should_panic]
|
||||||
|
#[cfg(debug_assertions)]
|
||||||
|
fn clamp_max_nan_max() {
|
||||||
|
clamp_max(0., ::core::f32::NAN);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[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 from_str_radix_multi_byte_fail() {
|
||||||
|
// Ensure parsing doesn't panic, even on invalid sign characters
|
||||||
|
assert!(f32::from_str_radix("™0.2", 10).is_err());
|
||||||
|
|
||||||
|
// Even when parsing the exponent sign
|
||||||
|
assert!(f32::from_str_radix("0.2E™1", 10).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[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)
|
||||||
|
|
|
@ -0,0 +1,37 @@
|
||||||
|
// not all are used in all features configurations
|
||||||
|
#![allow(unused)]
|
||||||
|
|
||||||
|
/// Forward a method to an inherent method or a base trait method.
|
||||||
|
macro_rules! forward {
|
||||||
|
($( Self :: $method:ident ( self $( , $arg:ident : $ty:ty )* ) -> $ret:ty ; )*)
|
||||||
|
=> {$(
|
||||||
|
#[inline]
|
||||||
|
fn $method(self $( , $arg : $ty )* ) -> $ret {
|
||||||
|
Self::$method(self $( , $arg )* )
|
||||||
|
}
|
||||||
|
)*};
|
||||||
|
($( $base:ident :: $method:ident ( self $( , $arg:ident : $ty:ty )* ) -> $ret:ty ; )*)
|
||||||
|
=> {$(
|
||||||
|
#[inline]
|
||||||
|
fn $method(self $( , $arg : $ty )* ) -> $ret {
|
||||||
|
<Self as $base>::$method(self $( , $arg )* )
|
||||||
|
}
|
||||||
|
)*};
|
||||||
|
($( $base:ident :: $method:ident ( $( $arg:ident : $ty:ty ),* ) -> $ret:ty ; )*)
|
||||||
|
=> {$(
|
||||||
|
#[inline]
|
||||||
|
fn $method( $( $arg : $ty ),* ) -> $ret {
|
||||||
|
<Self as $base>::$method( $( $arg ),* )
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! constant {
|
||||||
|
($( $method:ident () -> $ret:expr ; )*)
|
||||||
|
=> {$(
|
||||||
|
#[inline]
|
||||||
|
fn $method() -> Self {
|
||||||
|
$ret
|
||||||
|
}
|
||||||
|
)*};
|
||||||
|
}
|
|
@ -0,0 +1,277 @@
|
||||||
|
use core::ops::{Add, Div, Mul, Rem, Shl, Shr, Sub};
|
||||||
|
|
||||||
|
/// Performs addition that returns `None` instead of wrapping around on
|
||||||
|
/// overflow.
|
||||||
|
pub trait CheckedAdd: Sized + Add<Self, Output = Self> {
|
||||||
|
/// Adds two numbers, checking for overflow. If overflow happens, `None` is
|
||||||
|
/// returned.
|
||||||
|
fn checked_add(&self, v: &Self) -> Option<Self>;
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! checked_impl {
|
||||||
|
($trait_name:ident, $method:ident, $t:ty) => {
|
||||||
|
impl $trait_name for $t {
|
||||||
|
#[inline]
|
||||||
|
fn $method(&self, v: &$t) -> Option<$t> {
|
||||||
|
<$t>::$method(*self, *v)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
checked_impl!(CheckedAdd, checked_add, u8);
|
||||||
|
checked_impl!(CheckedAdd, checked_add, u16);
|
||||||
|
checked_impl!(CheckedAdd, checked_add, u32);
|
||||||
|
checked_impl!(CheckedAdd, checked_add, u64);
|
||||||
|
checked_impl!(CheckedAdd, checked_add, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedAdd, checked_add, u128);
|
||||||
|
|
||||||
|
checked_impl!(CheckedAdd, checked_add, i8);
|
||||||
|
checked_impl!(CheckedAdd, checked_add, i16);
|
||||||
|
checked_impl!(CheckedAdd, checked_add, i32);
|
||||||
|
checked_impl!(CheckedAdd, checked_add, i64);
|
||||||
|
checked_impl!(CheckedAdd, checked_add, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedAdd, checked_add, i128);
|
||||||
|
|
||||||
|
/// Performs subtraction that returns `None` instead of wrapping around on underflow.
|
||||||
|
pub trait CheckedSub: Sized + Sub<Self, Output = Self> {
|
||||||
|
/// Subtracts two numbers, checking for underflow. If underflow happens,
|
||||||
|
/// `None` is returned.
|
||||||
|
fn checked_sub(&self, v: &Self) -> Option<Self>;
|
||||||
|
}
|
||||||
|
|
||||||
|
checked_impl!(CheckedSub, checked_sub, u8);
|
||||||
|
checked_impl!(CheckedSub, checked_sub, u16);
|
||||||
|
checked_impl!(CheckedSub, checked_sub, u32);
|
||||||
|
checked_impl!(CheckedSub, checked_sub, u64);
|
||||||
|
checked_impl!(CheckedSub, checked_sub, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedSub, checked_sub, u128);
|
||||||
|
|
||||||
|
checked_impl!(CheckedSub, checked_sub, i8);
|
||||||
|
checked_impl!(CheckedSub, checked_sub, i16);
|
||||||
|
checked_impl!(CheckedSub, checked_sub, i32);
|
||||||
|
checked_impl!(CheckedSub, checked_sub, i64);
|
||||||
|
checked_impl!(CheckedSub, checked_sub, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedSub, checked_sub, i128);
|
||||||
|
|
||||||
|
/// Performs multiplication that returns `None` instead of wrapping around on underflow or
|
||||||
|
/// overflow.
|
||||||
|
pub trait CheckedMul: Sized + Mul<Self, Output = Self> {
|
||||||
|
/// Multiplies two numbers, checking for underflow or overflow. If underflow
|
||||||
|
/// or overflow happens, `None` is returned.
|
||||||
|
fn checked_mul(&self, v: &Self) -> Option<Self>;
|
||||||
|
}
|
||||||
|
|
||||||
|
checked_impl!(CheckedMul, checked_mul, u8);
|
||||||
|
checked_impl!(CheckedMul, checked_mul, u16);
|
||||||
|
checked_impl!(CheckedMul, checked_mul, u32);
|
||||||
|
checked_impl!(CheckedMul, checked_mul, u64);
|
||||||
|
checked_impl!(CheckedMul, checked_mul, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedMul, checked_mul, u128);
|
||||||
|
|
||||||
|
checked_impl!(CheckedMul, checked_mul, i8);
|
||||||
|
checked_impl!(CheckedMul, checked_mul, i16);
|
||||||
|
checked_impl!(CheckedMul, checked_mul, i32);
|
||||||
|
checked_impl!(CheckedMul, checked_mul, i64);
|
||||||
|
checked_impl!(CheckedMul, checked_mul, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedMul, checked_mul, i128);
|
||||||
|
|
||||||
|
/// Performs division that returns `None` instead of panicking on division by zero and instead of
|
||||||
|
/// wrapping around on underflow and overflow.
|
||||||
|
pub trait CheckedDiv: Sized + Div<Self, Output = Self> {
|
||||||
|
/// Divides two numbers, checking for underflow, overflow and division by
|
||||||
|
/// zero. If any of that happens, `None` is returned.
|
||||||
|
fn checked_div(&self, v: &Self) -> Option<Self>;
|
||||||
|
}
|
||||||
|
|
||||||
|
checked_impl!(CheckedDiv, checked_div, u8);
|
||||||
|
checked_impl!(CheckedDiv, checked_div, u16);
|
||||||
|
checked_impl!(CheckedDiv, checked_div, u32);
|
||||||
|
checked_impl!(CheckedDiv, checked_div, u64);
|
||||||
|
checked_impl!(CheckedDiv, checked_div, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedDiv, checked_div, u128);
|
||||||
|
|
||||||
|
checked_impl!(CheckedDiv, checked_div, i8);
|
||||||
|
checked_impl!(CheckedDiv, checked_div, i16);
|
||||||
|
checked_impl!(CheckedDiv, checked_div, i32);
|
||||||
|
checked_impl!(CheckedDiv, checked_div, i64);
|
||||||
|
checked_impl!(CheckedDiv, checked_div, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedDiv, checked_div, i128);
|
||||||
|
|
||||||
|
/// Performs an integral remainder that returns `None` instead of panicking on division by zero and
|
||||||
|
/// instead of wrapping around on underflow and overflow.
|
||||||
|
pub trait CheckedRem: Sized + Rem<Self, Output = Self> {
|
||||||
|
/// Finds the remainder of dividing two numbers, checking for underflow, overflow and division
|
||||||
|
/// by zero. If any of that happens, `None` is returned.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::CheckedRem;
|
||||||
|
/// use std::i32::MIN;
|
||||||
|
///
|
||||||
|
/// assert_eq!(CheckedRem::checked_rem(&10, &7), Some(3));
|
||||||
|
/// assert_eq!(CheckedRem::checked_rem(&10, &-7), Some(3));
|
||||||
|
/// assert_eq!(CheckedRem::checked_rem(&-10, &7), Some(-3));
|
||||||
|
/// assert_eq!(CheckedRem::checked_rem(&-10, &-7), Some(-3));
|
||||||
|
///
|
||||||
|
/// assert_eq!(CheckedRem::checked_rem(&10, &0), None);
|
||||||
|
///
|
||||||
|
/// assert_eq!(CheckedRem::checked_rem(&MIN, &1), Some(0));
|
||||||
|
/// assert_eq!(CheckedRem::checked_rem(&MIN, &-1), None);
|
||||||
|
/// ```
|
||||||
|
fn checked_rem(&self, v: &Self) -> Option<Self>;
|
||||||
|
}
|
||||||
|
|
||||||
|
checked_impl!(CheckedRem, checked_rem, u8);
|
||||||
|
checked_impl!(CheckedRem, checked_rem, u16);
|
||||||
|
checked_impl!(CheckedRem, checked_rem, u32);
|
||||||
|
checked_impl!(CheckedRem, checked_rem, u64);
|
||||||
|
checked_impl!(CheckedRem, checked_rem, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedRem, checked_rem, u128);
|
||||||
|
|
||||||
|
checked_impl!(CheckedRem, checked_rem, i8);
|
||||||
|
checked_impl!(CheckedRem, checked_rem, i16);
|
||||||
|
checked_impl!(CheckedRem, checked_rem, i32);
|
||||||
|
checked_impl!(CheckedRem, checked_rem, i64);
|
||||||
|
checked_impl!(CheckedRem, checked_rem, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl!(CheckedRem, checked_rem, i128);
|
||||||
|
|
||||||
|
macro_rules! checked_impl_unary {
|
||||||
|
($trait_name:ident, $method:ident, $t:ty) => {
|
||||||
|
impl $trait_name for $t {
|
||||||
|
#[inline]
|
||||||
|
fn $method(&self) -> Option<$t> {
|
||||||
|
<$t>::$method(*self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Performs negation that returns `None` if the result can't be represented.
|
||||||
|
pub trait CheckedNeg: Sized {
|
||||||
|
/// Negates a number, returning `None` for results that can't be represented, like signed `MIN`
|
||||||
|
/// values that can't be positive, or non-zero unsigned values that can't be negative.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::CheckedNeg;
|
||||||
|
/// use std::i32::MIN;
|
||||||
|
///
|
||||||
|
/// assert_eq!(CheckedNeg::checked_neg(&1_i32), Some(-1));
|
||||||
|
/// assert_eq!(CheckedNeg::checked_neg(&-1_i32), Some(1));
|
||||||
|
/// assert_eq!(CheckedNeg::checked_neg(&MIN), None);
|
||||||
|
///
|
||||||
|
/// assert_eq!(CheckedNeg::checked_neg(&0_u32), Some(0));
|
||||||
|
/// assert_eq!(CheckedNeg::checked_neg(&1_u32), None);
|
||||||
|
/// ```
|
||||||
|
fn checked_neg(&self) -> Option<Self>;
|
||||||
|
}
|
||||||
|
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, u8);
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, u16);
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, u32);
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, u64);
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, u128);
|
||||||
|
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, i8);
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, i16);
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, i32);
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, i64);
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_impl_unary!(CheckedNeg, checked_neg, i128);
|
||||||
|
|
||||||
|
/// Performs a left shift that returns `None` on shifts larger than
|
||||||
|
/// the type width.
|
||||||
|
pub trait CheckedShl: Sized + Shl<u32, Output = Self> {
|
||||||
|
/// Checked shift left. Computes `self << rhs`, returning `None`
|
||||||
|
/// if `rhs` is larger than or equal to the number of bits in `self`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::CheckedShl;
|
||||||
|
///
|
||||||
|
/// let x: u16 = 0x0001;
|
||||||
|
///
|
||||||
|
/// assert_eq!(CheckedShl::checked_shl(&x, 0), Some(0x0001));
|
||||||
|
/// assert_eq!(CheckedShl::checked_shl(&x, 1), Some(0x0002));
|
||||||
|
/// assert_eq!(CheckedShl::checked_shl(&x, 15), Some(0x8000));
|
||||||
|
/// assert_eq!(CheckedShl::checked_shl(&x, 16), None);
|
||||||
|
/// ```
|
||||||
|
fn checked_shl(&self, rhs: u32) -> Option<Self>;
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! checked_shift_impl {
|
||||||
|
($trait_name:ident, $method:ident, $t:ty) => {
|
||||||
|
impl $trait_name for $t {
|
||||||
|
#[inline]
|
||||||
|
fn $method(&self, rhs: u32) -> Option<$t> {
|
||||||
|
<$t>::$method(*self, rhs)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, u8);
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, u16);
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, u32);
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, u64);
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, u128);
|
||||||
|
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, i8);
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, i16);
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, i32);
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, i64);
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_shift_impl!(CheckedShl, checked_shl, i128);
|
||||||
|
|
||||||
|
/// Performs a right shift that returns `None` on shifts larger than
|
||||||
|
/// the type width.
|
||||||
|
pub trait CheckedShr: Sized + Shr<u32, Output = Self> {
|
||||||
|
/// Checked shift right. Computes `self >> rhs`, returning `None`
|
||||||
|
/// if `rhs` is larger than or equal to the number of bits in `self`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::CheckedShr;
|
||||||
|
///
|
||||||
|
/// let x: u16 = 0x8000;
|
||||||
|
///
|
||||||
|
/// assert_eq!(CheckedShr::checked_shr(&x, 0), Some(0x8000));
|
||||||
|
/// assert_eq!(CheckedShr::checked_shr(&x, 1), Some(0x4000));
|
||||||
|
/// assert_eq!(CheckedShr::checked_shr(&x, 15), Some(0x0001));
|
||||||
|
/// assert_eq!(CheckedShr::checked_shr(&x, 16), None);
|
||||||
|
/// ```
|
||||||
|
fn checked_shr(&self, rhs: u32) -> Option<Self>;
|
||||||
|
}
|
||||||
|
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, u8);
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, u16);
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, u32);
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, u64);
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, u128);
|
||||||
|
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, i8);
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, i16);
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, i32);
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, i64);
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
checked_shift_impl!(CheckedShr, checked_shr, i128);
|
|
@ -0,0 +1,47 @@
|
||||||
|
/// Unary operator for retrieving the multiplicative inverse, or reciprocal, of a value.
|
||||||
|
pub trait Inv {
|
||||||
|
/// The result after applying the operator.
|
||||||
|
type Output;
|
||||||
|
|
||||||
|
/// Returns the multiplicative inverse of `self`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::f64::INFINITY;
|
||||||
|
/// use num_traits::Inv;
|
||||||
|
///
|
||||||
|
/// assert_eq!(7.0.inv() * 7.0, 1.0);
|
||||||
|
/// assert_eq!((-0.0).inv(), -INFINITY);
|
||||||
|
/// ```
|
||||||
|
fn inv(self) -> Self::Output;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Inv for f32 {
|
||||||
|
type Output = f32;
|
||||||
|
#[inline]
|
||||||
|
fn inv(self) -> f32 {
|
||||||
|
1.0 / self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl Inv for f64 {
|
||||||
|
type Output = f64;
|
||||||
|
#[inline]
|
||||||
|
fn inv(self) -> f64 {
|
||||||
|
1.0 / self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'a> Inv for &'a f32 {
|
||||||
|
type Output = f32;
|
||||||
|
#[inline]
|
||||||
|
fn inv(self) -> f32 {
|
||||||
|
1.0 / *self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'a> Inv for &'a f64 {
|
||||||
|
type Output = f64;
|
||||||
|
#[inline]
|
||||||
|
fn inv(self) -> f64 {
|
||||||
|
1.0 / *self
|
||||||
|
}
|
||||||
|
}
|
|
@ -1,3 +1,5 @@
|
||||||
pub mod saturating;
|
|
||||||
pub mod checked;
|
pub mod checked;
|
||||||
|
pub mod inv;
|
||||||
|
pub mod mul_add;
|
||||||
|
pub mod saturating;
|
||||||
pub mod wrapping;
|
pub mod wrapping;
|
|
@ -0,0 +1,151 @@
|
||||||
|
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
|
||||||
|
/// error, yielding a more accurate result than an unfused multiply-add.
|
||||||
|
///
|
||||||
|
/// Using `mul_add` can be more performant than an unfused multiply-add if
|
||||||
|
/// the target architecture has a dedicated `fma` CPU instruction.
|
||||||
|
///
|
||||||
|
/// Note that `A` and `B` are `Self` by default, but this is not mandatory.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::f32;
|
||||||
|
///
|
||||||
|
/// let m = 10.0_f32;
|
||||||
|
/// let x = 4.0_f32;
|
||||||
|
/// let b = 60.0_f32;
|
||||||
|
///
|
||||||
|
/// // 100.0
|
||||||
|
/// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference <= 100.0 * f32::EPSILON);
|
||||||
|
/// ```
|
||||||
|
pub trait MulAdd<A = Self, B = Self> {
|
||||||
|
/// The resulting type after applying the fused multiply-add.
|
||||||
|
type Output;
|
||||||
|
|
||||||
|
/// Performs the fused multiply-add operation.
|
||||||
|
fn mul_add(self, a: A, b: B) -> Self::Output;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The fused multiply-add assignment operation.
|
||||||
|
pub trait MulAddAssign<A = Self, B = Self> {
|
||||||
|
/// Performs the fused multiply-add operation.
|
||||||
|
fn mul_add_assign(&mut self, a: A, b: B);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(any(feature = "std", feature = "libm"))]
|
||||||
|
impl MulAdd<f32, f32> for f32 {
|
||||||
|
type Output = Self;
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn mul_add(self, a: Self, b: Self) -> Self::Output {
|
||||||
|
<Self as ::Float>::mul_add(self, a, b)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(any(feature = "std", feature = "libm"))]
|
||||||
|
impl MulAdd<f64, f64> for f64 {
|
||||||
|
type Output = Self;
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn mul_add(self, a: Self, b: Self) -> Self::Output {
|
||||||
|
<Self as ::Float>::mul_add(self, a, b)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! mul_add_impl {
|
||||||
|
($trait_name:ident for $($t:ty)*) => {$(
|
||||||
|
impl $trait_name for $t {
|
||||||
|
type Output = Self;
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn mul_add(self, a: Self, b: Self) -> Self::Output {
|
||||||
|
(self * a) + b
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
mul_add_impl!(MulAdd for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
mul_add_impl!(MulAdd for i128 u128);
|
||||||
|
|
||||||
|
#[cfg(any(feature = "std", feature = "libm"))]
|
||||||
|
impl MulAddAssign<f32, f32> for f32 {
|
||||||
|
#[inline]
|
||||||
|
fn mul_add_assign(&mut self, a: Self, b: Self) {
|
||||||
|
*self = <Self as ::Float>::mul_add(*self, a, b)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(any(feature = "std", feature = "libm"))]
|
||||||
|
impl MulAddAssign<f64, f64> for f64 {
|
||||||
|
#[inline]
|
||||||
|
fn mul_add_assign(&mut self, a: Self, b: Self) {
|
||||||
|
*self = <Self as ::Float>::mul_add(*self, a, b)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! mul_add_assign_impl {
|
||||||
|
($trait_name:ident for $($t:ty)*) => {$(
|
||||||
|
impl $trait_name for $t {
|
||||||
|
#[inline]
|
||||||
|
fn mul_add_assign(&mut self, a: Self, b: Self) {
|
||||||
|
*self = (*self * a) + b
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
mul_add_assign_impl!(MulAddAssign for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
mul_add_assign_impl!(MulAddAssign for i128 u128);
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn mul_add_integer() {
|
||||||
|
macro_rules! test_mul_add {
|
||||||
|
($($t:ident)+) => {
|
||||||
|
$(
|
||||||
|
{
|
||||||
|
let m: $t = 2;
|
||||||
|
let x: $t = 3;
|
||||||
|
let b: $t = 4;
|
||||||
|
|
||||||
|
assert_eq!(MulAdd::mul_add(m, x, b), (m*x + b));
|
||||||
|
}
|
||||||
|
)+
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
test_mul_add!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
fn mul_add_float() {
|
||||||
|
macro_rules! test_mul_add {
|
||||||
|
($($t:ident)+) => {
|
||||||
|
$(
|
||||||
|
{
|
||||||
|
use core::$t;
|
||||||
|
|
||||||
|
let m: $t = 12.0;
|
||||||
|
let x: $t = 3.4;
|
||||||
|
let b: $t = 5.6;
|
||||||
|
|
||||||
|
let abs_difference = (MulAdd::mul_add(m, x, b) - (m*x + b)).abs();
|
||||||
|
|
||||||
|
assert!(abs_difference <= 46.4 * $t::EPSILON);
|
||||||
|
}
|
||||||
|
)+
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
test_mul_add!(f32 f64);
|
||||||
|
}
|
||||||
|
}
|
|
@ -26,3 +26,5 @@ macro_rules! saturating_impl {
|
||||||
}
|
}
|
||||||
|
|
||||||
saturating_impl!(Saturating for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
|
saturating_impl!(Saturating for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
saturating_impl!(Saturating for i128 u128);
|
|
@ -0,0 +1,272 @@
|
||||||
|
use core::num::Wrapping;
|
||||||
|
use core::ops::{Add, Mul, Shl, Shr, Sub};
|
||||||
|
|
||||||
|
macro_rules! wrapping_impl {
|
||||||
|
($trait_name:ident, $method:ident, $t:ty) => {
|
||||||
|
impl $trait_name for $t {
|
||||||
|
#[inline]
|
||||||
|
fn $method(&self, v: &Self) -> Self {
|
||||||
|
<$t>::$method(*self, *v)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
($trait_name:ident, $method:ident, $t:ty, $rhs:ty) => {
|
||||||
|
impl $trait_name<$rhs> for $t {
|
||||||
|
#[inline]
|
||||||
|
fn $method(&self, v: &$rhs) -> Self {
|
||||||
|
<$t>::$method(*self, *v)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Performs addition that wraps around on overflow.
|
||||||
|
pub trait WrappingAdd: Sized + Add<Self, Output = Self> {
|
||||||
|
/// Wrapping (modular) addition. Computes `self + other`, wrapping around at the boundary of
|
||||||
|
/// the type.
|
||||||
|
fn wrapping_add(&self, v: &Self) -> Self;
|
||||||
|
}
|
||||||
|
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, u8);
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, u16);
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, u32);
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, u64);
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, u128);
|
||||||
|
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, i8);
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, i16);
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, i32);
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, i64);
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_impl!(WrappingAdd, wrapping_add, i128);
|
||||||
|
|
||||||
|
/// Performs subtraction that wraps around on overflow.
|
||||||
|
pub trait WrappingSub: Sized + Sub<Self, Output = Self> {
|
||||||
|
/// Wrapping (modular) subtraction. Computes `self - other`, wrapping around at the boundary
|
||||||
|
/// of the type.
|
||||||
|
fn wrapping_sub(&self, v: &Self) -> Self;
|
||||||
|
}
|
||||||
|
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, u8);
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, u16);
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, u32);
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, u64);
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, u128);
|
||||||
|
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, i8);
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, i16);
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, i32);
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, i64);
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_impl!(WrappingSub, wrapping_sub, i128);
|
||||||
|
|
||||||
|
/// Performs multiplication that wraps around on overflow.
|
||||||
|
pub trait WrappingMul: Sized + Mul<Self, Output = Self> {
|
||||||
|
/// Wrapping (modular) multiplication. Computes `self * other`, wrapping around at the boundary
|
||||||
|
/// of the type.
|
||||||
|
fn wrapping_mul(&self, v: &Self) -> Self;
|
||||||
|
}
|
||||||
|
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, u8);
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, u16);
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, u32);
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, u64);
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, u128);
|
||||||
|
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, i8);
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, i16);
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, i32);
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, i64);
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_impl!(WrappingMul, wrapping_mul, i128);
|
||||||
|
|
||||||
|
macro_rules! wrapping_shift_impl {
|
||||||
|
($trait_name:ident, $method:ident, $t:ty) => {
|
||||||
|
impl $trait_name for $t {
|
||||||
|
#[inline]
|
||||||
|
fn $method(&self, rhs: u32) -> $t {
|
||||||
|
<$t>::$method(*self, rhs)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Performs a left shift that does not panic.
|
||||||
|
pub trait WrappingShl: Sized + Shl<usize, Output = Self> {
|
||||||
|
/// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
|
||||||
|
/// where `mask` removes any high order bits of `rhs` that would
|
||||||
|
/// cause the shift to exceed the bitwidth of the type.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::WrappingShl;
|
||||||
|
///
|
||||||
|
/// let x: u16 = 0x0001;
|
||||||
|
///
|
||||||
|
/// assert_eq!(WrappingShl::wrapping_shl(&x, 0), 0x0001);
|
||||||
|
/// assert_eq!(WrappingShl::wrapping_shl(&x, 1), 0x0002);
|
||||||
|
/// assert_eq!(WrappingShl::wrapping_shl(&x, 15), 0x8000);
|
||||||
|
/// assert_eq!(WrappingShl::wrapping_shl(&x, 16), 0x0001);
|
||||||
|
/// ```
|
||||||
|
fn wrapping_shl(&self, rhs: u32) -> Self;
|
||||||
|
}
|
||||||
|
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, u8);
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, u16);
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, u32);
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, u64);
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, u128);
|
||||||
|
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, i8);
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, i16);
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, i32);
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, i64);
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_shift_impl!(WrappingShl, wrapping_shl, i128);
|
||||||
|
|
||||||
|
/// Performs a right shift that does not panic.
|
||||||
|
pub trait WrappingShr: Sized + Shr<usize, Output = Self> {
|
||||||
|
/// Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
|
||||||
|
/// where `mask` removes any high order bits of `rhs` that would
|
||||||
|
/// cause the shift to exceed the bitwidth of the type.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::WrappingShr;
|
||||||
|
///
|
||||||
|
/// let x: u16 = 0x8000;
|
||||||
|
///
|
||||||
|
/// assert_eq!(WrappingShr::wrapping_shr(&x, 0), 0x8000);
|
||||||
|
/// assert_eq!(WrappingShr::wrapping_shr(&x, 1), 0x4000);
|
||||||
|
/// assert_eq!(WrappingShr::wrapping_shr(&x, 15), 0x0001);
|
||||||
|
/// assert_eq!(WrappingShr::wrapping_shr(&x, 16), 0x8000);
|
||||||
|
/// ```
|
||||||
|
fn wrapping_shr(&self, rhs: u32) -> Self;
|
||||||
|
}
|
||||||
|
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, u8);
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, u16);
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, u32);
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, u64);
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, usize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, u128);
|
||||||
|
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, i8);
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, i16);
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, i32);
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, i64);
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, isize);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
wrapping_shift_impl!(WrappingShr, wrapping_shr, i128);
|
||||||
|
|
||||||
|
// Well this is a bit funny, but all the more appropriate.
|
||||||
|
impl<T: WrappingAdd> WrappingAdd for Wrapping<T>
|
||||||
|
where
|
||||||
|
Wrapping<T>: Add<Output = Wrapping<T>>,
|
||||||
|
{
|
||||||
|
fn wrapping_add(&self, v: &Self) -> Self {
|
||||||
|
Wrapping(self.0.wrapping_add(&v.0))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<T: WrappingSub> WrappingSub for Wrapping<T>
|
||||||
|
where
|
||||||
|
Wrapping<T>: Sub<Output = Wrapping<T>>,
|
||||||
|
{
|
||||||
|
fn wrapping_sub(&self, v: &Self) -> Self {
|
||||||
|
Wrapping(self.0.wrapping_sub(&v.0))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<T: WrappingMul> WrappingMul for Wrapping<T>
|
||||||
|
where
|
||||||
|
Wrapping<T>: Mul<Output = Wrapping<T>>,
|
||||||
|
{
|
||||||
|
fn wrapping_mul(&self, v: &Self) -> Self {
|
||||||
|
Wrapping(self.0.wrapping_mul(&v.0))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<T: WrappingShl> WrappingShl for Wrapping<T>
|
||||||
|
where
|
||||||
|
Wrapping<T>: Shl<usize, Output = Wrapping<T>>,
|
||||||
|
{
|
||||||
|
fn wrapping_shl(&self, rhs: u32) -> Self {
|
||||||
|
Wrapping(self.0.wrapping_shl(rhs))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<T: WrappingShr> WrappingShr for Wrapping<T>
|
||||||
|
where
|
||||||
|
Wrapping<T>: Shr<usize, Output = Wrapping<T>>,
|
||||||
|
{
|
||||||
|
fn wrapping_shr(&self, rhs: u32) -> Self {
|
||||||
|
Wrapping(self.0.wrapping_shr(rhs))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_wrapping_traits() {
|
||||||
|
fn wrapping_add<T: WrappingAdd>(a: T, b: T) -> T {
|
||||||
|
a.wrapping_add(&b)
|
||||||
|
}
|
||||||
|
fn wrapping_sub<T: WrappingSub>(a: T, b: T) -> T {
|
||||||
|
a.wrapping_sub(&b)
|
||||||
|
}
|
||||||
|
fn wrapping_mul<T: WrappingMul>(a: T, b: T) -> T {
|
||||||
|
a.wrapping_mul(&b)
|
||||||
|
}
|
||||||
|
fn wrapping_shl<T: WrappingShl>(a: T, b: u32) -> T {
|
||||||
|
a.wrapping_shl(b)
|
||||||
|
}
|
||||||
|
fn wrapping_shr<T: WrappingShr>(a: T, b: u32) -> T {
|
||||||
|
a.wrapping_shr(b)
|
||||||
|
}
|
||||||
|
assert_eq!(wrapping_add(255, 1), 0u8);
|
||||||
|
assert_eq!(wrapping_sub(0, 1), 255u8);
|
||||||
|
assert_eq!(wrapping_mul(255, 2), 254u8);
|
||||||
|
assert_eq!(wrapping_shl(255, 8), 255u8);
|
||||||
|
assert_eq!(wrapping_shr(255, 8), 255u8);
|
||||||
|
assert_eq!(wrapping_add(255, 1), (Wrapping(255u8) + Wrapping(1u8)).0);
|
||||||
|
assert_eq!(wrapping_sub(0, 1), (Wrapping(0u8) - Wrapping(1u8)).0);
|
||||||
|
assert_eq!(wrapping_mul(255, 2), (Wrapping(255u8) * Wrapping(2u8)).0);
|
||||||
|
assert_eq!(wrapping_shl(255, 8), (Wrapping(255u8) << 8).0);
|
||||||
|
assert_eq!(wrapping_shr(255, 8), (Wrapping(255u8) >> 8).0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_wrappingadd() {
|
||||||
|
fn require_wrappingadd<T: WrappingAdd>(_: &T) {}
|
||||||
|
require_wrappingadd(&Wrapping(42));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_wrappingsub() {
|
||||||
|
fn require_wrappingsub<T: WrappingSub>(_: &T) {}
|
||||||
|
require_wrappingsub(&Wrapping(42));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_wrappingmul() {
|
||||||
|
fn require_wrappingmul<T: WrappingMul>(_: &T) {}
|
||||||
|
require_wrappingmul(&Wrapping(42));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_wrappingshl() {
|
||||||
|
fn require_wrappingshl<T: WrappingShl>(_: &T) {}
|
||||||
|
require_wrappingshl(&Wrapping(42));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_wrappingshr() {
|
||||||
|
fn require_wrappingshr<T: WrappingShr>(_: &T) {}
|
||||||
|
require_wrappingshr(&Wrapping(42));
|
||||||
|
}
|
|
@ -0,0 +1,262 @@
|
||||||
|
use core::num::Wrapping;
|
||||||
|
use core::ops::Mul;
|
||||||
|
use {CheckedMul, One};
|
||||||
|
|
||||||
|
/// Binary operator for raising a value to a power.
|
||||||
|
pub trait Pow<RHS> {
|
||||||
|
/// The result after applying the operator.
|
||||||
|
type Output;
|
||||||
|
|
||||||
|
/// Returns `self` to the power `rhs`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::Pow;
|
||||||
|
/// assert_eq!(Pow::pow(10u32, 2u32), 100);
|
||||||
|
/// ```
|
||||||
|
fn pow(self, rhs: RHS) -> Self::Output;
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! pow_impl {
|
||||||
|
($t:ty) => {
|
||||||
|
pow_impl!($t, u8);
|
||||||
|
pow_impl!($t, usize);
|
||||||
|
|
||||||
|
// FIXME: these should be possible
|
||||||
|
// pow_impl!($t, u16);
|
||||||
|
// pow_impl!($t, u32);
|
||||||
|
// pow_impl!($t, u64);
|
||||||
|
};
|
||||||
|
($t:ty, $rhs:ty) => {
|
||||||
|
pow_impl!($t, $rhs, usize, pow);
|
||||||
|
};
|
||||||
|
($t:ty, $rhs:ty, $desired_rhs:ty, $method:expr) => {
|
||||||
|
impl Pow<$rhs> for $t {
|
||||||
|
type Output = $t;
|
||||||
|
#[inline]
|
||||||
|
fn pow(self, rhs: $rhs) -> $t {
|
||||||
|
($method)(self, <$desired_rhs>::from(rhs))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Pow<&'a $rhs> for $t {
|
||||||
|
type Output = $t;
|
||||||
|
#[inline]
|
||||||
|
fn pow(self, rhs: &'a $rhs) -> $t {
|
||||||
|
($method)(self, <$desired_rhs>::from(*rhs))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Pow<$rhs> for &'a $t {
|
||||||
|
type Output = $t;
|
||||||
|
#[inline]
|
||||||
|
fn pow(self, rhs: $rhs) -> $t {
|
||||||
|
($method)(*self, <$desired_rhs>::from(rhs))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, 'b> Pow<&'a $rhs> for &'b $t {
|
||||||
|
type Output = $t;
|
||||||
|
#[inline]
|
||||||
|
fn pow(self, rhs: &'a $rhs) -> $t {
|
||||||
|
($method)(*self, <$desired_rhs>::from(*rhs))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
pow_impl!(u8, u8, u32, u8::pow);
|
||||||
|
pow_impl!(u8, u16, u32, u8::pow);
|
||||||
|
pow_impl!(u8, u32, u32, u8::pow);
|
||||||
|
pow_impl!(u8, usize);
|
||||||
|
pow_impl!(i8, u8, u32, i8::pow);
|
||||||
|
pow_impl!(i8, u16, u32, i8::pow);
|
||||||
|
pow_impl!(i8, u32, u32, i8::pow);
|
||||||
|
pow_impl!(i8, usize);
|
||||||
|
pow_impl!(u16, u8, u32, u16::pow);
|
||||||
|
pow_impl!(u16, u16, u32, u16::pow);
|
||||||
|
pow_impl!(u16, u32, u32, u16::pow);
|
||||||
|
pow_impl!(u16, usize);
|
||||||
|
pow_impl!(i16, u8, u32, i16::pow);
|
||||||
|
pow_impl!(i16, u16, u32, i16::pow);
|
||||||
|
pow_impl!(i16, u32, u32, i16::pow);
|
||||||
|
pow_impl!(i16, usize);
|
||||||
|
pow_impl!(u32, u8, u32, u32::pow);
|
||||||
|
pow_impl!(u32, u16, u32, u32::pow);
|
||||||
|
pow_impl!(u32, u32, u32, u32::pow);
|
||||||
|
pow_impl!(u32, usize);
|
||||||
|
pow_impl!(i32, u8, u32, i32::pow);
|
||||||
|
pow_impl!(i32, u16, u32, i32::pow);
|
||||||
|
pow_impl!(i32, u32, u32, i32::pow);
|
||||||
|
pow_impl!(i32, usize);
|
||||||
|
pow_impl!(u64, u8, u32, u64::pow);
|
||||||
|
pow_impl!(u64, u16, u32, u64::pow);
|
||||||
|
pow_impl!(u64, u32, u32, u64::pow);
|
||||||
|
pow_impl!(u64, usize);
|
||||||
|
pow_impl!(i64, u8, u32, i64::pow);
|
||||||
|
pow_impl!(i64, u16, u32, i64::pow);
|
||||||
|
pow_impl!(i64, u32, u32, i64::pow);
|
||||||
|
pow_impl!(i64, usize);
|
||||||
|
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(u128, u8, u32, u128::pow);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(u128, u16, u32, u128::pow);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(u128, u32, u32, u128::pow);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(u128, usize);
|
||||||
|
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(i128, u8, u32, i128::pow);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(i128, u16, u32, i128::pow);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(i128, u32, u32, i128::pow);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(i128, usize);
|
||||||
|
|
||||||
|
pow_impl!(usize, u8, u32, usize::pow);
|
||||||
|
pow_impl!(usize, u16, u32, usize::pow);
|
||||||
|
pow_impl!(usize, u32, u32, usize::pow);
|
||||||
|
pow_impl!(usize, usize);
|
||||||
|
pow_impl!(isize, u8, u32, isize::pow);
|
||||||
|
pow_impl!(isize, u16, u32, isize::pow);
|
||||||
|
pow_impl!(isize, u32, u32, isize::pow);
|
||||||
|
pow_impl!(isize, usize);
|
||||||
|
pow_impl!(Wrapping<u8>);
|
||||||
|
pow_impl!(Wrapping<i8>);
|
||||||
|
pow_impl!(Wrapping<u16>);
|
||||||
|
pow_impl!(Wrapping<i16>);
|
||||||
|
pow_impl!(Wrapping<u32>);
|
||||||
|
pow_impl!(Wrapping<i32>);
|
||||||
|
pow_impl!(Wrapping<u64>);
|
||||||
|
pow_impl!(Wrapping<i64>);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(Wrapping<u128>);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
pow_impl!(Wrapping<i128>);
|
||||||
|
pow_impl!(Wrapping<usize>);
|
||||||
|
pow_impl!(Wrapping<isize>);
|
||||||
|
|
||||||
|
// FIXME: these should be possible
|
||||||
|
// pow_impl!(u8, u64);
|
||||||
|
// pow_impl!(i16, u64);
|
||||||
|
// pow_impl!(i8, u64);
|
||||||
|
// pow_impl!(u16, u64);
|
||||||
|
// pow_impl!(u32, u64);
|
||||||
|
// pow_impl!(i32, u64);
|
||||||
|
// pow_impl!(u64, u64);
|
||||||
|
// pow_impl!(i64, u64);
|
||||||
|
// pow_impl!(usize, u64);
|
||||||
|
// pow_impl!(isize, u64);
|
||||||
|
|
||||||
|
#[cfg(any(feature = "std", feature = "libm"))]
|
||||||
|
mod float_impls {
|
||||||
|
use super::Pow;
|
||||||
|
use Float;
|
||||||
|
|
||||||
|
pow_impl!(f32, i8, i32, <f32 as Float>::powi);
|
||||||
|
pow_impl!(f32, u8, i32, <f32 as Float>::powi);
|
||||||
|
pow_impl!(f32, i16, i32, <f32 as Float>::powi);
|
||||||
|
pow_impl!(f32, u16, i32, <f32 as Float>::powi);
|
||||||
|
pow_impl!(f32, i32, i32, <f32 as Float>::powi);
|
||||||
|
pow_impl!(f64, i8, i32, <f64 as Float>::powi);
|
||||||
|
pow_impl!(f64, u8, i32, <f64 as Float>::powi);
|
||||||
|
pow_impl!(f64, i16, i32, <f64 as Float>::powi);
|
||||||
|
pow_impl!(f64, u16, i32, <f64 as Float>::powi);
|
||||||
|
pow_impl!(f64, i32, i32, <f64 as Float>::powi);
|
||||||
|
pow_impl!(f32, f32, f32, <f32 as Float>::powf);
|
||||||
|
pow_impl!(f64, f32, f64, <f64 as Float>::powf);
|
||||||
|
pow_impl!(f64, f64, f64, <f64 as Float>::powf);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Raises a value to the power of exp, using exponentiation by squaring.
|
||||||
|
///
|
||||||
|
/// Note that `0⁰` (`pow(0, 0)`) returns `1`. Mathematically this is undefined.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// use num_traits::pow;
|
||||||
|
///
|
||||||
|
/// assert_eq!(pow(2i8, 4), 16);
|
||||||
|
/// assert_eq!(pow(6u8, 3), 216);
|
||||||
|
/// assert_eq!(pow(0u8, 0), 1); // Be aware if this case affects you
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn pow<T: Clone + One + Mul<T, Output = T>>(mut base: T, mut exp: usize) -> T {
|
||||||
|
if exp == 0 {
|
||||||
|
return T::one();
|
||||||
|
}
|
||||||
|
|
||||||
|
while exp & 1 == 0 {
|
||||||
|
base = base.clone() * base;
|
||||||
|
exp >>= 1;
|
||||||
|
}
|
||||||
|
if exp == 1 {
|
||||||
|
return base;
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut acc = base.clone();
|
||||||
|
while exp > 1 {
|
||||||
|
exp >>= 1;
|
||||||
|
base = base.clone() * base;
|
||||||
|
if exp & 1 == 1 {
|
||||||
|
acc = acc * base.clone();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
acc
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Raises a value to the power of exp, returning `None` if an overflow occurred.
|
||||||
|
///
|
||||||
|
/// Note that `0⁰` (`checked_pow(0, 0)`) returns `Some(1)`. Mathematically this is undefined.
|
||||||
|
///
|
||||||
|
/// Otherwise same as the `pow` function.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// use num_traits::checked_pow;
|
||||||
|
///
|
||||||
|
/// assert_eq!(checked_pow(2i8, 4), Some(16));
|
||||||
|
/// assert_eq!(checked_pow(7i8, 8), None);
|
||||||
|
/// assert_eq!(checked_pow(7u32, 8), Some(5_764_801));
|
||||||
|
/// assert_eq!(checked_pow(0u32, 0), Some(1)); // Be aware if this case affect you
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn checked_pow<T: Clone + One + CheckedMul>(mut base: T, mut exp: usize) -> Option<T> {
|
||||||
|
if exp == 0 {
|
||||||
|
return Some(T::one());
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! optry {
|
||||||
|
($expr:expr) => {
|
||||||
|
if let Some(val) = $expr {
|
||||||
|
val
|
||||||
|
} else {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
while exp & 1 == 0 {
|
||||||
|
base = optry!(base.checked_mul(&base));
|
||||||
|
exp >>= 1;
|
||||||
|
}
|
||||||
|
if exp == 1 {
|
||||||
|
return Some(base);
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut acc = base.clone();
|
||||||
|
while exp > 1 {
|
||||||
|
exp >>= 1;
|
||||||
|
base = optry!(base.checked_mul(&base));
|
||||||
|
if exp & 1 == 1 {
|
||||||
|
acc = optry!(acc.checked_mul(&base));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Some(acc)
|
||||||
|
}
|
|
@ -0,0 +1,834 @@
|
||||||
|
#![cfg(any(feature = "std", feature = "libm"))]
|
||||||
|
|
||||||
|
use core::ops::Neg;
|
||||||
|
|
||||||
|
use {Float, Num, NumCast};
|
||||||
|
|
||||||
|
// NOTE: These doctests have the same issue as those in src/float.rs.
|
||||||
|
// They're testing the inherent methods directly, and not those of `Real`.
|
||||||
|
|
||||||
|
/// A trait for real number types that do not necessarily have
|
||||||
|
/// floating-point-specific characteristics such as NaN and infinity.
|
||||||
|
///
|
||||||
|
/// See [this Wikipedia article](https://en.wikipedia.org/wiki/Real_data_type)
|
||||||
|
/// for a list of data types that could meaningfully implement this trait.
|
||||||
|
///
|
||||||
|
/// This trait is only available with the `std` feature, or with the `libm` feature otherwise.
|
||||||
|
pub trait Real: Num + Copy + NumCast + PartialOrd + Neg<Output = Self> {
|
||||||
|
/// Returns the smallest finite value that this type can represent.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x: f64 = Real::min_value();
|
||||||
|
///
|
||||||
|
/// assert_eq!(x, f64::MIN);
|
||||||
|
/// ```
|
||||||
|
fn min_value() -> Self;
|
||||||
|
|
||||||
|
/// Returns the smallest positive, normalized value that this type can represent.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x: f64 = Real::min_positive_value();
|
||||||
|
///
|
||||||
|
/// assert_eq!(x, f64::MIN_POSITIVE);
|
||||||
|
/// ```
|
||||||
|
fn min_positive_value() -> Self;
|
||||||
|
|
||||||
|
/// Returns epsilon, a small positive value.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x: f64 = Real::epsilon();
|
||||||
|
///
|
||||||
|
/// assert_eq!(x, f64::EPSILON);
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// # Panics
|
||||||
|
///
|
||||||
|
/// The default implementation will panic if `f32::EPSILON` cannot
|
||||||
|
/// be cast to `Self`.
|
||||||
|
fn epsilon() -> Self;
|
||||||
|
|
||||||
|
/// Returns the largest finite value that this type can represent.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x: f64 = Real::max_value();
|
||||||
|
/// assert_eq!(x, f64::MAX);
|
||||||
|
/// ```
|
||||||
|
fn max_value() -> Self;
|
||||||
|
|
||||||
|
/// Returns the largest integer less than or equal to a number.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let f = 3.99;
|
||||||
|
/// let g = 3.0;
|
||||||
|
///
|
||||||
|
/// assert_eq!(f.floor(), 3.0);
|
||||||
|
/// assert_eq!(g.floor(), 3.0);
|
||||||
|
/// ```
|
||||||
|
fn floor(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns the smallest integer greater than or equal to a number.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let f = 3.01;
|
||||||
|
/// let g = 4.0;
|
||||||
|
///
|
||||||
|
/// assert_eq!(f.ceil(), 4.0);
|
||||||
|
/// assert_eq!(g.ceil(), 4.0);
|
||||||
|
/// ```
|
||||||
|
fn ceil(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns the nearest integer to a number. Round half-way cases away from
|
||||||
|
/// `0.0`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let f = 3.3;
|
||||||
|
/// let g = -3.3;
|
||||||
|
///
|
||||||
|
/// assert_eq!(f.round(), 3.0);
|
||||||
|
/// assert_eq!(g.round(), -3.0);
|
||||||
|
/// ```
|
||||||
|
fn round(self) -> Self;
|
||||||
|
|
||||||
|
/// Return the integer part of a number.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let f = 3.3;
|
||||||
|
/// let g = -3.7;
|
||||||
|
///
|
||||||
|
/// assert_eq!(f.trunc(), 3.0);
|
||||||
|
/// assert_eq!(g.trunc(), -3.0);
|
||||||
|
/// ```
|
||||||
|
fn trunc(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns the fractional part of a number.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 3.5;
|
||||||
|
/// let y = -3.5;
|
||||||
|
/// let abs_difference_x = (x.fract() - 0.5).abs();
|
||||||
|
/// let abs_difference_y = (y.fract() - (-0.5)).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference_x < 1e-10);
|
||||||
|
/// assert!(abs_difference_y < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn fract(self) -> Self;
|
||||||
|
|
||||||
|
/// Computes the absolute value of `self`. Returns `Float::nan()` if the
|
||||||
|
/// number is `Float::nan()`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x = 3.5;
|
||||||
|
/// let y = -3.5;
|
||||||
|
///
|
||||||
|
/// let abs_difference_x = (x.abs() - x).abs();
|
||||||
|
/// let abs_difference_y = (y.abs() - (-y)).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference_x < 1e-10);
|
||||||
|
/// assert!(abs_difference_y < 1e-10);
|
||||||
|
///
|
||||||
|
/// assert!(::num_traits::Float::is_nan(f64::NAN.abs()));
|
||||||
|
/// ```
|
||||||
|
fn abs(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns a number that represents the sign of `self`.
|
||||||
|
///
|
||||||
|
/// - `1.0` if the number is positive, `+0.0` or `Float::infinity()`
|
||||||
|
/// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()`
|
||||||
|
/// - `Float::nan()` if the number is `Float::nan()`
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let f = 3.5;
|
||||||
|
///
|
||||||
|
/// assert_eq!(f.signum(), 1.0);
|
||||||
|
/// assert_eq!(f64::NEG_INFINITY.signum(), -1.0);
|
||||||
|
///
|
||||||
|
/// assert!(f64::NAN.signum().is_nan());
|
||||||
|
/// ```
|
||||||
|
fn signum(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns `true` if `self` is positive, including `+0.0`,
|
||||||
|
/// `Float::infinity()`, and with newer versions of Rust `f64::NAN`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let neg_nan: f64 = -f64::NAN;
|
||||||
|
///
|
||||||
|
/// let f = 7.0;
|
||||||
|
/// let g = -7.0;
|
||||||
|
///
|
||||||
|
/// assert!(f.is_sign_positive());
|
||||||
|
/// assert!(!g.is_sign_positive());
|
||||||
|
/// assert!(!neg_nan.is_sign_positive());
|
||||||
|
/// ```
|
||||||
|
fn is_sign_positive(self) -> bool;
|
||||||
|
|
||||||
|
/// Returns `true` if `self` is negative, including `-0.0`,
|
||||||
|
/// `Float::neg_infinity()`, and with newer versions of Rust `-f64::NAN`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let nan: f64 = f64::NAN;
|
||||||
|
///
|
||||||
|
/// let f = 7.0;
|
||||||
|
/// let g = -7.0;
|
||||||
|
///
|
||||||
|
/// assert!(!f.is_sign_negative());
|
||||||
|
/// assert!(g.is_sign_negative());
|
||||||
|
/// assert!(!nan.is_sign_negative());
|
||||||
|
/// ```
|
||||||
|
fn is_sign_negative(self) -> bool;
|
||||||
|
|
||||||
|
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
|
||||||
|
/// error, yielding a more accurate result than an unfused multiply-add.
|
||||||
|
///
|
||||||
|
/// Using `mul_add` can be more performant than an unfused multiply-add if
|
||||||
|
/// the target architecture has a dedicated `fma` CPU instruction.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let m = 10.0;
|
||||||
|
/// let x = 4.0;
|
||||||
|
/// let b = 60.0;
|
||||||
|
///
|
||||||
|
/// // 100.0
|
||||||
|
/// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn mul_add(self, a: Self, b: Self) -> Self;
|
||||||
|
|
||||||
|
/// Take the reciprocal (inverse) of a number, `1/x`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 2.0;
|
||||||
|
/// let abs_difference = (x.recip() - (1.0/x)).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn recip(self) -> Self;
|
||||||
|
|
||||||
|
/// Raise a number to an integer power.
|
||||||
|
///
|
||||||
|
/// Using this function is generally faster than using `powf`
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 2.0;
|
||||||
|
/// let abs_difference = (x.powi(2) - x*x).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn powi(self, n: i32) -> Self;
|
||||||
|
|
||||||
|
/// Raise a number to a real number power.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 2.0;
|
||||||
|
/// let abs_difference = (x.powf(2.0) - x*x).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn powf(self, n: Self) -> Self;
|
||||||
|
|
||||||
|
/// Take the square root of a number.
|
||||||
|
///
|
||||||
|
/// Returns NaN if `self` is a negative floating-point number.
|
||||||
|
///
|
||||||
|
/// # Panics
|
||||||
|
///
|
||||||
|
/// If the implementing type doesn't support NaN, this method should panic if `self < 0`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let positive = 4.0;
|
||||||
|
/// let negative = -4.0;
|
||||||
|
///
|
||||||
|
/// let abs_difference = (positive.sqrt() - 2.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// assert!(::num_traits::Float::is_nan(negative.sqrt()));
|
||||||
|
/// ```
|
||||||
|
fn sqrt(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns `e^(self)`, (the exponential function).
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let one = 1.0;
|
||||||
|
/// // e^1
|
||||||
|
/// let e = one.exp();
|
||||||
|
///
|
||||||
|
/// // ln(e) - 1 == 0
|
||||||
|
/// let abs_difference = (e.ln() - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn exp(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns `2^(self)`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let f = 2.0;
|
||||||
|
///
|
||||||
|
/// // 2^2 - 4 == 0
|
||||||
|
/// let abs_difference = (f.exp2() - 4.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn exp2(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns the natural logarithm of the number.
|
||||||
|
///
|
||||||
|
/// # Panics
|
||||||
|
///
|
||||||
|
/// If `self <= 0` and this type does not support a NaN representation, this function should panic.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let one = 1.0;
|
||||||
|
/// // e^1
|
||||||
|
/// let e = one.exp();
|
||||||
|
///
|
||||||
|
/// // ln(e) - 1 == 0
|
||||||
|
/// let abs_difference = (e.ln() - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn ln(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns the logarithm of the number with respect to an arbitrary base.
|
||||||
|
///
|
||||||
|
/// # Panics
|
||||||
|
///
|
||||||
|
/// If `self <= 0` and this type does not support a NaN representation, this function should panic.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let ten = 10.0;
|
||||||
|
/// let two = 2.0;
|
||||||
|
///
|
||||||
|
/// // log10(10) - 1 == 0
|
||||||
|
/// let abs_difference_10 = (ten.log(10.0) - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// // log2(2) - 1 == 0
|
||||||
|
/// let abs_difference_2 = (two.log(2.0) - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference_10 < 1e-10);
|
||||||
|
/// assert!(abs_difference_2 < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn log(self, base: Self) -> Self;
|
||||||
|
|
||||||
|
/// Returns the base 2 logarithm of the number.
|
||||||
|
///
|
||||||
|
/// # Panics
|
||||||
|
///
|
||||||
|
/// If `self <= 0` and this type does not support a NaN representation, this function should panic.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let two = 2.0;
|
||||||
|
///
|
||||||
|
/// // log2(2) - 1 == 0
|
||||||
|
/// let abs_difference = (two.log2() - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn log2(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns the base 10 logarithm of the number.
|
||||||
|
///
|
||||||
|
/// # Panics
|
||||||
|
///
|
||||||
|
/// If `self <= 0` and this type does not support a NaN representation, this function should panic.
|
||||||
|
///
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let ten = 10.0;
|
||||||
|
///
|
||||||
|
/// // log10(10) - 1 == 0
|
||||||
|
/// let abs_difference = (ten.log10() - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn log10(self) -> Self;
|
||||||
|
|
||||||
|
/// Converts radians to degrees.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::f64::consts;
|
||||||
|
///
|
||||||
|
/// let angle = consts::PI;
|
||||||
|
///
|
||||||
|
/// let abs_difference = (angle.to_degrees() - 180.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn to_degrees(self) -> Self;
|
||||||
|
|
||||||
|
/// Converts degrees to radians.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::f64::consts;
|
||||||
|
///
|
||||||
|
/// let angle = 180.0_f64;
|
||||||
|
///
|
||||||
|
/// let abs_difference = (angle.to_radians() - consts::PI).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn to_radians(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns the maximum of the two numbers.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 1.0;
|
||||||
|
/// let y = 2.0;
|
||||||
|
///
|
||||||
|
/// assert_eq!(x.max(y), y);
|
||||||
|
/// ```
|
||||||
|
fn max(self, other: Self) -> Self;
|
||||||
|
|
||||||
|
/// Returns the minimum of the two numbers.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 1.0;
|
||||||
|
/// let y = 2.0;
|
||||||
|
///
|
||||||
|
/// assert_eq!(x.min(y), x);
|
||||||
|
/// ```
|
||||||
|
fn min(self, other: Self) -> Self;
|
||||||
|
|
||||||
|
/// The positive difference of two numbers.
|
||||||
|
///
|
||||||
|
/// * If `self <= other`: `0:0`
|
||||||
|
/// * Else: `self - other`
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 3.0;
|
||||||
|
/// let y = -3.0;
|
||||||
|
///
|
||||||
|
/// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();
|
||||||
|
/// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference_x < 1e-10);
|
||||||
|
/// assert!(abs_difference_y < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn abs_sub(self, other: Self) -> Self;
|
||||||
|
|
||||||
|
/// Take the cubic root of a number.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 8.0;
|
||||||
|
///
|
||||||
|
/// // x^(1/3) - 2 == 0
|
||||||
|
/// let abs_difference = (x.cbrt() - 2.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn cbrt(self) -> Self;
|
||||||
|
|
||||||
|
/// Calculate the length of the hypotenuse of a right-angle triangle given
|
||||||
|
/// legs of length `x` and `y`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 2.0;
|
||||||
|
/// let y = 3.0;
|
||||||
|
///
|
||||||
|
/// // sqrt(x^2 + y^2)
|
||||||
|
/// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn hypot(self, other: Self) -> Self;
|
||||||
|
|
||||||
|
/// Computes the sine of a number (in radians).
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x = f64::consts::PI/2.0;
|
||||||
|
///
|
||||||
|
/// let abs_difference = (x.sin() - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn sin(self) -> Self;
|
||||||
|
|
||||||
|
/// Computes the cosine of a number (in radians).
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x = 2.0*f64::consts::PI;
|
||||||
|
///
|
||||||
|
/// let abs_difference = (x.cos() - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn cos(self) -> Self;
|
||||||
|
|
||||||
|
/// Computes the tangent of a number (in radians).
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x = f64::consts::PI/4.0;
|
||||||
|
/// let abs_difference = (x.tan() - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-14);
|
||||||
|
/// ```
|
||||||
|
fn tan(self) -> Self;
|
||||||
|
|
||||||
|
/// Computes the arcsine of a number. Return value is in radians in
|
||||||
|
/// the range [-pi/2, pi/2] or NaN if the number is outside the range
|
||||||
|
/// [-1, 1].
|
||||||
|
///
|
||||||
|
/// # Panics
|
||||||
|
///
|
||||||
|
/// If this type does not support a NaN representation, this function should panic
|
||||||
|
/// if the number is outside the range [-1, 1].
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let f = f64::consts::PI / 2.0;
|
||||||
|
///
|
||||||
|
/// // asin(sin(pi/2))
|
||||||
|
/// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn asin(self) -> Self;
|
||||||
|
|
||||||
|
/// Computes the arccosine of a number. Return value is in radians in
|
||||||
|
/// the range [0, pi] or NaN if the number is outside the range
|
||||||
|
/// [-1, 1].
|
||||||
|
///
|
||||||
|
/// # Panics
|
||||||
|
///
|
||||||
|
/// If this type does not support a NaN representation, this function should panic
|
||||||
|
/// if the number is outside the range [-1, 1].
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let f = f64::consts::PI / 4.0;
|
||||||
|
///
|
||||||
|
/// // acos(cos(pi/4))
|
||||||
|
/// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn acos(self) -> Self;
|
||||||
|
|
||||||
|
/// Computes the arctangent of a number. Return value is in radians in the
|
||||||
|
/// range [-pi/2, pi/2];
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let f = 1.0;
|
||||||
|
///
|
||||||
|
/// // atan(tan(1))
|
||||||
|
/// let abs_difference = (f.tan().atan() - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn atan(self) -> Self;
|
||||||
|
|
||||||
|
/// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`).
|
||||||
|
///
|
||||||
|
/// * `x = 0`, `y = 0`: `0`
|
||||||
|
/// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
|
||||||
|
/// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
|
||||||
|
/// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let pi = f64::consts::PI;
|
||||||
|
/// // All angles from horizontal right (+x)
|
||||||
|
/// // 45 deg counter-clockwise
|
||||||
|
/// let x1 = 3.0;
|
||||||
|
/// let y1 = -3.0;
|
||||||
|
///
|
||||||
|
/// // 135 deg clockwise
|
||||||
|
/// let x2 = -3.0;
|
||||||
|
/// let y2 = 3.0;
|
||||||
|
///
|
||||||
|
/// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs();
|
||||||
|
/// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference_1 < 1e-10);
|
||||||
|
/// assert!(abs_difference_2 < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn atan2(self, other: Self) -> Self;
|
||||||
|
|
||||||
|
/// Simultaneously computes the sine and cosine of the number, `x`. Returns
|
||||||
|
/// `(sin(x), cos(x))`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x = f64::consts::PI/4.0;
|
||||||
|
/// let f = x.sin_cos();
|
||||||
|
///
|
||||||
|
/// let abs_difference_0 = (f.0 - x.sin()).abs();
|
||||||
|
/// let abs_difference_1 = (f.1 - x.cos()).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference_0 < 1e-10);
|
||||||
|
/// assert!(abs_difference_0 < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn sin_cos(self) -> (Self, Self);
|
||||||
|
|
||||||
|
/// Returns `e^(self) - 1` in a way that is accurate even if the
|
||||||
|
/// number is close to zero.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 7.0;
|
||||||
|
///
|
||||||
|
/// // e^(ln(7)) - 1
|
||||||
|
/// let abs_difference = (x.ln().exp_m1() - 6.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn exp_m1(self) -> Self;
|
||||||
|
|
||||||
|
/// Returns `ln(1+n)` (natural logarithm) more accurately than if
|
||||||
|
/// the operations were performed separately.
|
||||||
|
///
|
||||||
|
/// # Panics
|
||||||
|
///
|
||||||
|
/// If this type does not support a NaN representation, this function should panic
|
||||||
|
/// if `self-1 <= 0`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let x = f64::consts::E - 1.0;
|
||||||
|
///
|
||||||
|
/// // ln(1 + (e - 1)) == ln(e) == 1
|
||||||
|
/// let abs_difference = (x.ln_1p() - 1.0).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn ln_1p(self) -> Self;
|
||||||
|
|
||||||
|
/// Hyperbolic sine function.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let e = f64::consts::E;
|
||||||
|
/// let x = 1.0;
|
||||||
|
///
|
||||||
|
/// let f = x.sinh();
|
||||||
|
/// // Solving sinh() at 1 gives `(e^2-1)/(2e)`
|
||||||
|
/// let g = (e*e - 1.0)/(2.0*e);
|
||||||
|
/// let abs_difference = (f - g).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1e-10);
|
||||||
|
/// ```
|
||||||
|
fn sinh(self) -> Self;
|
||||||
|
|
||||||
|
/// Hyperbolic cosine function.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let e = f64::consts::E;
|
||||||
|
/// let x = 1.0;
|
||||||
|
/// let f = x.cosh();
|
||||||
|
/// // Solving cosh() at 1 gives this result
|
||||||
|
/// let g = (e*e + 1.0)/(2.0*e);
|
||||||
|
/// let abs_difference = (f - g).abs();
|
||||||
|
///
|
||||||
|
/// // Same result
|
||||||
|
/// assert!(abs_difference < 1.0e-10);
|
||||||
|
/// ```
|
||||||
|
fn cosh(self) -> Self;
|
||||||
|
|
||||||
|
/// Hyperbolic tangent function.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let e = f64::consts::E;
|
||||||
|
/// let x = 1.0;
|
||||||
|
///
|
||||||
|
/// let f = x.tanh();
|
||||||
|
/// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))`
|
||||||
|
/// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2));
|
||||||
|
/// let abs_difference = (f - g).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1.0e-10);
|
||||||
|
/// ```
|
||||||
|
fn tanh(self) -> Self;
|
||||||
|
|
||||||
|
/// Inverse hyperbolic sine function.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 1.0;
|
||||||
|
/// let f = x.sinh().asinh();
|
||||||
|
///
|
||||||
|
/// let abs_difference = (f - x).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1.0e-10);
|
||||||
|
/// ```
|
||||||
|
fn asinh(self) -> Self;
|
||||||
|
|
||||||
|
/// Inverse hyperbolic cosine function.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
///
|
||||||
|
/// let x = 1.0;
|
||||||
|
/// let f = x.cosh().acosh();
|
||||||
|
///
|
||||||
|
/// let abs_difference = (f - x).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1.0e-10);
|
||||||
|
/// ```
|
||||||
|
fn acosh(self) -> Self;
|
||||||
|
|
||||||
|
/// Inverse hyperbolic tangent function.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use num_traits::real::Real;
|
||||||
|
/// use std::f64;
|
||||||
|
///
|
||||||
|
/// let e = f64::consts::E;
|
||||||
|
/// let f = e.tanh().atanh();
|
||||||
|
///
|
||||||
|
/// let abs_difference = (f - e).abs();
|
||||||
|
///
|
||||||
|
/// assert!(abs_difference < 1.0e-10);
|
||||||
|
/// ```
|
||||||
|
fn atanh(self) -> Self;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: Float> Real for T {
|
||||||
|
forward! {
|
||||||
|
Float::min_value() -> Self;
|
||||||
|
Float::min_positive_value() -> Self;
|
||||||
|
Float::epsilon() -> Self;
|
||||||
|
Float::max_value() -> Self;
|
||||||
|
}
|
||||||
|
forward! {
|
||||||
|
Float::floor(self) -> Self;
|
||||||
|
Float::ceil(self) -> Self;
|
||||||
|
Float::round(self) -> Self;
|
||||||
|
Float::trunc(self) -> Self;
|
||||||
|
Float::fract(self) -> Self;
|
||||||
|
Float::abs(self) -> Self;
|
||||||
|
Float::signum(self) -> Self;
|
||||||
|
Float::is_sign_positive(self) -> bool;
|
||||||
|
Float::is_sign_negative(self) -> bool;
|
||||||
|
Float::mul_add(self, a: Self, b: Self) -> Self;
|
||||||
|
Float::recip(self) -> Self;
|
||||||
|
Float::powi(self, n: i32) -> Self;
|
||||||
|
Float::powf(self, n: Self) -> Self;
|
||||||
|
Float::sqrt(self) -> Self;
|
||||||
|
Float::exp(self) -> Self;
|
||||||
|
Float::exp2(self) -> Self;
|
||||||
|
Float::ln(self) -> Self;
|
||||||
|
Float::log(self, base: Self) -> Self;
|
||||||
|
Float::log2(self) -> Self;
|
||||||
|
Float::log10(self) -> Self;
|
||||||
|
Float::to_degrees(self) -> Self;
|
||||||
|
Float::to_radians(self) -> Self;
|
||||||
|
Float::max(self, other: Self) -> Self;
|
||||||
|
Float::min(self, other: Self) -> Self;
|
||||||
|
Float::abs_sub(self, other: Self) -> Self;
|
||||||
|
Float::cbrt(self) -> Self;
|
||||||
|
Float::hypot(self, other: Self) -> Self;
|
||||||
|
Float::sin(self) -> Self;
|
||||||
|
Float::cos(self) -> Self;
|
||||||
|
Float::tan(self) -> Self;
|
||||||
|
Float::asin(self) -> Self;
|
||||||
|
Float::acos(self) -> Self;
|
||||||
|
Float::atan(self) -> Self;
|
||||||
|
Float::atan2(self, other: Self) -> Self;
|
||||||
|
Float::sin_cos(self) -> (Self, Self);
|
||||||
|
Float::exp_m1(self) -> Self;
|
||||||
|
Float::ln_1p(self) -> Self;
|
||||||
|
Float::sinh(self) -> Self;
|
||||||
|
Float::cosh(self) -> Self;
|
||||||
|
Float::tanh(self) -> Self;
|
||||||
|
Float::asinh(self) -> Self;
|
||||||
|
Float::acosh(self) -> Self;
|
||||||
|
Float::atanh(self) -> Self;
|
||||||
|
}
|
||||||
|
}
|
|
@ -1,7 +1,7 @@
|
||||||
use std::ops::Neg;
|
use core::num::Wrapping;
|
||||||
use std::{f32, f64};
|
use core::ops::Neg;
|
||||||
use std::num::Wrapping;
|
|
||||||
|
|
||||||
|
use float::FloatCore;
|
||||||
use Num;
|
use Num;
|
||||||
|
|
||||||
/// Useful functions for signed numbers (i.e. numbers that can be negative).
|
/// Useful functions for signed numbers (i.e. numbers that can be negative).
|
||||||
|
@ -74,7 +74,12 @@ macro_rules! signed_impl {
|
||||||
|
|
||||||
signed_impl!(isize i8 i16 i32 i64);
|
signed_impl!(isize i8 i16 i32 i64);
|
||||||
|
|
||||||
impl<T: Signed> Signed for Wrapping<T> where Wrapping<T>: Num + Neg<Output=Wrapping<T>>
|
#[cfg(has_i128)]
|
||||||
|
signed_impl!(i128);
|
||||||
|
|
||||||
|
impl<T: Signed> Signed for Wrapping<T>
|
||||||
|
where
|
||||||
|
Wrapping<T>: Num + Neg<Output = Wrapping<T>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn abs(&self) -> Self {
|
fn abs(&self) -> Self {
|
||||||
|
@ -92,28 +97,35 @@ impl<T: Signed> Signed for Wrapping<T> where Wrapping<T>: Num + Neg<Output=Wrapp
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn is_positive(&self) -> bool { self.0.is_positive() }
|
fn is_positive(&self) -> bool {
|
||||||
|
self.0.is_positive()
|
||||||
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn is_negative(&self) -> bool { self.0.is_negative() }
|
fn is_negative(&self) -> bool {
|
||||||
|
self.0.is_negative()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
macro_rules! signed_float_impl {
|
macro_rules! signed_float_impl {
|
||||||
($t:ty, $nan:expr, $inf:expr, $neg_inf:expr) => {
|
($t:ty) => {
|
||||||
impl Signed for $t {
|
impl Signed for $t {
|
||||||
/// Computes the absolute value. Returns `NAN` if the number is `NAN`.
|
/// Computes the absolute value. Returns `NAN` if the number is `NAN`.
|
||||||
#[inline]
|
#[inline]
|
||||||
fn abs(&self) -> $t {
|
fn abs(&self) -> $t {
|
||||||
<$t>::abs(*self)
|
FloatCore::abs(*self)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The positive difference of two numbers. Returns `0.0` if the number is
|
/// The positive difference of two numbers. Returns `0.0` if the number is
|
||||||
/// less than or equal to `other`, otherwise the difference between`self`
|
/// less than or equal to `other`, otherwise the difference between`self`
|
||||||
/// and `other` is returned.
|
/// and `other` is returned.
|
||||||
#[inline]
|
#[inline]
|
||||||
#[allow(deprecated)]
|
|
||||||
fn abs_sub(&self, other: &$t) -> $t {
|
fn abs_sub(&self, other: &$t) -> $t {
|
||||||
<$t>::abs_sub(*self, *other)
|
if *self <= *other {
|
||||||
|
0.
|
||||||
|
} else {
|
||||||
|
*self - *other
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// # Returns
|
/// # Returns
|
||||||
|
@ -123,22 +135,26 @@ macro_rules! signed_float_impl {
|
||||||
/// - `NAN` if the number is NaN
|
/// - `NAN` if the number is NaN
|
||||||
#[inline]
|
#[inline]
|
||||||
fn signum(&self) -> $t {
|
fn signum(&self) -> $t {
|
||||||
<$t>::signum(*self)
|
FloatCore::signum(*self)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Returns `true` if the number is positive, including `+0.0` and `INFINITY`
|
/// Returns `true` if the number is positive, including `+0.0` and `INFINITY`
|
||||||
#[inline]
|
#[inline]
|
||||||
fn is_positive(&self) -> bool { *self > 0.0 || (1.0 / *self) == $inf }
|
fn is_positive(&self) -> bool {
|
||||||
|
FloatCore::is_sign_positive(*self)
|
||||||
|
}
|
||||||
|
|
||||||
/// Returns `true` if the number is negative, including `-0.0` and `NEG_INFINITY`
|
/// Returns `true` if the number is negative, including `-0.0` and `NEG_INFINITY`
|
||||||
#[inline]
|
#[inline]
|
||||||
fn is_negative(&self) -> bool { *self < 0.0 || (1.0 / *self) == $neg_inf }
|
fn is_negative(&self) -> bool {
|
||||||
|
FloatCore::is_sign_negative(*self)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
signed_float_impl!(f32, f32::NAN, f32::INFINITY, f32::NEG_INFINITY);
|
signed_float_impl!(f32);
|
||||||
signed_float_impl!(f64, f64::NAN, f64::INFINITY, f64::NEG_INFINITY);
|
signed_float_impl!(f64);
|
||||||
|
|
||||||
/// Computes the absolute value.
|
/// Computes the absolute value.
|
||||||
///
|
///
|
||||||
|
@ -172,7 +188,10 @@ pub fn abs_sub<T: Signed>(x: T, y: T) -> T {
|
||||||
/// * `0` if the number is zero
|
/// * `0` if the number is zero
|
||||||
/// * `1` if the number is positive
|
/// * `1` if the number is positive
|
||||||
/// * `-1` if the number is negative
|
/// * `-1` if the number is negative
|
||||||
#[inline(always)] pub fn signum<T: Signed>(value: T) -> T { value.signum() }
|
#[inline(always)]
|
||||||
|
pub fn signum<T: Signed>(value: T) -> T {
|
||||||
|
value.signum()
|
||||||
|
}
|
||||||
|
|
||||||
/// A trait for values which cannot be negative
|
/// A trait for values which cannot be negative
|
||||||
pub trait Unsigned: Num {}
|
pub trait Unsigned: Num {}
|
||||||
|
@ -184,6 +203,8 @@ macro_rules! empty_trait_impl {
|
||||||
}
|
}
|
||||||
|
|
||||||
empty_trait_impl!(Unsigned for usize u8 u16 u32 u64);
|
empty_trait_impl!(Unsigned for usize u8 u16 u32 u64);
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
empty_trait_impl!(Unsigned for u128);
|
||||||
|
|
||||||
impl<T: Unsigned> Unsigned for Wrapping<T> where Wrapping<T>: Num {}
|
impl<T: Unsigned> Unsigned for Wrapping<T> where Wrapping<T>: Num {}
|
||||||
|
|
|
@ -0,0 +1,396 @@
|
||||||
|
//! Tests of `num_traits::cast`.
|
||||||
|
|
||||||
|
#![no_std]
|
||||||
|
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
#[macro_use]
|
||||||
|
extern crate std;
|
||||||
|
|
||||||
|
extern crate num_traits;
|
||||||
|
|
||||||
|
use num_traits::cast::*;
|
||||||
|
use num_traits::Bounded;
|
||||||
|
|
||||||
|
use core::{f32, f64};
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
use core::{i128, u128};
|
||||||
|
use core::{i16, i32, i64, i8, isize};
|
||||||
|
use core::{u16, u32, u64, u8, usize};
|
||||||
|
|
||||||
|
use core::fmt::Debug;
|
||||||
|
use core::mem;
|
||||||
|
use core::num::Wrapping;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn to_primitive_float() {
|
||||||
|
let f32_toolarge = 1e39f64;
|
||||||
|
assert_eq!(f32_toolarge.to_f32(), None);
|
||||||
|
assert_eq!((f32::MAX as f64).to_f32(), Some(f32::MAX));
|
||||||
|
assert_eq!((-f32::MAX as f64).to_f32(), Some(-f32::MAX));
|
||||||
|
assert_eq!(f64::INFINITY.to_f32(), Some(f32::INFINITY));
|
||||||
|
assert_eq!((f64::NEG_INFINITY).to_f32(), Some(f32::NEG_INFINITY));
|
||||||
|
assert!((f64::NAN).to_f32().map_or(false, |f| f.is_nan()));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_to_primitive() {
|
||||||
|
macro_rules! test_wrapping_to_primitive {
|
||||||
|
($($t:ty)+) => {
|
||||||
|
$({
|
||||||
|
let i: $t = 0;
|
||||||
|
let w = Wrapping(i);
|
||||||
|
assert_eq!(i.to_u8(), w.to_u8());
|
||||||
|
assert_eq!(i.to_u16(), w.to_u16());
|
||||||
|
assert_eq!(i.to_u32(), w.to_u32());
|
||||||
|
assert_eq!(i.to_u64(), w.to_u64());
|
||||||
|
assert_eq!(i.to_usize(), w.to_usize());
|
||||||
|
assert_eq!(i.to_i8(), w.to_i8());
|
||||||
|
assert_eq!(i.to_i16(), w.to_i16());
|
||||||
|
assert_eq!(i.to_i32(), w.to_i32());
|
||||||
|
assert_eq!(i.to_i64(), w.to_i64());
|
||||||
|
assert_eq!(i.to_isize(), w.to_isize());
|
||||||
|
assert_eq!(i.to_f32(), w.to_f32());
|
||||||
|
assert_eq!(i.to_f64(), w.to_f64());
|
||||||
|
})+
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
test_wrapping_to_primitive!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_toprimitive() {
|
||||||
|
fn require_toprimitive<T: ToPrimitive>(_: &T) {}
|
||||||
|
require_toprimitive(&Wrapping(42));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_fromprimitive() {
|
||||||
|
fn require_fromprimitive<T: FromPrimitive>(_: &T) {}
|
||||||
|
require_fromprimitive(&Wrapping(42));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn wrapping_is_numcast() {
|
||||||
|
fn require_numcast<T: NumCast>(_: &T) {}
|
||||||
|
require_numcast(&Wrapping(42));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn as_primitive() {
|
||||||
|
let x: f32 = (1.625f64).as_();
|
||||||
|
assert_eq!(x, 1.625f32);
|
||||||
|
|
||||||
|
let x: f32 = (3.14159265358979323846f64).as_();
|
||||||
|
assert_eq!(x, 3.1415927f32);
|
||||||
|
|
||||||
|
let x: u8 = (768i16).as_();
|
||||||
|
assert_eq!(x, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn float_to_integer_checks_overflow() {
|
||||||
|
// This will overflow an i32
|
||||||
|
let source: f64 = 1.0e+123f64;
|
||||||
|
|
||||||
|
// Expect the overflow to be caught
|
||||||
|
assert_eq!(cast::<f64, i32>(source), None);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn cast_to_int_checks_overflow() {
|
||||||
|
let big_f: f64 = 1.0e123;
|
||||||
|
let normal_f: f64 = 1.0;
|
||||||
|
let small_f: f64 = -1.0e123;
|
||||||
|
assert_eq!(None, cast::<f64, isize>(big_f));
|
||||||
|
assert_eq!(None, cast::<f64, i8>(big_f));
|
||||||
|
assert_eq!(None, cast::<f64, i16>(big_f));
|
||||||
|
assert_eq!(None, cast::<f64, i32>(big_f));
|
||||||
|
assert_eq!(None, cast::<f64, i64>(big_f));
|
||||||
|
|
||||||
|
assert_eq!(Some(normal_f as isize), cast::<f64, isize>(normal_f));
|
||||||
|
assert_eq!(Some(normal_f as i8), cast::<f64, i8>(normal_f));
|
||||||
|
assert_eq!(Some(normal_f as i16), cast::<f64, i16>(normal_f));
|
||||||
|
assert_eq!(Some(normal_f as i32), cast::<f64, i32>(normal_f));
|
||||||
|
assert_eq!(Some(normal_f as i64), cast::<f64, i64>(normal_f));
|
||||||
|
|
||||||
|
assert_eq!(None, cast::<f64, isize>(small_f));
|
||||||
|
assert_eq!(None, cast::<f64, i8>(small_f));
|
||||||
|
assert_eq!(None, cast::<f64, i16>(small_f));
|
||||||
|
assert_eq!(None, cast::<f64, i32>(small_f));
|
||||||
|
assert_eq!(None, cast::<f64, i64>(small_f));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn cast_to_unsigned_int_checks_overflow() {
|
||||||
|
let big_f: f64 = 1.0e123;
|
||||||
|
let normal_f: f64 = 1.0;
|
||||||
|
let small_f: f64 = -1.0e123;
|
||||||
|
assert_eq!(None, cast::<f64, usize>(big_f));
|
||||||
|
assert_eq!(None, cast::<f64, u8>(big_f));
|
||||||
|
assert_eq!(None, cast::<f64, u16>(big_f));
|
||||||
|
assert_eq!(None, cast::<f64, u32>(big_f));
|
||||||
|
assert_eq!(None, cast::<f64, u64>(big_f));
|
||||||
|
|
||||||
|
assert_eq!(Some(normal_f as usize), cast::<f64, usize>(normal_f));
|
||||||
|
assert_eq!(Some(normal_f as u8), cast::<f64, u8>(normal_f));
|
||||||
|
assert_eq!(Some(normal_f as u16), cast::<f64, u16>(normal_f));
|
||||||
|
assert_eq!(Some(normal_f as u32), cast::<f64, u32>(normal_f));
|
||||||
|
assert_eq!(Some(normal_f as u64), cast::<f64, u64>(normal_f));
|
||||||
|
|
||||||
|
assert_eq!(None, cast::<f64, usize>(small_f));
|
||||||
|
assert_eq!(None, cast::<f64, u8>(small_f));
|
||||||
|
assert_eq!(None, cast::<f64, u16>(small_f));
|
||||||
|
assert_eq!(None, cast::<f64, u32>(small_f));
|
||||||
|
assert_eq!(None, cast::<f64, u64>(small_f));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn cast_to_i128_checks_overflow() {
|
||||||
|
let big_f: f64 = 1.0e123;
|
||||||
|
let normal_f: f64 = 1.0;
|
||||||
|
let small_f: f64 = -1.0e123;
|
||||||
|
assert_eq!(None, cast::<f64, i128>(big_f));
|
||||||
|
assert_eq!(None, cast::<f64, u128>(big_f));
|
||||||
|
|
||||||
|
assert_eq!(Some(normal_f as i128), cast::<f64, i128>(normal_f));
|
||||||
|
assert_eq!(Some(normal_f as u128), cast::<f64, u128>(normal_f));
|
||||||
|
|
||||||
|
assert_eq!(None, cast::<f64, i128>(small_f));
|
||||||
|
assert_eq!(None, cast::<f64, u128>(small_f));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
fn dbg(args: ::core::fmt::Arguments) {
|
||||||
|
println!("{}", args);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(feature = "std"))]
|
||||||
|
fn dbg(_: ::core::fmt::Arguments) {}
|
||||||
|
|
||||||
|
// Rust 1.8 doesn't handle cfg on macros correctly
|
||||||
|
macro_rules! dbg { ($($tok:tt)*) => { dbg(format_args!($($tok)*)) } }
|
||||||
|
|
||||||
|
macro_rules! float_test_edge {
|
||||||
|
($f:ident -> $($t:ident)+) => { $({
|
||||||
|
dbg!("testing cast edge cases for {} -> {}", stringify!($f), stringify!($t));
|
||||||
|
|
||||||
|
let small = if $t::MIN == 0 || mem::size_of::<$t>() < mem::size_of::<$f>() {
|
||||||
|
$t::MIN as $f - 1.0
|
||||||
|
} else {
|
||||||
|
($t::MIN as $f).raw_offset(1).floor()
|
||||||
|
};
|
||||||
|
let fmin = small.raw_offset(-1);
|
||||||
|
dbg!(" testing min {}\n\tvs. {:.0}\n\tand {:.0}", $t::MIN, fmin, small);
|
||||||
|
assert_eq!(Some($t::MIN), cast::<$f, $t>($t::MIN as $f));
|
||||||
|
assert_eq!(Some($t::MIN), cast::<$f, $t>(fmin));
|
||||||
|
assert_eq!(None, cast::<$f, $t>(small));
|
||||||
|
|
||||||
|
let (max, large) = if mem::size_of::<$t>() < mem::size_of::<$f>() {
|
||||||
|
($t::MAX, $t::MAX as $f + 1.0)
|
||||||
|
} else {
|
||||||
|
let large = $t::MAX as $f; // rounds up!
|
||||||
|
let max = large.raw_offset(-1) as $t; // the next smallest possible
|
||||||
|
assert_eq!(max.count_ones(), $f::MANTISSA_DIGITS);
|
||||||
|
(max, large)
|
||||||
|
};
|
||||||
|
let fmax = large.raw_offset(-1);
|
||||||
|
dbg!(" testing max {}\n\tvs. {:.0}\n\tand {:.0}", max, fmax, large);
|
||||||
|
assert_eq!(Some(max), cast::<$f, $t>(max as $f));
|
||||||
|
assert_eq!(Some(max), cast::<$f, $t>(fmax));
|
||||||
|
assert_eq!(None, cast::<$f, $t>(large));
|
||||||
|
|
||||||
|
dbg!(" testing non-finite values");
|
||||||
|
assert_eq!(None, cast::<$f, $t>($f::NAN));
|
||||||
|
assert_eq!(None, cast::<$f, $t>($f::INFINITY));
|
||||||
|
assert_eq!(None, cast::<$f, $t>($f::NEG_INFINITY));
|
||||||
|
})+}
|
||||||
|
}
|
||||||
|
|
||||||
|
trait RawOffset: Sized {
|
||||||
|
type Raw;
|
||||||
|
fn raw_offset(self, offset: Self::Raw) -> Self;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl RawOffset for f32 {
|
||||||
|
type Raw = i32;
|
||||||
|
fn raw_offset(self, offset: Self::Raw) -> Self {
|
||||||
|
unsafe {
|
||||||
|
let raw: Self::Raw = mem::transmute(self);
|
||||||
|
mem::transmute(raw + offset)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl RawOffset for f64 {
|
||||||
|
type Raw = i64;
|
||||||
|
fn raw_offset(self, offset: Self::Raw) -> Self {
|
||||||
|
unsafe {
|
||||||
|
let raw: Self::Raw = mem::transmute(self);
|
||||||
|
mem::transmute(raw + offset)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn cast_float_to_int_edge_cases() {
|
||||||
|
float_test_edge!(f32 -> isize i8 i16 i32 i64);
|
||||||
|
float_test_edge!(f32 -> usize u8 u16 u32 u64);
|
||||||
|
float_test_edge!(f64 -> isize i8 i16 i32 i64);
|
||||||
|
float_test_edge!(f64 -> usize u8 u16 u32 u64);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn cast_float_to_i128_edge_cases() {
|
||||||
|
float_test_edge!(f32 -> i128 u128);
|
||||||
|
float_test_edge!(f64 -> i128 u128);
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! int_test_edge {
|
||||||
|
($f:ident -> { $($t:ident)+ } with $BigS:ident $BigU:ident ) => { $({
|
||||||
|
fn test_edge() {
|
||||||
|
dbg!("testing cast edge cases for {} -> {}", stringify!($f), stringify!($t));
|
||||||
|
|
||||||
|
match ($f::MIN as $BigS).cmp(&($t::MIN as $BigS)) {
|
||||||
|
Greater => {
|
||||||
|
assert_eq!(Some($f::MIN as $t), cast::<$f, $t>($f::MIN));
|
||||||
|
}
|
||||||
|
Equal => {
|
||||||
|
assert_eq!(Some($t::MIN), cast::<$f, $t>($f::MIN));
|
||||||
|
}
|
||||||
|
Less => {
|
||||||
|
let min = $t::MIN as $f;
|
||||||
|
assert_eq!(Some($t::MIN), cast::<$f, $t>(min));
|
||||||
|
assert_eq!(None, cast::<$f, $t>(min - 1));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
match ($f::MAX as $BigU).cmp(&($t::MAX as $BigU)) {
|
||||||
|
Greater => {
|
||||||
|
let max = $t::MAX as $f;
|
||||||
|
assert_eq!(Some($t::MAX), cast::<$f, $t>(max));
|
||||||
|
assert_eq!(None, cast::<$f, $t>(max + 1));
|
||||||
|
}
|
||||||
|
Equal => {
|
||||||
|
assert_eq!(Some($t::MAX), cast::<$f, $t>($f::MAX));
|
||||||
|
}
|
||||||
|
Less => {
|
||||||
|
assert_eq!(Some($f::MAX as $t), cast::<$f, $t>($f::MAX));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
test_edge();
|
||||||
|
})+}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn cast_int_to_int_edge_cases() {
|
||||||
|
use core::cmp::Ordering::*;
|
||||||
|
|
||||||
|
macro_rules! test_edge {
|
||||||
|
($( $from:ident )+) => { $({
|
||||||
|
int_test_edge!($from -> { isize i8 i16 i32 i64 } with i64 u64);
|
||||||
|
int_test_edge!($from -> { usize u8 u16 u32 u64 } with i64 u64);
|
||||||
|
})+}
|
||||||
|
}
|
||||||
|
|
||||||
|
test_edge!(isize i8 i16 i32 i64);
|
||||||
|
test_edge!(usize u8 u16 u32 u64);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg(has_i128)]
|
||||||
|
fn cast_int_to_128_edge_cases() {
|
||||||
|
use core::cmp::Ordering::*;
|
||||||
|
|
||||||
|
macro_rules! test_edge {
|
||||||
|
($( $t:ident )+) => {
|
||||||
|
$(
|
||||||
|
int_test_edge!($t -> { i128 u128 } with i128 u128);
|
||||||
|
)+
|
||||||
|
int_test_edge!(i128 -> { $( $t )+ } with i128 u128);
|
||||||
|
int_test_edge!(u128 -> { $( $t )+ } with i128 u128);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
test_edge!(isize i8 i16 i32 i64 i128);
|
||||||
|
test_edge!(usize u8 u16 u32 u64 u128);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn newtype_from_primitive() {
|
||||||
|
#[derive(PartialEq, Debug)]
|
||||||
|
struct New<T>(T);
|
||||||
|
|
||||||
|
// minimal impl
|
||||||
|
impl<T: FromPrimitive> FromPrimitive for New<T> {
|
||||||
|
fn from_i64(n: i64) -> Option<Self> {
|
||||||
|
T::from_i64(n).map(New)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn from_u64(n: u64) -> Option<Self> {
|
||||||
|
T::from_u64(n).map(New)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! assert_eq_from {
|
||||||
|
($( $from:ident )+) => {$(
|
||||||
|
assert_eq!(T::$from(Bounded::min_value()).map(New),
|
||||||
|
New::<T>::$from(Bounded::min_value()));
|
||||||
|
assert_eq!(T::$from(Bounded::max_value()).map(New),
|
||||||
|
New::<T>::$from(Bounded::max_value()));
|
||||||
|
)+}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check<T: PartialEq + Debug + FromPrimitive>() {
|
||||||
|
assert_eq_from!(from_i8 from_i16 from_i32 from_i64 from_isize);
|
||||||
|
assert_eq_from!(from_u8 from_u16 from_u32 from_u64 from_usize);
|
||||||
|
assert_eq_from!(from_f32 from_f64);
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! check {
|
||||||
|
($( $ty:ty )+) => {$( check::<$ty>(); )+}
|
||||||
|
}
|
||||||
|
check!(i8 i16 i32 i64 isize);
|
||||||
|
check!(u8 u16 u32 u64 usize);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn newtype_to_primitive() {
|
||||||
|
#[derive(PartialEq, Debug)]
|
||||||
|
struct New<T>(T);
|
||||||
|
|
||||||
|
// minimal impl
|
||||||
|
impl<T: ToPrimitive> ToPrimitive for New<T> {
|
||||||
|
fn to_i64(&self) -> Option<i64> {
|
||||||
|
self.0.to_i64()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn to_u64(&self) -> Option<u64> {
|
||||||
|
self.0.to_u64()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! assert_eq_to {
|
||||||
|
($( $to:ident )+) => {$(
|
||||||
|
assert_eq!(T::$to(&Bounded::min_value()),
|
||||||
|
New::<T>::$to(&New(Bounded::min_value())));
|
||||||
|
assert_eq!(T::$to(&Bounded::max_value()),
|
||||||
|
New::<T>::$to(&New(Bounded::max_value())));
|
||||||
|
)+}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check<T: PartialEq + Debug + Bounded + ToPrimitive>() {
|
||||||
|
assert_eq_to!(to_i8 to_i16 to_i32 to_i64 to_isize);
|
||||||
|
assert_eq_to!(to_u8 to_u16 to_u32 to_u64 to_usize);
|
||||||
|
assert_eq_to!(to_f32 to_f64);
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! check {
|
||||||
|
($( $ty:ty )+) => {$( check::<$ty>(); )+}
|
||||||
|
}
|
||||||
|
check!(i8 i16 i32 i64 isize);
|
||||||
|
check!(u8 u16 u32 u64 usize);
|
||||||
|
}
|
|
@ -1,12 +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"]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
repository = "https://github.com/rust-num/num"
|
|
||||||
name = "num-traits"
|
|
||||||
version = "0.1.39"
|
|
||||||
|
|
||||||
[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,511 +0,0 @@
|
||||||
use std::mem::size_of;
|
|
||||||
use std::num::Wrapping;
|
|
||||||
|
|
||||||
use identities::Zero;
|
|
||||||
use bounds::Bounded;
|
|
||||||
|
|
||||||
/// A generic trait for converting a value to a number.
|
|
||||||
pub trait ToPrimitive {
|
|
||||||
/// Converts the value of `self` to an `isize`.
|
|
||||||
#[inline]
|
|
||||||
fn to_isize(&self) -> Option<isize> {
|
|
||||||
self.to_i64().and_then(|x| x.to_isize())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `i8`.
|
|
||||||
#[inline]
|
|
||||||
fn to_i8(&self) -> Option<i8> {
|
|
||||||
self.to_i64().and_then(|x| x.to_i8())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `i16`.
|
|
||||||
#[inline]
|
|
||||||
fn to_i16(&self) -> Option<i16> {
|
|
||||||
self.to_i64().and_then(|x| x.to_i16())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `i32`.
|
|
||||||
#[inline]
|
|
||||||
fn to_i32(&self) -> Option<i32> {
|
|
||||||
self.to_i64().and_then(|x| x.to_i32())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `i64`.
|
|
||||||
fn to_i64(&self) -> Option<i64>;
|
|
||||||
|
|
||||||
/// Converts the value of `self` to a `usize`.
|
|
||||||
#[inline]
|
|
||||||
fn to_usize(&self) -> Option<usize> {
|
|
||||||
self.to_u64().and_then(|x| x.to_usize())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `u8`.
|
|
||||||
#[inline]
|
|
||||||
fn to_u8(&self) -> Option<u8> {
|
|
||||||
self.to_u64().and_then(|x| x.to_u8())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `u16`.
|
|
||||||
#[inline]
|
|
||||||
fn to_u16(&self) -> Option<u16> {
|
|
||||||
self.to_u64().and_then(|x| x.to_u16())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `u32`.
|
|
||||||
#[inline]
|
|
||||||
fn to_u32(&self) -> Option<u32> {
|
|
||||||
self.to_u64().and_then(|x| x.to_u32())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `u64`.
|
|
||||||
#[inline]
|
|
||||||
fn to_u64(&self) -> Option<u64>;
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `f32`.
|
|
||||||
#[inline]
|
|
||||||
fn to_f32(&self) -> Option<f32> {
|
|
||||||
self.to_f64().and_then(|x| x.to_f32())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the value of `self` to an `f64`.
|
|
||||||
#[inline]
|
|
||||||
fn to_f64(&self) -> Option<f64> {
|
|
||||||
self.to_i64().and_then(|x| x.to_f64())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! impl_to_primitive_int_to_int {
|
|
||||||
($SrcT:ty, $DstT:ty, $slf:expr) => (
|
|
||||||
{
|
|
||||||
if size_of::<$SrcT>() <= size_of::<$DstT>() {
|
|
||||||
Some($slf as $DstT)
|
|
||||||
} else {
|
|
||||||
let n = $slf as i64;
|
|
||||||
let min_value: $DstT = Bounded::min_value();
|
|
||||||
let max_value: $DstT = Bounded::max_value();
|
|
||||||
if min_value as i64 <= n && n <= max_value as i64 {
|
|
||||||
Some($slf as $DstT)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! impl_to_primitive_int_to_uint {
|
|
||||||
($SrcT:ty, $DstT:ty, $slf:expr) => (
|
|
||||||
{
|
|
||||||
let zero: $SrcT = Zero::zero();
|
|
||||||
let max_value: $DstT = Bounded::max_value();
|
|
||||||
if zero <= $slf && $slf as u64 <= max_value as u64 {
|
|
||||||
Some($slf as $DstT)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! impl_to_primitive_int {
|
|
||||||
($T:ty) => (
|
|
||||||
impl ToPrimitive for $T {
|
|
||||||
#[inline]
|
|
||||||
fn to_isize(&self) -> Option<isize> { impl_to_primitive_int_to_int!($T, isize, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i8(&self) -> Option<i8> { impl_to_primitive_int_to_int!($T, i8, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i16(&self) -> Option<i16> { impl_to_primitive_int_to_int!($T, i16, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i32(&self) -> Option<i32> { impl_to_primitive_int_to_int!($T, i32, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i64(&self) -> Option<i64> { impl_to_primitive_int_to_int!($T, i64, *self) }
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn to_usize(&self) -> Option<usize> { impl_to_primitive_int_to_uint!($T, usize, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u8(&self) -> Option<u8> { impl_to_primitive_int_to_uint!($T, u8, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u16(&self) -> Option<u16> { impl_to_primitive_int_to_uint!($T, u16, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u32(&self) -> Option<u32> { impl_to_primitive_int_to_uint!($T, u32, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u64(&self) -> Option<u64> { impl_to_primitive_int_to_uint!($T, u64, *self) }
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
|
|
||||||
#[inline]
|
|
||||||
fn to_f64(&self) -> Option<f64> { Some(*self as f64) }
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
impl_to_primitive_int!(isize);
|
|
||||||
impl_to_primitive_int!(i8);
|
|
||||||
impl_to_primitive_int!(i16);
|
|
||||||
impl_to_primitive_int!(i32);
|
|
||||||
impl_to_primitive_int!(i64);
|
|
||||||
|
|
||||||
macro_rules! impl_to_primitive_uint_to_int {
|
|
||||||
($DstT:ty, $slf:expr) => (
|
|
||||||
{
|
|
||||||
let max_value: $DstT = Bounded::max_value();
|
|
||||||
if $slf as u64 <= max_value as u64 {
|
|
||||||
Some($slf as $DstT)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! impl_to_primitive_uint_to_uint {
|
|
||||||
($SrcT:ty, $DstT:ty, $slf:expr) => (
|
|
||||||
{
|
|
||||||
if size_of::<$SrcT>() <= size_of::<$DstT>() {
|
|
||||||
Some($slf as $DstT)
|
|
||||||
} else {
|
|
||||||
let zero: $SrcT = Zero::zero();
|
|
||||||
let max_value: $DstT = Bounded::max_value();
|
|
||||||
if zero <= $slf && $slf as u64 <= max_value as u64 {
|
|
||||||
Some($slf as $DstT)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! impl_to_primitive_uint {
|
|
||||||
($T:ty) => (
|
|
||||||
impl ToPrimitive for $T {
|
|
||||||
#[inline]
|
|
||||||
fn to_isize(&self) -> Option<isize> { impl_to_primitive_uint_to_int!(isize, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i8(&self) -> Option<i8> { impl_to_primitive_uint_to_int!(i8, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i16(&self) -> Option<i16> { impl_to_primitive_uint_to_int!(i16, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i32(&self) -> Option<i32> { impl_to_primitive_uint_to_int!(i32, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i64(&self) -> Option<i64> { impl_to_primitive_uint_to_int!(i64, *self) }
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn to_usize(&self) -> Option<usize> {
|
|
||||||
impl_to_primitive_uint_to_uint!($T, usize, *self)
|
|
||||||
}
|
|
||||||
#[inline]
|
|
||||||
fn to_u8(&self) -> Option<u8> { impl_to_primitive_uint_to_uint!($T, u8, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u16(&self) -> Option<u16> { impl_to_primitive_uint_to_uint!($T, u16, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u32(&self) -> Option<u32> { impl_to_primitive_uint_to_uint!($T, u32, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u64(&self) -> Option<u64> { impl_to_primitive_uint_to_uint!($T, u64, *self) }
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
|
|
||||||
#[inline]
|
|
||||||
fn to_f64(&self) -> Option<f64> { Some(*self as f64) }
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
impl_to_primitive_uint!(usize);
|
|
||||||
impl_to_primitive_uint!(u8);
|
|
||||||
impl_to_primitive_uint!(u16);
|
|
||||||
impl_to_primitive_uint!(u32);
|
|
||||||
impl_to_primitive_uint!(u64);
|
|
||||||
|
|
||||||
macro_rules! impl_to_primitive_float_to_float {
|
|
||||||
($SrcT:ident, $DstT:ident, $slf:expr) => (
|
|
||||||
if size_of::<$SrcT>() <= size_of::<$DstT>() {
|
|
||||||
Some($slf as $DstT)
|
|
||||||
} else {
|
|
||||||
// Make sure the value is in range for the cast.
|
|
||||||
// NaN and +-inf are cast as they are.
|
|
||||||
let n = $slf as f64;
|
|
||||||
let max_value: $DstT = ::std::$DstT::MAX;
|
|
||||||
if !n.is_finite() || (-max_value as f64 <= n && n <= max_value as f64) {
|
|
||||||
Some($slf as $DstT)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! impl_to_primitive_float {
|
|
||||||
($T:ident) => (
|
|
||||||
impl ToPrimitive for $T {
|
|
||||||
#[inline]
|
|
||||||
fn to_isize(&self) -> Option<isize> { Some(*self as isize) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i8(&self) -> Option<i8> { Some(*self as i8) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i16(&self) -> Option<i16> { Some(*self as i16) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i32(&self) -> Option<i32> { Some(*self as i32) }
|
|
||||||
#[inline]
|
|
||||||
fn to_i64(&self) -> Option<i64> { Some(*self as i64) }
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn to_usize(&self) -> Option<usize> { Some(*self as usize) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u8(&self) -> Option<u8> { Some(*self as u8) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u16(&self) -> Option<u16> { Some(*self as u16) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u32(&self) -> Option<u32> { Some(*self as u32) }
|
|
||||||
#[inline]
|
|
||||||
fn to_u64(&self) -> Option<u64> { Some(*self as u64) }
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn to_f32(&self) -> Option<f32> { impl_to_primitive_float_to_float!($T, f32, *self) }
|
|
||||||
#[inline]
|
|
||||||
fn to_f64(&self) -> Option<f64> { impl_to_primitive_float_to_float!($T, f64, *self) }
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
impl_to_primitive_float!(f32);
|
|
||||||
impl_to_primitive_float!(f64);
|
|
||||||
|
|
||||||
/// A generic trait for converting a number to a value.
|
|
||||||
pub trait FromPrimitive: Sized {
|
|
||||||
/// Convert an `isize` to return an optional value of this type. If the
|
|
||||||
/// value cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_isize(n: isize) -> Option<Self> {
|
|
||||||
FromPrimitive::from_i64(n as i64)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert an `i8` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_i8(n: i8) -> Option<Self> {
|
|
||||||
FromPrimitive::from_i64(n as i64)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert an `i16` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_i16(n: i16) -> Option<Self> {
|
|
||||||
FromPrimitive::from_i64(n as i64)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert an `i32` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_i32(n: i32) -> Option<Self> {
|
|
||||||
FromPrimitive::from_i64(n as i64)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert an `i64` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
fn from_i64(n: i64) -> Option<Self>;
|
|
||||||
|
|
||||||
/// Convert a `usize` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_usize(n: usize) -> Option<Self> {
|
|
||||||
FromPrimitive::from_u64(n as u64)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert an `u8` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_u8(n: u8) -> Option<Self> {
|
|
||||||
FromPrimitive::from_u64(n as u64)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert an `u16` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_u16(n: u16) -> Option<Self> {
|
|
||||||
FromPrimitive::from_u64(n as u64)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert an `u32` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_u32(n: u32) -> Option<Self> {
|
|
||||||
FromPrimitive::from_u64(n as u64)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert an `u64` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
fn from_u64(n: u64) -> Option<Self>;
|
|
||||||
|
|
||||||
/// Convert a `f32` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_f32(n: f32) -> Option<Self> {
|
|
||||||
FromPrimitive::from_f64(n as f64)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert a `f64` to return an optional value of this type. If the
|
|
||||||
/// type cannot be represented by this value, the `None` is returned.
|
|
||||||
#[inline]
|
|
||||||
fn from_f64(n: f64) -> Option<Self> {
|
|
||||||
FromPrimitive::from_i64(n as i64)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! impl_from_primitive {
|
|
||||||
($T:ty, $to_ty:ident) => (
|
|
||||||
#[allow(deprecated)]
|
|
||||||
impl FromPrimitive for $T {
|
|
||||||
#[inline] fn from_i8(n: i8) -> Option<$T> { n.$to_ty() }
|
|
||||||
#[inline] fn from_i16(n: i16) -> Option<$T> { n.$to_ty() }
|
|
||||||
#[inline] fn from_i32(n: i32) -> Option<$T> { n.$to_ty() }
|
|
||||||
#[inline] fn from_i64(n: i64) -> Option<$T> { n.$to_ty() }
|
|
||||||
|
|
||||||
#[inline] fn from_u8(n: u8) -> Option<$T> { n.$to_ty() }
|
|
||||||
#[inline] fn from_u16(n: u16) -> Option<$T> { n.$to_ty() }
|
|
||||||
#[inline] fn from_u32(n: u32) -> Option<$T> { n.$to_ty() }
|
|
||||||
#[inline] fn from_u64(n: u64) -> Option<$T> { n.$to_ty() }
|
|
||||||
|
|
||||||
#[inline] fn from_f32(n: f32) -> Option<$T> { n.$to_ty() }
|
|
||||||
#[inline] fn from_f64(n: f64) -> Option<$T> { n.$to_ty() }
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
impl_from_primitive!(isize, to_isize);
|
|
||||||
impl_from_primitive!(i8, to_i8);
|
|
||||||
impl_from_primitive!(i16, to_i16);
|
|
||||||
impl_from_primitive!(i32, to_i32);
|
|
||||||
impl_from_primitive!(i64, to_i64);
|
|
||||||
impl_from_primitive!(usize, to_usize);
|
|
||||||
impl_from_primitive!(u8, to_u8);
|
|
||||||
impl_from_primitive!(u16, to_u16);
|
|
||||||
impl_from_primitive!(u32, to_u32);
|
|
||||||
impl_from_primitive!(u64, to_u64);
|
|
||||||
impl_from_primitive!(f32, to_f32);
|
|
||||||
impl_from_primitive!(f64, to_f64);
|
|
||||||
|
|
||||||
|
|
||||||
impl<T: ToPrimitive> ToPrimitive for Wrapping<T> {
|
|
||||||
fn to_i64(&self) -> Option<i64> { self.0.to_i64() }
|
|
||||||
fn to_u64(&self) -> Option<u64> { self.0.to_u64() }
|
|
||||||
}
|
|
||||||
impl<T: FromPrimitive> FromPrimitive for Wrapping<T> {
|
|
||||||
fn from_u64(n: u64) -> Option<Self> { T::from_u64(n).map(Wrapping) }
|
|
||||||
fn from_i64(n: i64) -> Option<Self> { T::from_i64(n).map(Wrapping) }
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/// Cast from one machine scalar to another.
|
|
||||||
///
|
|
||||||
/// # Examples
|
|
||||||
///
|
|
||||||
/// ```
|
|
||||||
/// # use num_traits as num;
|
|
||||||
/// let twenty: f32 = num::cast(0x14).unwrap();
|
|
||||||
/// assert_eq!(twenty, 20f32);
|
|
||||||
/// ```
|
|
||||||
///
|
|
||||||
#[inline]
|
|
||||||
pub fn cast<T: NumCast, U: NumCast>(n: T) -> Option<U> {
|
|
||||||
NumCast::from(n)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// An interface for casting between machine scalars.
|
|
||||||
pub trait NumCast: Sized + ToPrimitive {
|
|
||||||
/// Creates a number from another value that can be converted into
|
|
||||||
/// a primitive via the `ToPrimitive` trait.
|
|
||||||
fn from<T: ToPrimitive>(n: T) -> Option<Self>;
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! impl_num_cast {
|
|
||||||
($T:ty, $conv:ident) => (
|
|
||||||
impl NumCast for $T {
|
|
||||||
#[inline]
|
|
||||||
#[allow(deprecated)]
|
|
||||||
fn from<N: ToPrimitive>(n: N) -> Option<$T> {
|
|
||||||
// `$conv` could be generated using `concat_idents!`, but that
|
|
||||||
// macro seems to be broken at the moment
|
|
||||||
n.$conv()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
impl_num_cast!(u8, to_u8);
|
|
||||||
impl_num_cast!(u16, to_u16);
|
|
||||||
impl_num_cast!(u32, to_u32);
|
|
||||||
impl_num_cast!(u64, to_u64);
|
|
||||||
impl_num_cast!(usize, to_usize);
|
|
||||||
impl_num_cast!(i8, to_i8);
|
|
||||||
impl_num_cast!(i16, to_i16);
|
|
||||||
impl_num_cast!(i32, to_i32);
|
|
||||||
impl_num_cast!(i64, to_i64);
|
|
||||||
impl_num_cast!(isize, to_isize);
|
|
||||||
impl_num_cast!(f32, to_f32);
|
|
||||||
impl_num_cast!(f64, to_f64);
|
|
||||||
|
|
||||||
impl<T: NumCast> NumCast for Wrapping<T> {
|
|
||||||
fn from<U: ToPrimitive>(n: U) -> Option<Self> {
|
|
||||||
T::from(n).map(Wrapping)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn to_primitive_float() {
|
|
||||||
use std::f32;
|
|
||||||
use std::f64;
|
|
||||||
|
|
||||||
let f32_toolarge = 1e39f64;
|
|
||||||
assert_eq!(f32_toolarge.to_f32(), None);
|
|
||||||
assert_eq!((f32::MAX as f64).to_f32(), Some(f32::MAX));
|
|
||||||
assert_eq!((-f32::MAX as f64).to_f32(), Some(-f32::MAX));
|
|
||||||
assert_eq!(f64::INFINITY.to_f32(), Some(f32::INFINITY));
|
|
||||||
assert_eq!((f64::NEG_INFINITY).to_f32(), Some(f32::NEG_INFINITY));
|
|
||||||
assert!((f64::NAN).to_f32().map_or(false, |f| f.is_nan()));
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! test_wrapping_to_primitive {
|
|
||||||
($($t:ty)+) => {
|
|
||||||
$({
|
|
||||||
let i: $t = 0;
|
|
||||||
let w = Wrapping(i);
|
|
||||||
assert_eq!(i.to_u8(), w.to_u8());
|
|
||||||
assert_eq!(i.to_u16(), w.to_u16());
|
|
||||||
assert_eq!(i.to_u32(), w.to_u32());
|
|
||||||
assert_eq!(i.to_u64(), w.to_u64());
|
|
||||||
assert_eq!(i.to_usize(), w.to_usize());
|
|
||||||
assert_eq!(i.to_i8(), w.to_i8());
|
|
||||||
assert_eq!(i.to_i16(), w.to_i16());
|
|
||||||
assert_eq!(i.to_i32(), w.to_i32());
|
|
||||||
assert_eq!(i.to_i64(), w.to_i64());
|
|
||||||
assert_eq!(i.to_isize(), w.to_isize());
|
|
||||||
assert_eq!(i.to_f32(), w.to_f32());
|
|
||||||
assert_eq!(i.to_f64(), w.to_f64());
|
|
||||||
})+
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_to_primitive() {
|
|
||||||
test_wrapping_to_primitive!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_is_toprimitive() {
|
|
||||||
fn require_toprimitive<T: ToPrimitive>(_: &T) {}
|
|
||||||
require_toprimitive(&Wrapping(42));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_is_fromprimitive() {
|
|
||||||
fn require_fromprimitive<T: FromPrimitive>(_: &T) {}
|
|
||||||
require_fromprimitive(&Wrapping(42));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_is_numcast() {
|
|
||||||
fn require_numcast<T: NumCast>(_: &T) {}
|
|
||||||
require_numcast(&Wrapping(42));
|
|
||||||
}
|
|
1346
traits/src/float.rs
1346
traits/src/float.rs
File diff suppressed because it is too large
Load Diff
|
@ -1,148 +0,0 @@
|
||||||
use std::ops::{Add, Mul};
|
|
||||||
use std::num::Wrapping;
|
|
||||||
|
|
||||||
/// Defines an additive identity element for `Self`.
|
|
||||||
pub trait Zero: Sized + Add<Self, Output = Self> {
|
|
||||||
/// Returns the additive identity element of `Self`, `0`.
|
|
||||||
///
|
|
||||||
/// # Laws
|
|
||||||
///
|
|
||||||
/// ```{.text}
|
|
||||||
/// a + 0 = a ∀ a ∈ Self
|
|
||||||
/// 0 + a = a ∀ a ∈ Self
|
|
||||||
/// ```
|
|
||||||
///
|
|
||||||
/// # Purity
|
|
||||||
///
|
|
||||||
/// This function should return the same result at all times regardless of
|
|
||||||
/// external mutable state, for example values stored in TLS or in
|
|
||||||
/// `static mut`s.
|
|
||||||
// FIXME (#5527): This should be an associated constant
|
|
||||||
fn zero() -> Self;
|
|
||||||
|
|
||||||
/// Returns `true` if `self` is equal to the additive identity.
|
|
||||||
#[inline]
|
|
||||||
fn is_zero(&self) -> bool;
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! zero_impl {
|
|
||||||
($t:ty, $v:expr) => {
|
|
||||||
impl Zero for $t {
|
|
||||||
#[inline]
|
|
||||||
fn zero() -> $t { $v }
|
|
||||||
#[inline]
|
|
||||||
fn is_zero(&self) -> bool { *self == $v }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
zero_impl!(usize, 0usize);
|
|
||||||
zero_impl!(u8, 0u8);
|
|
||||||
zero_impl!(u16, 0u16);
|
|
||||||
zero_impl!(u32, 0u32);
|
|
||||||
zero_impl!(u64, 0u64);
|
|
||||||
|
|
||||||
zero_impl!(isize, 0isize);
|
|
||||||
zero_impl!(i8, 0i8);
|
|
||||||
zero_impl!(i16, 0i16);
|
|
||||||
zero_impl!(i32, 0i32);
|
|
||||||
zero_impl!(i64, 0i64);
|
|
||||||
|
|
||||||
zero_impl!(f32, 0.0f32);
|
|
||||||
zero_impl!(f64, 0.0f64);
|
|
||||||
|
|
||||||
impl<T: Zero> Zero for Wrapping<T> where Wrapping<T>: Add<Output=Wrapping<T>> {
|
|
||||||
fn is_zero(&self) -> bool {
|
|
||||||
self.0.is_zero()
|
|
||||||
}
|
|
||||||
fn zero() -> Self {
|
|
||||||
Wrapping(T::zero())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/// Defines a multiplicative identity element for `Self`.
|
|
||||||
pub trait One: Sized + Mul<Self, Output = Self> {
|
|
||||||
/// Returns the multiplicative identity element of `Self`, `1`.
|
|
||||||
///
|
|
||||||
/// # Laws
|
|
||||||
///
|
|
||||||
/// ```{.text}
|
|
||||||
/// a * 1 = a ∀ a ∈ Self
|
|
||||||
/// 1 * a = a ∀ a ∈ Self
|
|
||||||
/// ```
|
|
||||||
///
|
|
||||||
/// # Purity
|
|
||||||
///
|
|
||||||
/// This function should return the same result at all times regardless of
|
|
||||||
/// external mutable state, for example values stored in TLS or in
|
|
||||||
/// `static mut`s.
|
|
||||||
// FIXME (#5527): This should be an associated constant
|
|
||||||
fn one() -> Self;
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! one_impl {
|
|
||||||
($t:ty, $v:expr) => {
|
|
||||||
impl One for $t {
|
|
||||||
#[inline]
|
|
||||||
fn one() -> $t { $v }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
one_impl!(usize, 1usize);
|
|
||||||
one_impl!(u8, 1u8);
|
|
||||||
one_impl!(u16, 1u16);
|
|
||||||
one_impl!(u32, 1u32);
|
|
||||||
one_impl!(u64, 1u64);
|
|
||||||
|
|
||||||
one_impl!(isize, 1isize);
|
|
||||||
one_impl!(i8, 1i8);
|
|
||||||
one_impl!(i16, 1i16);
|
|
||||||
one_impl!(i32, 1i32);
|
|
||||||
one_impl!(i64, 1i64);
|
|
||||||
|
|
||||||
one_impl!(f32, 1.0f32);
|
|
||||||
one_impl!(f64, 1.0f64);
|
|
||||||
|
|
||||||
impl<T: One> One for Wrapping<T> where Wrapping<T>: Mul<Output=Wrapping<T>> {
|
|
||||||
fn one() -> Self {
|
|
||||||
Wrapping(T::one())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Some helper functions provided for backwards compatibility.
|
|
||||||
|
|
||||||
/// Returns the additive identity, `0`.
|
|
||||||
#[inline(always)] pub fn zero<T: Zero>() -> T { Zero::zero() }
|
|
||||||
|
|
||||||
/// Returns the multiplicative identity, `1`.
|
|
||||||
#[inline(always)] pub fn one<T: One>() -> T { One::one() }
|
|
||||||
|
|
||||||
|
|
||||||
macro_rules! test_wrapping_identities {
|
|
||||||
($($t:ty)+) => {
|
|
||||||
$(
|
|
||||||
assert_eq!(zero::<$t>(), zero::<Wrapping<$t>>().0);
|
|
||||||
assert_eq!(one::<$t>(), one::<Wrapping<$t>>().0);
|
|
||||||
assert_eq!((0 as $t).is_zero(), Wrapping(0 as $t).is_zero());
|
|
||||||
assert_eq!((1 as $t).is_zero(), Wrapping(1 as $t).is_zero());
|
|
||||||
)+
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_identities() {
|
|
||||||
test_wrapping_identities!(isize i8 i16 i32 i64 usize u8 u16 u32 u64);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_is_zero() {
|
|
||||||
fn require_zero<T: Zero>(_: &T) {}
|
|
||||||
require_zero(&Wrapping(42));
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn wrapping_is_one() {
|
|
||||||
fn require_one<T: One>(_: &T) {}
|
|
||||||
require_one(&Wrapping(42));
|
|
||||||
}
|
|
|
@ -1,435 +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);
|
|
||||||
}
|
|
||||||
|
|
||||||
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]
|
|
||||||
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() {
|
|
||||||
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,92 +0,0 @@
|
||||||
use std::ops::{Add, Sub, Mul, Div};
|
|
||||||
|
|
||||||
/// Performs addition that returns `None` instead of wrapping around on
|
|
||||||
/// overflow.
|
|
||||||
pub trait CheckedAdd: Sized + Add<Self, Output=Self> {
|
|
||||||
/// Adds two numbers, checking for overflow. If overflow happens, `None` is
|
|
||||||
/// returned.
|
|
||||||
fn checked_add(&self, v: &Self) -> Option<Self>;
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! checked_impl {
|
|
||||||
($trait_name:ident, $method:ident, $t:ty) => {
|
|
||||||
impl $trait_name for $t {
|
|
||||||
#[inline]
|
|
||||||
fn $method(&self, v: &$t) -> Option<$t> {
|
|
||||||
<$t>::$method(*self, *v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
checked_impl!(CheckedAdd, checked_add, u8);
|
|
||||||
checked_impl!(CheckedAdd, checked_add, u16);
|
|
||||||
checked_impl!(CheckedAdd, checked_add, u32);
|
|
||||||
checked_impl!(CheckedAdd, checked_add, u64);
|
|
||||||
checked_impl!(CheckedAdd, checked_add, usize);
|
|
||||||
|
|
||||||
checked_impl!(CheckedAdd, checked_add, i8);
|
|
||||||
checked_impl!(CheckedAdd, checked_add, i16);
|
|
||||||
checked_impl!(CheckedAdd, checked_add, i32);
|
|
||||||
checked_impl!(CheckedAdd, checked_add, i64);
|
|
||||||
checked_impl!(CheckedAdd, checked_add, isize);
|
|
||||||
|
|
||||||
/// Performs subtraction that returns `None` instead of wrapping around on underflow.
|
|
||||||
pub trait CheckedSub: Sized + Sub<Self, Output=Self> {
|
|
||||||
/// Subtracts two numbers, checking for underflow. If underflow happens,
|
|
||||||
/// `None` is returned.
|
|
||||||
fn checked_sub(&self, v: &Self) -> Option<Self>;
|
|
||||||
}
|
|
||||||
|
|
||||||
checked_impl!(CheckedSub, checked_sub, u8);
|
|
||||||
checked_impl!(CheckedSub, checked_sub, u16);
|
|
||||||
checked_impl!(CheckedSub, checked_sub, u32);
|
|
||||||
checked_impl!(CheckedSub, checked_sub, u64);
|
|
||||||
checked_impl!(CheckedSub, checked_sub, usize);
|
|
||||||
|
|
||||||
checked_impl!(CheckedSub, checked_sub, i8);
|
|
||||||
checked_impl!(CheckedSub, checked_sub, i16);
|
|
||||||
checked_impl!(CheckedSub, checked_sub, i32);
|
|
||||||
checked_impl!(CheckedSub, checked_sub, i64);
|
|
||||||
checked_impl!(CheckedSub, checked_sub, isize);
|
|
||||||
|
|
||||||
/// Performs multiplication that returns `None` instead of wrapping around on underflow or
|
|
||||||
/// overflow.
|
|
||||||
pub trait CheckedMul: Sized + Mul<Self, Output=Self> {
|
|
||||||
/// Multiplies two numbers, checking for underflow or overflow. If underflow
|
|
||||||
/// or overflow happens, `None` is returned.
|
|
||||||
fn checked_mul(&self, v: &Self) -> Option<Self>;
|
|
||||||
}
|
|
||||||
|
|
||||||
checked_impl!(CheckedMul, checked_mul, u8);
|
|
||||||
checked_impl!(CheckedMul, checked_mul, u16);
|
|
||||||
checked_impl!(CheckedMul, checked_mul, u32);
|
|
||||||
checked_impl!(CheckedMul, checked_mul, u64);
|
|
||||||
checked_impl!(CheckedMul, checked_mul, usize);
|
|
||||||
|
|
||||||
checked_impl!(CheckedMul, checked_mul, i8);
|
|
||||||
checked_impl!(CheckedMul, checked_mul, i16);
|
|
||||||
checked_impl!(CheckedMul, checked_mul, i32);
|
|
||||||
checked_impl!(CheckedMul, checked_mul, i64);
|
|
||||||
checked_impl!(CheckedMul, checked_mul, isize);
|
|
||||||
|
|
||||||
/// Performs division that returns `None` instead of panicking on division by zero and instead of
|
|
||||||
/// wrapping around on underflow and overflow.
|
|
||||||
pub trait CheckedDiv: Sized + Div<Self, Output=Self> {
|
|
||||||
/// Divides two numbers, checking for underflow, overflow and division by
|
|
||||||
/// zero. If any of that happens, `None` is returned.
|
|
||||||
fn checked_div(&self, v: &Self) -> Option<Self>;
|
|
||||||
}
|
|
||||||
|
|
||||||
checked_impl!(CheckedDiv, checked_div, u8);
|
|
||||||
checked_impl!(CheckedDiv, checked_div, u16);
|
|
||||||
checked_impl!(CheckedDiv, checked_div, u32);
|
|
||||||
checked_impl!(CheckedDiv, checked_div, u64);
|
|
||||||
checked_impl!(CheckedDiv, checked_div, usize);
|
|
||||||
|
|
||||||
checked_impl!(CheckedDiv, checked_div, i8);
|
|
||||||
checked_impl!(CheckedDiv, checked_div, i16);
|
|
||||||
checked_impl!(CheckedDiv, checked_div, i32);
|
|
||||||
checked_impl!(CheckedDiv, checked_div, i64);
|
|
||||||
checked_impl!(CheckedDiv, checked_div, isize);
|
|
||||||
|
|
|
@ -1,127 +0,0 @@
|
||||||
use std::ops::{Add, Sub, Mul};
|
|
||||||
use std::num::Wrapping;
|
|
||||||
|
|
||||||
macro_rules! wrapping_impl {
|
|
||||||
($trait_name:ident, $method:ident, $t:ty) => {
|
|
||||||
impl $trait_name for $t {
|
|
||||||
#[inline]
|
|
||||||
fn $method(&self, v: &Self) -> Self {
|
|
||||||
<$t>::$method(*self, *v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
($trait_name:ident, $method:ident, $t:ty, $rhs:ty) => {
|
|
||||||
impl $trait_name<$rhs> for $t {
|
|
||||||
#[inline]
|
|
||||||
fn $method(&self, v: &$rhs) -> Self {
|
|
||||||
<$t>::$method(*self, *v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Performs addition that wraps around on overflow.
|
|
||||||
pub trait WrappingAdd: Sized + Add<Self, Output=Self> {
|
|
||||||
/// Wrapping (modular) addition. Computes `self + other`, wrapping around at the boundary of
|
|
||||||
/// the type.
|
|
||||||
fn wrapping_add(&self, v: &Self) -> Self;
|
|
||||||
}
|
|
||||||
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, u8);
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, u16);
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, u32);
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, u64);
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, usize);
|
|
||||||
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, i8);
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, i16);
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, i32);
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, i64);
|
|
||||||
wrapping_impl!(WrappingAdd, wrapping_add, isize);
|
|
||||||
|
|
||||||
/// Performs subtraction that wraps around on overflow.
|
|
||||||
pub trait WrappingSub: Sized + Sub<Self, Output=Self> {
|
|
||||||
/// Wrapping (modular) subtraction. Computes `self - other`, wrapping around at the boundary
|
|
||||||
/// of the type.
|
|
||||||
fn wrapping_sub(&self, v: &Self) -> Self;
|
|
||||||
}
|
|
||||||
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, u8);
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, u16);
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, u32);
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, u64);
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, usize);
|
|
||||||
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, i8);
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, i16);
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, i32);
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, i64);
|
|
||||||
wrapping_impl!(WrappingSub, wrapping_sub, isize);
|
|
||||||
|
|
||||||
/// Performs multiplication that wraps around on overflow.
|
|
||||||
pub trait WrappingMul: Sized + Mul<Self, Output=Self> {
|
|
||||||
/// Wrapping (modular) multiplication. Computes `self * other`, wrapping around at the boundary
|
|
||||||
/// of the type.
|
|
||||||
fn wrapping_mul(&self, v: &Self) -> Self;
|
|
||||||
}
|
|
||||||
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, u8);
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, u16);
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, u32);
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, u64);
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, usize);
|
|
||||||
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, i8);
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, i16);
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, i32);
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, i64);
|
|
||||||
wrapping_impl!(WrappingMul, wrapping_mul, isize);
|
|
||||||
|
|
||||||
// Well this is a bit funny, but all the more appropriate.
|
|
||||||
impl<T: WrappingAdd> WrappingAdd for Wrapping<T> where Wrapping<T>: Add<Output = Wrapping<T>> {
|
|
||||||
fn wrapping_add(&self, v: &Self) -> Self {
|
|
||||||
Wrapping(self.0.wrapping_add(&v.0))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<T: WrappingSub> WrappingSub for Wrapping<T> where Wrapping<T>: Sub<Output = Wrapping<T>> {
|
|
||||||
fn wrapping_sub(&self, v: &Self) -> Self {
|
|
||||||
Wrapping(self.0.wrapping_sub(&v.0))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<T: WrappingMul> WrappingMul for Wrapping<T> where Wrapping<T>: Mul<Output = Wrapping<T>> {
|
|
||||||
fn wrapping_mul(&self, v: &Self) -> Self {
|
|
||||||
Wrapping(self.0.wrapping_mul(&v.0))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_wrapping_traits() {
|
|
||||||
fn wrapping_add<T: WrappingAdd>(a: T, b: T) -> T { a.wrapping_add(&b) }
|
|
||||||
fn wrapping_sub<T: WrappingSub>(a: T, b: T) -> T { a.wrapping_sub(&b) }
|
|
||||||
fn wrapping_mul<T: WrappingMul>(a: T, b: T) -> T { a.wrapping_mul(&b) }
|
|
||||||
assert_eq!(wrapping_add(255, 1), 0u8);
|
|
||||||
assert_eq!(wrapping_sub(0, 1), 255u8);
|
|
||||||
assert_eq!(wrapping_mul(255, 2), 254u8);
|
|
||||||
assert_eq!(wrapping_add(255, 1), (Wrapping(255u8) + Wrapping(1u8)).0);
|
|
||||||
assert_eq!(wrapping_sub(0, 1), (Wrapping(0u8) - Wrapping(1u8)).0);
|
|
||||||
assert_eq!(wrapping_mul(255, 2), (Wrapping(255u8) * Wrapping(2u8)).0);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_is_wrappingadd() {
|
|
||||||
fn require_wrappingadd<T: WrappingAdd>(_: &T) {}
|
|
||||||
require_wrappingadd(&Wrapping(42));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_is_wrappingsub() {
|
|
||||||
fn require_wrappingsub<T: WrappingSub>(_: &T) {}
|
|
||||||
require_wrappingsub(&Wrapping(42));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrapping_is_wrappingmul() {
|
|
||||||
fn require_wrappingmul<T: WrappingMul>(_: &T) {}
|
|
||||||
require_wrappingmul(&Wrapping(42));
|
|
||||||
}
|
|
|
@ -1,73 +0,0 @@
|
||||||
use std::ops::Mul;
|
|
||||||
use {One, CheckedMul};
|
|
||||||
|
|
||||||
/// Raises a value to the power of exp, using exponentiation by squaring.
|
|
||||||
///
|
|
||||||
/// # Example
|
|
||||||
///
|
|
||||||
/// ```rust
|
|
||||||
/// use num_traits::pow;
|
|
||||||
///
|
|
||||||
/// assert_eq!(pow(2i8, 4), 16);
|
|
||||||
/// assert_eq!(pow(6u8, 3), 216);
|
|
||||||
/// ```
|
|
||||||
#[inline]
|
|
||||||
pub fn pow<T: Clone + One + Mul<T, Output = T>>(mut base: T, mut exp: usize) -> T {
|
|
||||||
if exp == 0 { return T::one() }
|
|
||||||
|
|
||||||
while exp & 1 == 0 {
|
|
||||||
base = base.clone() * base;
|
|
||||||
exp >>= 1;
|
|
||||||
}
|
|
||||||
if exp == 1 { return base }
|
|
||||||
|
|
||||||
let mut acc = base.clone();
|
|
||||||
while exp > 1 {
|
|
||||||
exp >>= 1;
|
|
||||||
base = base.clone() * base;
|
|
||||||
if exp & 1 == 1 {
|
|
||||||
acc = acc * base.clone();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
acc
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Raises a value to the power of exp, returning `None` if an overflow occurred.
|
|
||||||
///
|
|
||||||
/// Otherwise same as the `pow` function.
|
|
||||||
///
|
|
||||||
/// # Example
|
|
||||||
///
|
|
||||||
/// ```rust
|
|
||||||
/// use num_traits::checked_pow;
|
|
||||||
///
|
|
||||||
/// assert_eq!(checked_pow(2i8, 4), Some(16));
|
|
||||||
/// assert_eq!(checked_pow(7i8, 8), None);
|
|
||||||
/// assert_eq!(checked_pow(7u32, 8), Some(5_764_801));
|
|
||||||
/// ```
|
|
||||||
#[inline]
|
|
||||||
pub fn checked_pow<T: Clone + One + CheckedMul>(mut base: T, mut exp: usize) -> Option<T> {
|
|
||||||
if exp == 0 { return Some(T::one()) }
|
|
||||||
|
|
||||||
macro_rules! optry {
|
|
||||||
( $ expr : expr ) => {
|
|
||||||
if let Some(val) = $expr { val } else { return None }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
while exp & 1 == 0 {
|
|
||||||
base = optry!(base.checked_mul(&base));
|
|
||||||
exp >>= 1;
|
|
||||||
}
|
|
||||||
if exp == 1 { return Some(base) }
|
|
||||||
|
|
||||||
let mut acc = base.clone();
|
|
||||||
while exp > 1 {
|
|
||||||
exp >>= 1;
|
|
||||||
base = optry!(base.checked_mul(&base));
|
|
||||||
if exp & 1 == 1 {
|
|
||||||
acc = optry!(acc.checked_mul(&base));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Some(acc)
|
|
||||||
}
|
|
Loading…
Reference in New Issue