--- a/Cargo.lock
+++ b/Cargo.lock
@@ -16,17 +16,17 @@ name = "ansi_term"
version = "0.10.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "app_units"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "arrayvec"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
@@ -557,17 +557,17 @@ name = "error-chain"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "euclid"
version = "0.17.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "fallible"
version = "0.0.1"
dependencies = [
"hashglobe 0.1.0",
@@ -844,17 +844,17 @@ dependencies = [
"bindgen 0.33.2 (registry+https://github.com/rust-lang/crates.io-index)",
"cmake 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
"env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.39 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"mozjs_sys 0.0.0",
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "kernel32-sys"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1193,40 +1193,43 @@ dependencies = [
[[package]]
name = "num"
version = "0.1.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"num-integer 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
"num-iter 0.1.34 (registry+https://github.com/rust-lang/crates.io-index)",
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "num-integer"
version = "0.1.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "num-iter"
version = "0.1.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"num-integer 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "num-traits"
-version = "0.1.41"
+version = "0.1.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "num-traits 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
[[package]]
name = "num-traits"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "num_cpus"
@@ -1236,17 +1239,17 @@ dependencies = [
"libc 0.2.39 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "ordered-float"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
"unreachable 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "owning_ref"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
@@ -1327,17 +1330,17 @@ source = "registry+https://github.com/ru
[[package]]
name = "plane-split"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"binary-space-partition 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"euclid 0.17.2 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "podio"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
@@ -1641,17 +1644,17 @@ dependencies = [
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"malloc_size_of 0.0.1",
"malloc_size_of_derive 0.0.1",
"matches 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"nsstring 0.1.0",
"num-integer 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"ordered-float 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"parking_lot 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
"precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rayon 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"selectors 0.19.0",
@@ -2034,17 +2037,17 @@ dependencies = [
"core-text 9.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"dwrote 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"euclid 0.17.2 (registry+https://github.com/rust-lang/crates.io-index)",
"freetype 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"gleam 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
"plane-split 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rayon 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"ron 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
"thread_profiler 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
"webrender_api 0.57.0",
@@ -2294,17 +2297,17 @@ dependencies = [
"checksum mp4parse_fallible 0.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6626c2aef76eb8f984eef02e475883d3fe9112e114720446c5810fc5f045cd30"
"checksum msdos_time 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "65ba9d75bcea84e07812618fedf284a64776c2f2ea0cad6bca7f69739695a958"
"checksum net2 0.2.31 (registry+https://github.com/rust-lang/crates.io-index)" = "3a80f842784ef6c9a958b68b7516bc7e35883c614004dd94959a4dca1b716c09"
"checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
"checksum nom 1.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "a5b8c256fd9471521bcb84c3cdba98921497f1a331cbc15b8030fc63b82050ce"
"checksum num 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "a311b77ebdc5dd4cf6449d81e4135d9f0e3b153839ac90e648a8ef538f923525"
"checksum num-integer 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)" = "d1452e8b06e448a07f0e6ebb0bb1d92b8890eea63288c0b627331d53514d0fba"
"checksum num-iter 0.1.34 (registry+https://github.com/rust-lang/crates.io-index)" = "7485fcc84f85b4ecd0ea527b14189281cf27d60e583ae65ebc9c088b13dffe01"
-"checksum num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "cacfcab5eb48250ee7d0c7896b51a2c5eec99c1feea5f32025635f5ae4b00070"
+"checksum num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31"
"checksum num-traits 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e7de20f146db9d920c45ee8ed8f71681fd9ade71909b48c3acbd766aa504cf10"
"checksum num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "514f0d73e64be53ff320680ca671b64fe3fb91da01e1ae2ddc99eb51d453b20d"
"checksum ordered-float 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "da12c96037889ae0be29dd2bdd260e5a62a7df24e6466d5a15bb8131c1c200a8"
"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
"checksum parking_lot 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "37f364e2ce5efa24c7d0b6646d5bb61145551a0112f107ffd7499f1a3e322fbd"
"checksum parking_lot_core 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6c677d78851950b3aec390e681a411f78cc250cba277d4f578758a377f727970"
"checksum peeking_take_while 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
"checksum percent-encoding 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "de154f638187706bde41d9b4738748933d64e6b37bdbffc0b47a97d16a6ae356"
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{"Cargo.toml":"3d24ace42f6604297f16fb6e9a8aecb11644083bcc14eccb5d04002146444cd4","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","src/bounds.rs":"c744ca32dcb31447abc1132b2ef6f7c102d4ffa3dbc36a24a384520ec8702839","src/cast.rs":"a067d47329c30672ad9764e34a551cd566b5023f17a35673b35dbab6388043d2","src/float.rs":"fd768b5bb403cd5056d3b588074ed5571c40279d6a7da8c4f3c46ac4713f89fd","src/identities.rs":"ed67758e226fb78a14496776533a6d97d9f813294aadc73958e3005fd0e66599","src/int.rs":"b7b42dfa10423308f858216ac63fa52e26c49a7bc8900cd98de210992efc3f5f","src/lib.rs":"75b1b8b714b51f6169be13e8043bc0e9341a5aeb04e61c5446a5ce5cb241e101","src/ops/checked.rs":"bc667779636f81c7eca138c6d57252a6bb6ca4cd1f0ff706a993067044d86f94","src/ops/mod.rs":"668ea4d117bc1fdf7eaf0fe16692fa40dfbdfcbc7a2010237fe395ce0086e02e","src/ops/saturating.rs":"46821d815c90c16b2f6bec0b94b4d7ebdbddf3ea42edc0467de738c56abf6436","src/ops/wrapping.rs":"a444c7eb3366f2ad4c3a9938f1158b1994b9da4bbf9097884b5e8e27a9b581dd","src/pow.rs":"73b611ad8d595ef917871ba859ff0c25efc2382220d30568e5fbb930bf6b4daa","src/sign.rs":"732736f44c3c410f43da98eb3c8887319d94ad2c4883d614a9c353659402b315"},"package":"cacfcab5eb48250ee7d0c7896b51a2c5eec99c1feea5f32025635f5ae4b00070"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/Cargo.toml
+++ /dev/null
@@ -1,25 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g. crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "num-traits"
-version = "0.1.41"
-authors = ["The Rust Project Developers"]
-description = "Numeric traits for generic mathematics"
-homepage = "https://github.com/rust-num/num"
-documentation = "http://rust-num.github.io/num"
-keywords = ["mathematics", "numerics"]
-categories = ["algorithms", "science"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/rust-num/num"
-
-[dependencies]
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/bounds.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use std::{usize, u8, u16, u32, u64};
-use std::{isize, i8, i16, i32, i64};
-use std::{f32, f64};
-use std::num::Wrapping;
-
-/// Numbers which have upper and lower bounds
-pub trait Bounded {
- // FIXME (#5527): These should be associated constants
- /// returns the smallest finite number this type can represent
- fn min_value() -> Self;
- /// returns the largest finite number this type can represent
- fn max_value() -> Self;
-}
-
-macro_rules! bounded_impl {
- ($t:ty, $min:expr, $max:expr) => {
- impl Bounded for $t {
- #[inline]
- fn min_value() -> $t { $min }
-
- #[inline]
- fn max_value() -> $t { $max }
- }
- }
-}
-
-bounded_impl!(usize, usize::MIN, usize::MAX);
-bounded_impl!(u8, u8::MIN, u8::MAX);
-bounded_impl!(u16, u16::MIN, u16::MAX);
-bounded_impl!(u32, u32::MIN, u32::MAX);
-bounded_impl!(u64, u64::MIN, u64::MAX);
-
-bounded_impl!(isize, isize::MIN, isize::MAX);
-bounded_impl!(i8, i8::MIN, i8::MAX);
-bounded_impl!(i16, i16::MIN, i16::MAX);
-bounded_impl!(i32, i32::MIN, i32::MAX);
-bounded_impl!(i64, i64::MIN, i64::MAX);
-
-impl<T: Bounded> Bounded for Wrapping<T> {
- fn min_value() -> Self { Wrapping(T::min_value()) }
- fn max_value() -> Self { Wrapping(T::max_value()) }
-}
-
-bounded_impl!(f32, f32::MIN, f32::MAX);
-
-macro_rules! for_each_tuple_ {
- ( $m:ident !! ) => (
- $m! { }
- );
- ( $m:ident !! $h:ident, $($t:ident,)* ) => (
- $m! { $h $($t)* }
- for_each_tuple_! { $m !! $($t,)* }
- );
-}
-macro_rules! for_each_tuple {
- ( $m:ident ) => (
- for_each_tuple_! { $m !! A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, }
- );
-}
-
-macro_rules! bounded_tuple {
- ( $($name:ident)* ) => (
- impl<$($name: Bounded,)*> Bounded for ($($name,)*) {
- #[inline]
- fn min_value() -> Self {
- ($($name::min_value(),)*)
- }
- #[inline]
- fn max_value() -> Self {
- ($($name::max_value(),)*)
- }
- }
- );
-}
-
-for_each_tuple!(bounded_tuple);
-bounded_impl!(f64, f64::MIN, f64::MAX);
-
-
-#[test]
-fn wrapping_bounded() {
- 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_wrapping_bounded!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
-}
-
-#[test]
-fn wrapping_is_bounded() {
- fn require_bounded<T: Bounded>(_: &T) {}
- require_bounded(&Wrapping(42_u32));
- require_bounded(&Wrapping(-42));
-}
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/cast.rs
+++ /dev/null
@@ -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()));
-}
-
-#[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));
-}
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/float.rs
+++ /dev/null
@@ -1,1344 +0,0 @@
-use std::mem;
-use std::ops::Neg;
-use std::num::FpCategory;
-
-// Used for default implementation of `epsilon`
-use std::f32;
-
-use {Num, NumCast};
-
-// FIXME: these doctests aren't actually helpful, because they're using and
-// testing the inherent methods directly, not going through `Float`.
-
-pub trait Float
- : Num
- + Copy
- + NumCast
- + PartialOrd
- + Neg<Output = Self>
-{
- /// Returns the `NaN` value.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let nan: f32 = Float::nan();
- ///
- /// assert!(nan.is_nan());
- /// ```
- fn nan() -> Self;
- /// Returns the infinite value.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f32;
- ///
- /// let infinity: f32 = Float::infinity();
- ///
- /// assert!(infinity.is_infinite());
- /// assert!(!infinity.is_finite());
- /// assert!(infinity > f32::MAX);
- /// ```
- fn infinity() -> Self;
- /// Returns the negative infinite value.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f32;
- ///
- /// let neg_infinity: f32 = Float::neg_infinity();
- ///
- /// assert!(neg_infinity.is_infinite());
- /// assert!(!neg_infinity.is_finite());
- /// assert!(neg_infinity < f32::MIN);
- /// ```
- fn neg_infinity() -> Self;
- /// Returns `-0.0`.
- ///
- /// ```
- /// use num_traits::{Zero, Float};
- ///
- /// let inf: f32 = Float::infinity();
- /// let zero: f32 = Zero::zero();
- /// let neg_zero: f32 = Float::neg_zero();
- ///
- /// assert_eq!(zero, neg_zero);
- /// assert_eq!(7.0f32/inf, zero);
- /// assert_eq!(zero * 10.0, zero);
- /// ```
- fn neg_zero() -> Self;
-
- /// Returns the smallest finite value that this type can represent.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x: f64 = Float::min_value();
- ///
- /// assert_eq!(x, f64::MIN);
- /// ```
- fn min_value() -> Self;
-
- /// Returns the smallest positive, normalized value that this type can represent.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x: f64 = Float::min_positive_value();
- ///
- /// assert_eq!(x, f64::MIN_POSITIVE);
- /// ```
- fn min_positive_value() -> Self;
-
- /// Returns epsilon, a small positive value.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x: f64 = Float::epsilon();
- ///
- /// assert_eq!(x, f64::EPSILON);
- /// ```
- ///
- /// # Panics
- ///
- /// The default implementation will panic if `f32::EPSILON` cannot
- /// be cast to `Self`.
- fn epsilon() -> Self {
- Self::from(f32::EPSILON).expect("Unable to cast from f32::EPSILON")
- }
-
- /// Returns the largest finite value that this type can represent.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x: f64 = Float::max_value();
- /// assert_eq!(x, f64::MAX);
- /// ```
- fn max_value() -> Self;
-
- /// Returns `true` if this value is `NaN` and false otherwise.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let nan = f64::NAN;
- /// let f = 7.0;
- ///
- /// assert!(nan.is_nan());
- /// assert!(!f.is_nan());
- /// ```
- fn is_nan(self) -> bool;
-
- /// Returns `true` if this value is positive infinity or negative infinity and
- /// false otherwise.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f32;
- ///
- /// let f = 7.0f32;
- /// let inf: f32 = Float::infinity();
- /// let neg_inf: f32 = Float::neg_infinity();
- /// let nan: f32 = f32::NAN;
- ///
- /// assert!(!f.is_infinite());
- /// assert!(!nan.is_infinite());
- ///
- /// assert!(inf.is_infinite());
- /// assert!(neg_inf.is_infinite());
- /// ```
- fn is_infinite(self) -> bool;
-
- /// Returns `true` if this number is neither infinite nor `NaN`.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f32;
- ///
- /// let f = 7.0f32;
- /// let inf: f32 = Float::infinity();
- /// let neg_inf: f32 = Float::neg_infinity();
- /// let nan: f32 = f32::NAN;
- ///
- /// assert!(f.is_finite());
- ///
- /// assert!(!nan.is_finite());
- /// assert!(!inf.is_finite());
- /// assert!(!neg_inf.is_finite());
- /// ```
- fn is_finite(self) -> bool;
-
- /// Returns `true` if the number is neither zero, infinite,
- /// [subnormal][subnormal], or `NaN`.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f32;
- ///
- /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32
- /// let max = f32::MAX;
- /// let lower_than_min = 1.0e-40_f32;
- /// let zero = 0.0f32;
- ///
- /// assert!(min.is_normal());
- /// assert!(max.is_normal());
- ///
- /// assert!(!zero.is_normal());
- /// assert!(!f32::NAN.is_normal());
- /// assert!(!f32::INFINITY.is_normal());
- /// // Values between `0` and `min` are Subnormal.
- /// assert!(!lower_than_min.is_normal());
- /// ```
- /// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number
- fn is_normal(self) -> bool;
-
- /// Returns the floating point category of the number. If only one property
- /// is going to be tested, it is generally faster to use the specific
- /// predicate instead.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::num::FpCategory;
- /// use std::f32;
- ///
- /// let num = 12.4f32;
- /// let inf = f32::INFINITY;
- ///
- /// assert_eq!(num.classify(), FpCategory::Normal);
- /// assert_eq!(inf.classify(), FpCategory::Infinite);
- /// ```
- fn classify(self) -> FpCategory;
-
- /// Returns the largest integer less than or equal to a number.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let f = 3.99;
- /// let g = 3.0;
- ///
- /// assert_eq!(f.floor(), 3.0);
- /// assert_eq!(g.floor(), 3.0);
- /// ```
- fn floor(self) -> Self;
-
- /// Returns the smallest integer greater than or equal to a number.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let f = 3.01;
- /// let g = 4.0;
- ///
- /// assert_eq!(f.ceil(), 4.0);
- /// assert_eq!(g.ceil(), 4.0);
- /// ```
- fn ceil(self) -> Self;
-
- /// Returns the nearest integer to a number. Round half-way cases away from
- /// `0.0`.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let f = 3.3;
- /// let g = -3.3;
- ///
- /// assert_eq!(f.round(), 3.0);
- /// assert_eq!(g.round(), -3.0);
- /// ```
- fn round(self) -> Self;
-
- /// Return the integer part of a number.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let f = 3.3;
- /// let g = -3.7;
- ///
- /// assert_eq!(f.trunc(), 3.0);
- /// assert_eq!(g.trunc(), -3.0);
- /// ```
- fn trunc(self) -> Self;
-
- /// Returns the fractional part of a number.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 3.5;
- /// let y = -3.5;
- /// let abs_difference_x = (x.fract() - 0.5).abs();
- /// let abs_difference_y = (y.fract() - (-0.5)).abs();
- ///
- /// assert!(abs_difference_x < 1e-10);
- /// assert!(abs_difference_y < 1e-10);
- /// ```
- fn fract(self) -> Self;
-
- /// Computes the absolute value of `self`. Returns `Float::nan()` if the
- /// number is `Float::nan()`.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x = 3.5;
- /// let y = -3.5;
- ///
- /// let abs_difference_x = (x.abs() - x).abs();
- /// let abs_difference_y = (y.abs() - (-y)).abs();
- ///
- /// assert!(abs_difference_x < 1e-10);
- /// assert!(abs_difference_y < 1e-10);
- ///
- /// assert!(f64::NAN.abs().is_nan());
- /// ```
- fn abs(self) -> Self;
-
- /// Returns a number that represents the sign of `self`.
- ///
- /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()`
- /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()`
- /// - `Float::nan()` if the number is `Float::nan()`
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let f = 3.5;
- ///
- /// assert_eq!(f.signum(), 1.0);
- /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0);
- ///
- /// assert!(f64::NAN.signum().is_nan());
- /// ```
- fn signum(self) -> Self;
-
- /// Returns `true` if `self` is positive, including `+0.0`,
- /// `Float::infinity()`, and with newer versions of Rust `f64::NAN`.
- ///
- /// ```
- /// use num_traits::Float;
- /// 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::Float;
- /// 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. This produces a more accurate result with better performance than
- /// a separate multiplication operation followed by an add.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let m = 10.0;
- /// let x = 4.0;
- /// let b = 60.0;
- ///
- /// // 100.0
- /// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn mul_add(self, a: Self, b: Self) -> Self;
- /// Take the reciprocal (inverse) of a number, `1/x`.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 2.0;
- /// let abs_difference = (x.recip() - (1.0/x)).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn recip(self) -> Self;
-
- /// Raise a number to an integer power.
- ///
- /// Using this function is generally faster than using `powf`
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 2.0;
- /// let abs_difference = (x.powi(2) - x*x).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn powi(self, n: i32) -> Self;
-
- /// Raise a number to a floating point power.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 2.0;
- /// let abs_difference = (x.powf(2.0) - x*x).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn powf(self, n: Self) -> Self;
-
- /// Take the square root of a number.
- ///
- /// Returns NaN if `self` is a negative number.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let positive = 4.0;
- /// let negative = -4.0;
- ///
- /// let abs_difference = (positive.sqrt() - 2.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// assert!(negative.sqrt().is_nan());
- /// ```
- fn sqrt(self) -> Self;
-
- /// Returns `e^(self)`, (the exponential function).
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let one = 1.0;
- /// // e^1
- /// let e = one.exp();
- ///
- /// // ln(e) - 1 == 0
- /// let abs_difference = (e.ln() - 1.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn exp(self) -> Self;
-
- /// Returns `2^(self)`.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let f = 2.0;
- ///
- /// // 2^2 - 4 == 0
- /// let abs_difference = (f.exp2() - 4.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn exp2(self) -> Self;
-
- /// Returns the natural logarithm of the number.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let one = 1.0;
- /// // e^1
- /// let e = one.exp();
- ///
- /// // ln(e) - 1 == 0
- /// let abs_difference = (e.ln() - 1.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn ln(self) -> Self;
-
- /// Returns the logarithm of the number with respect to an arbitrary base.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let ten = 10.0;
- /// let two = 2.0;
- ///
- /// // log10(10) - 1 == 0
- /// let abs_difference_10 = (ten.log(10.0) - 1.0).abs();
- ///
- /// // log2(2) - 1 == 0
- /// let abs_difference_2 = (two.log(2.0) - 1.0).abs();
- ///
- /// assert!(abs_difference_10 < 1e-10);
- /// assert!(abs_difference_2 < 1e-10);
- /// ```
- fn log(self, base: Self) -> Self;
-
- /// Returns the base 2 logarithm of the number.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let two = 2.0;
- ///
- /// // log2(2) - 1 == 0
- /// let abs_difference = (two.log2() - 1.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn log2(self) -> Self;
-
- /// Returns the base 10 logarithm of the number.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let ten = 10.0;
- ///
- /// // log10(10) - 1 == 0
- /// let abs_difference = (ten.log10() - 1.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn log10(self) -> Self;
-
- /// 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);
- /// ```
- #[inline]
- fn to_degrees(self) -> Self {
- let halfpi = Self::zero().acos();
- let ninety = Self::from(90u8).unwrap();
- self * ninety / halfpi
- }
-
- /// 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);
- /// ```
- #[inline]
- fn to_radians(self) -> Self {
- let halfpi = Self::zero().acos();
- let ninety = Self::from(90u8).unwrap();
- self * halfpi / ninety
- }
-
- /// Returns the maximum of the two numbers.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 1.0;
- /// let y = 2.0;
- ///
- /// assert_eq!(x.max(y), y);
- /// ```
- fn max(self, other: Self) -> Self;
-
- /// Returns the minimum of the two numbers.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 1.0;
- /// let y = 2.0;
- ///
- /// assert_eq!(x.min(y), x);
- /// ```
- fn min(self, other: Self) -> Self;
-
- /// The positive difference of two numbers.
- ///
- /// * If `self <= other`: `0:0`
- /// * Else: `self - other`
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 3.0;
- /// let y = -3.0;
- ///
- /// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();
- /// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();
- ///
- /// assert!(abs_difference_x < 1e-10);
- /// assert!(abs_difference_y < 1e-10);
- /// ```
- fn abs_sub(self, other: Self) -> Self;
-
- /// Take the cubic root of a number.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 8.0;
- ///
- /// // x^(1/3) - 2 == 0
- /// let abs_difference = (x.cbrt() - 2.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn cbrt(self) -> Self;
-
- /// Calculate the length of the hypotenuse of a right-angle triangle given
- /// legs of length `x` and `y`.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 2.0;
- /// let y = 3.0;
- ///
- /// // sqrt(x^2 + y^2)
- /// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn hypot(self, other: Self) -> Self;
-
- /// Computes the sine of a number (in radians).
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x = f64::consts::PI/2.0;
- ///
- /// let abs_difference = (x.sin() - 1.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn sin(self) -> Self;
-
- /// Computes the cosine of a number (in radians).
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x = 2.0*f64::consts::PI;
- ///
- /// let abs_difference = (x.cos() - 1.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn cos(self) -> Self;
-
- /// Computes the tangent of a number (in radians).
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x = f64::consts::PI/4.0;
- /// let abs_difference = (x.tan() - 1.0).abs();
- ///
- /// assert!(abs_difference < 1e-14);
- /// ```
- fn tan(self) -> Self;
-
- /// Computes the arcsine of a number. Return value is in radians in
- /// the range [-pi/2, pi/2] or NaN if the number is outside the range
- /// [-1, 1].
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let f = f64::consts::PI / 2.0;
- ///
- /// // asin(sin(pi/2))
- /// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn asin(self) -> Self;
-
- /// Computes the arccosine of a number. Return value is in radians in
- /// the range [0, pi] or NaN if the number is outside the range
- /// [-1, 1].
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let f = f64::consts::PI / 4.0;
- ///
- /// // acos(cos(pi/4))
- /// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn acos(self) -> Self;
-
- /// Computes the arctangent of a number. Return value is in radians in the
- /// range [-pi/2, pi/2];
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let f = 1.0;
- ///
- /// // atan(tan(1))
- /// let abs_difference = (f.tan().atan() - 1.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn atan(self) -> Self;
-
- /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`).
- ///
- /// * `x = 0`, `y = 0`: `0`
- /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
- /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
- /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let pi = f64::consts::PI;
- /// // All angles from horizontal right (+x)
- /// // 45 deg counter-clockwise
- /// let x1 = 3.0;
- /// let y1 = -3.0;
- ///
- /// // 135 deg clockwise
- /// let x2 = -3.0;
- /// let y2 = 3.0;
- ///
- /// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs();
- /// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs();
- ///
- /// assert!(abs_difference_1 < 1e-10);
- /// assert!(abs_difference_2 < 1e-10);
- /// ```
- fn atan2(self, other: Self) -> Self;
-
- /// Simultaneously computes the sine and cosine of the number, `x`. Returns
- /// `(sin(x), cos(x))`.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x = f64::consts::PI/4.0;
- /// let f = x.sin_cos();
- ///
- /// let abs_difference_0 = (f.0 - x.sin()).abs();
- /// let abs_difference_1 = (f.1 - x.cos()).abs();
- ///
- /// assert!(abs_difference_0 < 1e-10);
- /// assert!(abs_difference_0 < 1e-10);
- /// ```
- fn sin_cos(self) -> (Self, Self);
-
- /// Returns `e^(self) - 1` in a way that is accurate even if the
- /// number is close to zero.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 7.0;
- ///
- /// // e^(ln(7)) - 1
- /// let abs_difference = (x.ln().exp_m1() - 6.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn exp_m1(self) -> Self;
-
- /// Returns `ln(1+n)` (natural logarithm) more accurately than if
- /// the operations were performed separately.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let x = f64::consts::E - 1.0;
- ///
- /// // ln(1 + (e - 1)) == ln(e) == 1
- /// let abs_difference = (x.ln_1p() - 1.0).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn ln_1p(self) -> Self;
-
- /// Hyperbolic sine function.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let e = f64::consts::E;
- /// let x = 1.0;
- ///
- /// let f = x.sinh();
- /// // Solving sinh() at 1 gives `(e^2-1)/(2e)`
- /// let g = (e*e - 1.0)/(2.0*e);
- /// let abs_difference = (f - g).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- fn sinh(self) -> Self;
-
- /// Hyperbolic cosine function.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let e = f64::consts::E;
- /// let x = 1.0;
- /// let f = x.cosh();
- /// // Solving cosh() at 1 gives this result
- /// let g = (e*e + 1.0)/(2.0*e);
- /// let abs_difference = (f - g).abs();
- ///
- /// // Same result
- /// assert!(abs_difference < 1.0e-10);
- /// ```
- fn cosh(self) -> Self;
-
- /// Hyperbolic tangent function.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let e = f64::consts::E;
- /// let x = 1.0;
- ///
- /// let f = x.tanh();
- /// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))`
- /// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2));
- /// let abs_difference = (f - g).abs();
- ///
- /// assert!(abs_difference < 1.0e-10);
- /// ```
- fn tanh(self) -> Self;
-
- /// Inverse hyperbolic sine function.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 1.0;
- /// let f = x.sinh().asinh();
- ///
- /// let abs_difference = (f - x).abs();
- ///
- /// assert!(abs_difference < 1.0e-10);
- /// ```
- fn asinh(self) -> Self;
-
- /// Inverse hyperbolic cosine function.
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let x = 1.0;
- /// let f = x.cosh().acosh();
- ///
- /// let abs_difference = (f - x).abs();
- ///
- /// assert!(abs_difference < 1.0e-10);
- /// ```
- fn acosh(self) -> Self;
-
- /// Inverse hyperbolic tangent function.
- ///
- /// ```
- /// use num_traits::Float;
- /// use std::f64;
- ///
- /// let e = f64::consts::E;
- /// let f = e.tanh().atanh();
- ///
- /// let abs_difference = (f - e).abs();
- ///
- /// assert!(abs_difference < 1.0e-10);
- /// ```
- fn atanh(self) -> Self;
-
-
- /// Returns the mantissa, base 2 exponent, and sign as integers, respectively.
- /// The original number can be recovered by `sign * mantissa * 2 ^ exponent`.
- /// The floating point encoding is documented in the [Reference][floating-point].
- ///
- /// ```
- /// use num_traits::Float;
- ///
- /// let num = 2.0f32;
- ///
- /// // (8388608, -22, 1)
- /// let (mantissa, exponent, sign) = Float::integer_decode(num);
- /// let sign_f = sign as f32;
- /// let mantissa_f = mantissa as f32;
- /// let exponent_f = num.powf(exponent as f32);
- ///
- /// // 1 * 8388608 * 2^(-22) == 2
- /// let abs_difference = (sign_f * mantissa_f * exponent_f - num).abs();
- ///
- /// assert!(abs_difference < 1e-10);
- /// ```
- /// [floating-point]: ../../../../../reference.html#machine-types
- fn integer_decode(self) -> (u64, i16, i8);
-}
-
-macro_rules! float_impl {
- ($T:ident $decode:ident) => (
- impl Float for $T {
- #[inline]
- fn nan() -> Self {
- ::std::$T::NAN
- }
-
- #[inline]
- fn infinity() -> Self {
- ::std::$T::INFINITY
- }
-
- #[inline]
- fn neg_infinity() -> Self {
- ::std::$T::NEG_INFINITY
- }
-
- #[inline]
- fn neg_zero() -> Self {
- -0.0
- }
-
- #[inline]
- fn min_value() -> Self {
- ::std::$T::MIN
- }
-
- #[inline]
- fn min_positive_value() -> Self {
- ::std::$T::MIN_POSITIVE
- }
-
- #[inline]
- fn epsilon() -> Self {
- ::std::$T::EPSILON
- }
-
- #[inline]
- fn max_value() -> Self {
- ::std::$T::MAX
- }
-
- #[inline]
- fn is_nan(self) -> bool {
- <$T>::is_nan(self)
- }
-
- #[inline]
- fn is_infinite(self) -> bool {
- <$T>::is_infinite(self)
- }
-
- #[inline]
- fn is_finite(self) -> bool {
- <$T>::is_finite(self)
- }
-
- #[inline]
- fn is_normal(self) -> bool {
- <$T>::is_normal(self)
- }
-
- #[inline]
- fn classify(self) -> FpCategory {
- <$T>::classify(self)
- }
-
- #[inline]
- fn floor(self) -> Self {
- <$T>::floor(self)
- }
-
- #[inline]
- fn ceil(self) -> Self {
- <$T>::ceil(self)
- }
-
- #[inline]
- fn round(self) -> Self {
- <$T>::round(self)
- }
-
- #[inline]
- fn trunc(self) -> Self {
- <$T>::trunc(self)
- }
-
- #[inline]
- fn fract(self) -> Self {
- <$T>::fract(self)
- }
-
- #[inline]
- fn abs(self) -> Self {
- <$T>::abs(self)
- }
-
- #[inline]
- fn signum(self) -> Self {
- <$T>::signum(self)
- }
-
- #[inline]
- fn is_sign_positive(self) -> bool {
- <$T>::is_sign_positive(self)
- }
-
- #[inline]
- fn is_sign_negative(self) -> bool {
- <$T>::is_sign_negative(self)
- }
-
- #[inline]
- fn mul_add(self, a: Self, b: Self) -> Self {
- <$T>::mul_add(self, a, b)
- }
-
- #[inline]
- fn recip(self) -> Self {
- <$T>::recip(self)
- }
-
- #[inline]
- fn powi(self, n: i32) -> Self {
- <$T>::powi(self, n)
- }
-
- #[inline]
- fn powf(self, n: Self) -> Self {
- <$T>::powf(self, n)
- }
-
- #[inline]
- fn sqrt(self) -> Self {
- <$T>::sqrt(self)
- }
-
- #[inline]
- fn exp(self) -> Self {
- <$T>::exp(self)
- }
-
- #[inline]
- fn exp2(self) -> Self {
- <$T>::exp2(self)
- }
-
- #[inline]
- fn ln(self) -> Self {
- <$T>::ln(self)
- }
-
- #[inline]
- fn log(self, base: Self) -> Self {
- <$T>::log(self, base)
- }
-
- #[inline]
- fn log2(self) -> Self {
- <$T>::log2(self)
- }
-
- #[inline]
- fn log10(self) -> Self {
- <$T>::log10(self)
- }
-
- #[inline]
- fn to_degrees(self) -> Self {
- // NB: `f32` didn't stabilize this until 1.7
- // <$T>::to_degrees(self)
- self * (180. / ::std::$T::consts::PI)
- }
-
- #[inline]
- fn to_radians(self) -> Self {
- // NB: `f32` didn't stabilize this until 1.7
- // <$T>::to_radians(self)
- self * (::std::$T::consts::PI / 180.)
- }
-
- #[inline]
- fn max(self, other: Self) -> Self {
- <$T>::max(self, other)
- }
-
- #[inline]
- fn min(self, other: Self) -> Self {
- <$T>::min(self, other)
- }
-
- #[inline]
- #[allow(deprecated)]
- fn abs_sub(self, other: Self) -> Self {
- <$T>::abs_sub(self, other)
- }
-
- #[inline]
- fn cbrt(self) -> Self {
- <$T>::cbrt(self)
- }
-
- #[inline]
- fn hypot(self, other: Self) -> Self {
- <$T>::hypot(self, other)
- }
-
- #[inline]
- fn sin(self) -> Self {
- <$T>::sin(self)
- }
-
- #[inline]
- fn cos(self) -> Self {
- <$T>::cos(self)
- }
-
- #[inline]
- fn tan(self) -> Self {
- <$T>::tan(self)
- }
-
- #[inline]
- fn asin(self) -> Self {
- <$T>::asin(self)
- }
-
- #[inline]
- fn acos(self) -> Self {
- <$T>::acos(self)
- }
-
- #[inline]
- fn atan(self) -> Self {
- <$T>::atan(self)
- }
-
- #[inline]
- fn atan2(self, other: Self) -> Self {
- <$T>::atan2(self, other)
- }
-
- #[inline]
- fn sin_cos(self) -> (Self, Self) {
- <$T>::sin_cos(self)
- }
-
- #[inline]
- fn exp_m1(self) -> Self {
- <$T>::exp_m1(self)
- }
-
- #[inline]
- fn ln_1p(self) -> Self {
- <$T>::ln_1p(self)
- }
-
- #[inline]
- fn sinh(self) -> Self {
- <$T>::sinh(self)
- }
-
- #[inline]
- fn cosh(self) -> Self {
- <$T>::cosh(self)
- }
-
- #[inline]
- fn tanh(self) -> Self {
- <$T>::tanh(self)
- }
-
- #[inline]
- fn asinh(self) -> Self {
- <$T>::asinh(self)
- }
-
- #[inline]
- fn acosh(self) -> Self {
- <$T>::acosh(self)
- }
-
- #[inline]
- fn atanh(self) -> Self {
- <$T>::atanh(self)
- }
-
- #[inline]
- fn integer_decode(self) -> (u64, i16, i8) {
- $decode(self)
- }
- }
- )
-}
-
-fn integer_decode_f32(f: f32) -> (u64, i16, i8) {
- let bits: u32 = unsafe { mem::transmute(f) };
- let sign: i8 = if bits >> 31 == 0 {
- 1
- } else {
- -1
- };
- let mut exponent: i16 = ((bits >> 23) & 0xff) as i16;
- let mantissa = if exponent == 0 {
- (bits & 0x7fffff) << 1
- } else {
- (bits & 0x7fffff) | 0x800000
- };
- // Exponent bias + mantissa shift
- exponent -= 127 + 23;
- (mantissa as u64, exponent, sign)
-}
-
-fn integer_decode_f64(f: f64) -> (u64, i16, i8) {
- let bits: u64 = unsafe { mem::transmute(f) };
- let sign: i8 = if bits >> 63 == 0 {
- 1
- } else {
- -1
- };
- let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16;
- let mantissa = if exponent == 0 {
- (bits & 0xfffffffffffff) << 1
- } else {
- (bits & 0xfffffffffffff) | 0x10000000000000
- };
- // Exponent bias + mantissa shift
- exponent -= 1023 + 52;
- (mantissa, exponent, sign)
-}
-
-float_impl!(f32 integer_decode_f32);
-float_impl!(f64 integer_decode_f64);
-
-macro_rules! float_const_impl {
- ($(#[$doc:meta] $constant:ident,)+) => (
- #[allow(non_snake_case)]
- pub trait FloatConst {
- $(#[$doc] fn $constant() -> Self;)+
- }
- float_const_impl! { @float f32, $($constant,)+ }
- float_const_impl! { @float f64, $($constant,)+ }
- );
- (@float $T:ident, $($constant:ident,)+) => (
- impl FloatConst for $T {
- $(
- #[inline]
- fn $constant() -> Self {
- ::std::$T::consts::$constant
- }
- )+
- }
- );
-}
-
-float_const_impl! {
- #[doc = "Return Euler’s number."]
- E,
- #[doc = "Return `1.0 / π`."]
- FRAC_1_PI,
- #[doc = "Return `1.0 / sqrt(2.0)`."]
- FRAC_1_SQRT_2,
- #[doc = "Return `2.0 / π`."]
- FRAC_2_PI,
- #[doc = "Return `2.0 / sqrt(Ï€)`."]
- FRAC_2_SQRT_PI,
- #[doc = "Return `Ï€ / 2.0`."]
- FRAC_PI_2,
- #[doc = "Return `Ï€ / 3.0`."]
- FRAC_PI_3,
- #[doc = "Return `Ï€ / 4.0`."]
- FRAC_PI_4,
- #[doc = "Return `Ï€ / 6.0`."]
- FRAC_PI_6,
- #[doc = "Return `Ï€ / 8.0`."]
- FRAC_PI_8,
- #[doc = "Return `ln(10.0)`."]
- LN_10,
- #[doc = "Return `ln(2.0)`."]
- LN_2,
- #[doc = "Return `log10(e)`."]
- LOG10_E,
- #[doc = "Return `log2(e)`."]
- LOG2_E,
- #[doc = "Return Archimedes’ constant."]
- PI,
- #[doc = "Return `sqrt(2.0)`."]
- SQRT_2,
-}
-
-#[cfg(test)]
-mod tests {
- use Float;
-
- #[test]
- fn convert_deg_rad() {
- use std::f64::consts;
-
- const DEG_RAD_PAIRS: [(f64, f64); 7] = [
- (0.0, 0.),
- (22.5, consts::FRAC_PI_8),
- (30.0, consts::FRAC_PI_6),
- (45.0, consts::FRAC_PI_4),
- (60.0, consts::FRAC_PI_3),
- (90.0, consts::FRAC_PI_2),
- (180.0, consts::PI),
- ];
-
- for &(deg, rad) in &DEG_RAD_PAIRS {
- assert!((Float::to_degrees(rad) - deg).abs() < 1e-6);
- assert!((Float::to_radians(deg) - rad).abs() < 1e-6);
-
- let (deg, rad) = (deg as f32, rad as f32);
- assert!((Float::to_degrees(rad) - deg).abs() < 1e-6);
- assert!((Float::to_radians(deg) - rad).abs() < 1e-6);
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/identities.rs
+++ /dev/null
@@ -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() }
-
-
-#[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));
-}
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/int.rs
+++ /dev/null
@@ -1,376 +0,0 @@
-use std::ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
-
-use {Num, NumCast};
-use bounds::Bounded;
-use ops::checked::*;
-use ops::saturating::Saturating;
-
-pub trait PrimInt
- : Sized
- + Copy
- + Num + NumCast
- + Bounded
- + PartialOrd + Ord + Eq
- + Not<Output=Self>
- + BitAnd<Output=Self>
- + BitOr<Output=Self>
- + BitXor<Output=Self>
- + Shl<usize, Output=Self>
- + Shr<usize, Output=Self>
- + CheckedAdd<Output=Self>
- + CheckedSub<Output=Self>
- + CheckedMul<Output=Self>
- + CheckedDiv<Output=Self>
- + Saturating
-{
- /// Returns the number of ones in the binary representation of `self`.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0b01001100u8;
- ///
- /// assert_eq!(n.count_ones(), 3);
- /// ```
- fn count_ones(self) -> u32;
-
- /// Returns the number of zeros in the binary representation of `self`.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0b01001100u8;
- ///
- /// assert_eq!(n.count_zeros(), 5);
- /// ```
- fn count_zeros(self) -> u32;
-
- /// Returns the number of leading zeros in the binary representation
- /// of `self`.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0b0101000u16;
- ///
- /// assert_eq!(n.leading_zeros(), 10);
- /// ```
- fn leading_zeros(self) -> u32;
-
- /// Returns the number of trailing zeros in the binary representation
- /// of `self`.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0b0101000u16;
- ///
- /// assert_eq!(n.trailing_zeros(), 3);
- /// ```
- fn trailing_zeros(self) -> u32;
-
- /// Shifts the bits to the left by a specified amount amount, `n`, wrapping
- /// the truncated bits to the end of the resulting integer.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0x0123456789ABCDEFu64;
- /// let m = 0x3456789ABCDEF012u64;
- ///
- /// assert_eq!(n.rotate_left(12), m);
- /// ```
- fn rotate_left(self, n: u32) -> Self;
-
- /// Shifts the bits to the right by a specified amount amount, `n`, wrapping
- /// the truncated bits to the beginning of the resulting integer.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0x0123456789ABCDEFu64;
- /// let m = 0xDEF0123456789ABCu64;
- ///
- /// assert_eq!(n.rotate_right(12), m);
- /// ```
- fn rotate_right(self, n: u32) -> Self;
-
- /// Shifts the bits to the left by a specified amount amount, `n`, filling
- /// zeros in the least significant bits.
- ///
- /// This is bitwise equivalent to signed `Shl`.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0x0123456789ABCDEFu64;
- /// let m = 0x3456789ABCDEF000u64;
- ///
- /// assert_eq!(n.signed_shl(12), m);
- /// ```
- fn signed_shl(self, n: u32) -> Self;
-
- /// Shifts the bits to the right by a specified amount amount, `n`, copying
- /// the "sign bit" in the most significant bits even for unsigned types.
- ///
- /// This is bitwise equivalent to signed `Shr`.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0xFEDCBA9876543210u64;
- /// let m = 0xFFFFEDCBA9876543u64;
- ///
- /// assert_eq!(n.signed_shr(12), m);
- /// ```
- fn signed_shr(self, n: u32) -> Self;
-
- /// Shifts the bits to the left by a specified amount amount, `n`, filling
- /// zeros in the least significant bits.
- ///
- /// This is bitwise equivalent to unsigned `Shl`.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0x0123456789ABCDEFi64;
- /// let m = 0x3456789ABCDEF000i64;
- ///
- /// assert_eq!(n.unsigned_shl(12), m);
- /// ```
- fn unsigned_shl(self, n: u32) -> Self;
-
- /// Shifts the bits to the right by a specified amount amount, `n`, filling
- /// zeros in the most significant bits.
- ///
- /// This is bitwise equivalent to unsigned `Shr`.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0xFEDCBA9876543210i64;
- /// let m = 0x000FEDCBA9876543i64;
- ///
- /// assert_eq!(n.unsigned_shr(12), m);
- /// ```
- fn unsigned_shr(self, n: u32) -> Self;
-
- /// Reverses the byte order of the integer.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0x0123456789ABCDEFu64;
- /// let m = 0xEFCDAB8967452301u64;
- ///
- /// assert_eq!(n.swap_bytes(), m);
- /// ```
- fn swap_bytes(self) -> Self;
-
- /// Convert an integer from big endian to the target's endianness.
- ///
- /// On big endian this is a no-op. On little endian the bytes are swapped.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0x0123456789ABCDEFu64;
- ///
- /// if cfg!(target_endian = "big") {
- /// assert_eq!(u64::from_be(n), n)
- /// } else {
- /// assert_eq!(u64::from_be(n), n.swap_bytes())
- /// }
- /// ```
- fn from_be(x: Self) -> Self;
-
- /// Convert an integer from little endian to the target's endianness.
- ///
- /// On little endian this is a no-op. On big endian the bytes are swapped.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0x0123456789ABCDEFu64;
- ///
- /// if cfg!(target_endian = "little") {
- /// assert_eq!(u64::from_le(n), n)
- /// } else {
- /// assert_eq!(u64::from_le(n), n.swap_bytes())
- /// }
- /// ```
- fn from_le(x: Self) -> Self;
-
- /// Convert `self` to big endian from the target's endianness.
- ///
- /// On big endian this is a no-op. On little endian the bytes are swapped.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0x0123456789ABCDEFu64;
- ///
- /// if cfg!(target_endian = "big") {
- /// assert_eq!(n.to_be(), n)
- /// } else {
- /// assert_eq!(n.to_be(), n.swap_bytes())
- /// }
- /// ```
- fn to_be(self) -> Self;
-
- /// Convert `self` to little endian from the target's endianness.
- ///
- /// On little endian this is a no-op. On big endian the bytes are swapped.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// let n = 0x0123456789ABCDEFu64;
- ///
- /// if cfg!(target_endian = "little") {
- /// assert_eq!(n.to_le(), n)
- /// } else {
- /// assert_eq!(n.to_le(), n.swap_bytes())
- /// }
- /// ```
- fn to_le(self) -> Self;
-
- /// Raises self to the power of `exp`, using exponentiation by squaring.
- ///
- /// # Examples
- ///
- /// ```
- /// use num_traits::PrimInt;
- ///
- /// assert_eq!(2i32.pow(4), 16);
- /// ```
- fn pow(self, exp: u32) -> Self;
-}
-
-macro_rules! prim_int_impl {
- ($T:ty, $S:ty, $U:ty) => (
- impl PrimInt for $T {
- #[inline]
- fn count_ones(self) -> u32 {
- <$T>::count_ones(self)
- }
-
- #[inline]
- fn count_zeros(self) -> u32 {
- <$T>::count_zeros(self)
- }
-
- #[inline]
- fn leading_zeros(self) -> u32 {
- <$T>::leading_zeros(self)
- }
-
- #[inline]
- fn trailing_zeros(self) -> u32 {
- <$T>::trailing_zeros(self)
- }
-
- #[inline]
- fn rotate_left(self, n: u32) -> Self {
- <$T>::rotate_left(self, n)
- }
-
- #[inline]
- fn rotate_right(self, n: u32) -> Self {
- <$T>::rotate_right(self, n)
- }
-
- #[inline]
- fn signed_shl(self, n: u32) -> Self {
- ((self as $S) << n) as $T
- }
-
- #[inline]
- fn signed_shr(self, n: u32) -> Self {
- ((self as $S) >> n) as $T
- }
-
- #[inline]
- fn unsigned_shl(self, n: u32) -> Self {
- ((self as $U) << n) as $T
- }
-
- #[inline]
- fn unsigned_shr(self, n: u32) -> Self {
- ((self as $U) >> n) as $T
- }
-
- #[inline]
- fn swap_bytes(self) -> Self {
- <$T>::swap_bytes(self)
- }
-
- #[inline]
- fn from_be(x: Self) -> Self {
- <$T>::from_be(x)
- }
-
- #[inline]
- fn from_le(x: Self) -> Self {
- <$T>::from_le(x)
- }
-
- #[inline]
- fn to_be(self) -> Self {
- <$T>::to_be(self)
- }
-
- #[inline]
- fn to_le(self) -> Self {
- <$T>::to_le(self)
- }
-
- #[inline]
- fn pow(self, exp: u32) -> Self {
- <$T>::pow(self, exp)
- }
- }
- )
-}
-
-// prim_int_impl!(type, signed, unsigned);
-prim_int_impl!(u8, i8, u8);
-prim_int_impl!(u16, i16, u16);
-prim_int_impl!(u32, i32, u32);
-prim_int_impl!(u64, i64, u64);
-prim_int_impl!(usize, isize, usize);
-prim_int_impl!(i8, i8, u8);
-prim_int_impl!(i16, i16, u16);
-prim_int_impl!(i32, i32, u32);
-prim_int_impl!(i64, i64, u64);
-prim_int_impl!(isize, isize, usize);
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/lib.rs
+++ /dev/null
@@ -1,437 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Numeric traits for generic mathematics
-#![doc(html_logo_url = "https://rust-num.github.io/num/rust-logo-128x128-blk-v2.png",
- html_favicon_url = "https://rust-num.github.io/num/favicon.ico",
- html_root_url = "https://rust-num.github.io/num/",
- html_playground_url = "http://play.integer32.com/")]
-
-use std::ops::{Add, Sub, Mul, Div, Rem};
-use std::ops::{AddAssign, SubAssign, MulAssign, DivAssign, RemAssign};
-use std::num::Wrapping;
-
-pub use bounds::Bounded;
-pub use float::{Float, FloatConst};
-pub use identities::{Zero, One, zero, one};
-pub use ops::checked::*;
-pub use ops::wrapping::*;
-pub use ops::saturating::Saturating;
-pub use sign::{Signed, Unsigned, abs, abs_sub, signum};
-pub use cast::*;
-pub use int::PrimInt;
-pub use pow::{pow, checked_pow};
-
-pub mod identities;
-pub mod sign;
-pub mod ops;
-pub mod bounds;
-pub mod float;
-pub mod cast;
-pub mod int;
-pub mod pow;
-
-/// The base trait for numeric types, covering `0` and `1` values,
-/// comparisons, basic numeric operations, and string conversion.
-pub trait Num: PartialEq + Zero + One + NumOps
-{
- type FromStrRadixErr;
-
- /// Convert from a string and radix <= 36.
- ///
- /// # Examples
- ///
- /// ```rust
- /// use num_traits::Num;
- ///
- /// let result = <i32 as Num>::from_str_radix("27", 10);
- /// assert_eq!(result, Ok(27));
- ///
- /// let result = <i32 as Num>::from_str_radix("foo", 10);
- /// assert!(result.is_err());
- /// ```
- fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>;
-}
-
-/// The trait for types implementing basic numeric operations
-///
-/// This is automatically implemented for types which implement the operators.
-pub trait NumOps<Rhs = Self, Output = Self>
- : Add<Rhs, Output = Output>
- + Sub<Rhs, Output = Output>
- + Mul<Rhs, Output = Output>
- + Div<Rhs, Output = Output>
- + Rem<Rhs, Output = Output>
-{}
-
-impl<T, Rhs, Output> NumOps<Rhs, Output> for T
-where T: Add<Rhs, Output = Output>
- + Sub<Rhs, Output = Output>
- + Mul<Rhs, Output = Output>
- + Div<Rhs, Output = Output>
- + Rem<Rhs, Output = Output>
-{}
-
-/// The trait for `Num` types which also implement numeric operations taking
-/// the second operand by reference.
-///
-/// This is automatically implemented for types which implement the operators.
-pub trait NumRef: Num + for<'r> NumOps<&'r Self> {}
-impl<T> NumRef for T where T: Num + for<'r> NumOps<&'r T> {}
-
-/// The trait for references which implement numeric operations, taking the
-/// second operand either by value or by reference.
-///
-/// This is automatically implemented for types which implement the operators.
-pub trait RefNum<Base>: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base> {}
-impl<T, Base> RefNum<Base> for T where T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base> {}
-
-/// The trait for types implementing numeric assignment operators (like `+=`).
-///
-/// This is automatically implemented for types which implement the operators.
-pub trait NumAssignOps<Rhs = Self>
- : AddAssign<Rhs>
- + SubAssign<Rhs>
- + MulAssign<Rhs>
- + DivAssign<Rhs>
- + RemAssign<Rhs>
-{}
-
-impl<T, Rhs> NumAssignOps<Rhs> for T
-where T: AddAssign<Rhs>
- + SubAssign<Rhs>
- + MulAssign<Rhs>
- + DivAssign<Rhs>
- + RemAssign<Rhs>
-{}
-
-/// The trait for `Num` types which also implement assignment operators.
-///
-/// This is automatically implemented for types which implement the operators.
-pub trait NumAssign: Num + NumAssignOps {}
-impl<T> NumAssign for T where T: Num + NumAssignOps {}
-
-/// The trait for `NumAssign` types which also implement assignment operations
-/// taking the second operand by reference.
-///
-/// This is automatically implemented for types which implement the operators.
-pub trait NumAssignRef: NumAssign + for<'r> NumAssignOps<&'r Self> {}
-impl<T> NumAssignRef for T where T: NumAssign + for<'r> NumAssignOps<&'r T> {}
-
-
-macro_rules! int_trait_impl {
- ($name:ident for $($t:ty)*) => ($(
- impl $name for $t {
- type FromStrRadixErr = ::std::num::ParseIntError;
- #[inline]
- fn from_str_radix(s: &str, radix: u32)
- -> Result<Self, ::std::num::ParseIntError>
- {
- <$t>::from_str_radix(s, radix)
- }
- }
- )*)
-}
-int_trait_impl!(Num for usize u8 u16 u32 u64 isize i8 i16 i32 i64);
-
-impl<T: Num> Num for Wrapping<T>
- where Wrapping<T>:
- Add<Output = Wrapping<T>> + Sub<Output = Wrapping<T>>
- + Mul<Output = Wrapping<T>> + Div<Output = Wrapping<T>> + Rem<Output = Wrapping<T>>
-{
- type FromStrRadixErr = T::FromStrRadixErr;
- fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
- T::from_str_radix(str, radix).map(Wrapping)
- }
-}
-
-
-#[derive(Debug)]
-pub enum FloatErrorKind {
- Empty,
- Invalid,
-}
-// FIXME: std::num::ParseFloatError is stable in 1.0, but opaque to us,
-// so there's not really any way for us to reuse it.
-#[derive(Debug)]
-pub struct ParseFloatError {
- pub kind: FloatErrorKind,
-}
-
-// FIXME: The standard library from_str_radix on floats was deprecated, so we're stuck
-// with this implementation ourselves until we want to make a breaking change.
-// (would have to drop it from `Num` though)
-macro_rules! float_trait_impl {
- ($name:ident for $($t:ty)*) => ($(
- impl $name for $t {
- type FromStrRadixErr = ParseFloatError;
-
- fn from_str_radix(src: &str, radix: u32)
- -> Result<Self, Self::FromStrRadixErr>
- {
- use self::FloatErrorKind::*;
- use self::ParseFloatError as PFE;
-
- // Special values
- match src {
- "inf" => return Ok(Float::infinity()),
- "-inf" => return Ok(Float::neg_infinity()),
- "NaN" => return Ok(Float::nan()),
- _ => {},
- }
-
- fn slice_shift_char(src: &str) -> Option<(char, &str)> {
- src.chars().nth(0).map(|ch| (ch, &src[1..]))
- }
-
- let (is_positive, src) = match slice_shift_char(src) {
- None => return Err(PFE { kind: Empty }),
- Some(('-', "")) => return Err(PFE { kind: Empty }),
- Some(('-', src)) => (false, src),
- Some((_, _)) => (true, src),
- };
-
- // The significand to accumulate
- let mut sig = if is_positive { 0.0 } else { -0.0 };
- // Necessary to detect overflow
- let mut prev_sig = sig;
- let mut cs = src.chars().enumerate();
- // Exponent prefix and exponent index offset
- let mut exp_info = None::<(char, usize)>;
-
- // Parse the integer part of the significand
- for (i, c) in cs.by_ref() {
- match c.to_digit(radix) {
- Some(digit) => {
- // shift significand one digit left
- sig = sig * (radix as $t);
-
- // add/subtract current digit depending on sign
- if is_positive {
- sig = sig + ((digit as isize) as $t);
- } else {
- sig = sig - ((digit as isize) as $t);
- }
-
- // Detect overflow by comparing to last value, except
- // if we've not seen any non-zero digits.
- if prev_sig != 0.0 {
- if is_positive && sig <= prev_sig
- { return Ok(Float::infinity()); }
- if !is_positive && sig >= prev_sig
- { return Ok(Float::neg_infinity()); }
-
- // Detect overflow by reversing the shift-and-add process
- if is_positive && (prev_sig != (sig - digit as $t) / radix as $t)
- { return Ok(Float::infinity()); }
- if !is_positive && (prev_sig != (sig + digit as $t) / radix as $t)
- { return Ok(Float::neg_infinity()); }
- }
- prev_sig = sig;
- },
- None => match c {
- 'e' | 'E' | 'p' | 'P' => {
- exp_info = Some((c, i + 1));
- break; // start of exponent
- },
- '.' => {
- break; // start of fractional part
- },
- _ => {
- return Err(PFE { kind: Invalid });
- },
- },
- }
- }
-
- // If we are not yet at the exponent parse the fractional
- // part of the significand
- if exp_info.is_none() {
- let mut power = 1.0;
- for (i, c) in cs.by_ref() {
- match c.to_digit(radix) {
- Some(digit) => {
- // Decrease power one order of magnitude
- power = power / (radix as $t);
- // add/subtract current digit depending on sign
- sig = if is_positive {
- sig + (digit as $t) * power
- } else {
- sig - (digit as $t) * power
- };
- // Detect overflow by comparing to last value
- if is_positive && sig < prev_sig
- { return Ok(Float::infinity()); }
- if !is_positive && sig > prev_sig
- { return Ok(Float::neg_infinity()); }
- prev_sig = sig;
- },
- None => match c {
- 'e' | 'E' | 'p' | 'P' => {
- exp_info = Some((c, i + 1));
- break; // start of exponent
- },
- _ => {
- return Err(PFE { kind: Invalid });
- },
- },
- }
- }
- }
-
- // Parse and calculate the exponent
- let exp = match exp_info {
- Some((c, offset)) => {
- let base = match c {
- 'E' | 'e' if radix == 10 => 10.0,
- 'P' | 'p' if radix == 16 => 2.0,
- _ => return Err(PFE { kind: Invalid }),
- };
-
- // Parse the exponent as decimal integer
- let src = &src[offset..];
- let (is_positive, exp) = match slice_shift_char(src) {
- Some(('-', src)) => (false, src.parse::<usize>()),
- Some(('+', src)) => (true, src.parse::<usize>()),
- Some((_, _)) => (true, src.parse::<usize>()),
- None => return Err(PFE { kind: Invalid }),
- };
-
- match (is_positive, exp) {
- (true, Ok(exp)) => base.powi(exp as i32),
- (false, Ok(exp)) => 1.0 / base.powi(exp as i32),
- (_, Err(_)) => return Err(PFE { kind: Invalid }),
- }
- },
- None => 1.0, // no exponent
- };
-
- Ok(sig * exp)
- }
- }
- )*)
-}
-float_trait_impl!(Num for f32 f64);
-
-/// A value bounded by a minimum and a maximum
-///
-/// If input is less than min then this returns min.
-/// If input is greater than max then this returns max.
-/// Otherwise this returns input.
-#[inline]
-pub fn clamp<T: PartialOrd>(input: T, min: T, max: T) -> T {
- debug_assert!(min <= max, "min must be less than or equal to max");
- if input < min {
- min
- } else if input > max {
- max
- } else {
- input
- }
-}
-
-#[test]
-fn clamp_test() {
- // Int test
- assert_eq!(1, clamp(1, -1, 2));
- assert_eq!(-1, clamp(-2, -1, 2));
- assert_eq!(2, clamp(3, -1, 2));
-
- // Float test
- assert_eq!(1.0, clamp(1.0, -1.0, 2.0));
- assert_eq!(-1.0, clamp(-2.0, -1.0, 2.0));
- assert_eq!(2.0, clamp(3.0, -1.0, 2.0));
-}
-
-#[test]
-fn from_str_radix_unwrap() {
- // The Result error must impl Debug to allow unwrap()
-
- let i: i32 = Num::from_str_radix("0", 10).unwrap();
- assert_eq!(i, 0);
-
- let f: f32 = Num::from_str_radix("0.0", 10).unwrap();
- assert_eq!(f, 0.0);
-}
-
-#[test]
-fn wrapping_is_num() {
- fn require_num<T: Num>(_: &T) {}
- require_num(&Wrapping(42_u32));
- require_num(&Wrapping(-42));
-}
-
-#[test]
-fn wrapping_from_str_radix() {
- macro_rules! test_wrapping_from_str_radix {
- ($($t:ty)+) => {
- $(
- for &(s, r) in &[("42", 10), ("42", 2), ("-13.0", 10), ("foo", 10)] {
- let w = Wrapping::<$t>::from_str_radix(s, r).map(|w| w.0);
- assert_eq!(w, <$t as Num>::from_str_radix(s, r));
- }
- )+
- };
- }
-
- test_wrapping_from_str_radix!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
-}
-
-#[test]
-fn check_num_ops() {
- fn compute<T: Num + Copy>(x: T, y: T) -> T {
- x * y / y % y + y - y
- }
- assert_eq!(compute(1, 2), 1)
-}
-
-#[test]
-fn check_numref_ops() {
- fn compute<T: NumRef>(x: T, y: &T) -> T {
- x * y / y % y + y - y
- }
- assert_eq!(compute(1, &2), 1)
-}
-
-#[test]
-fn check_refnum_ops() {
- fn compute<T: Copy>(x: &T, y: T) -> T
- where for<'a> &'a T: RefNum<T>
- {
- &(&(&(&(x * y) / y) % y) + y) - y
- }
- assert_eq!(compute(&1, 2), 1)
-}
-
-#[test]
-fn check_refref_ops() {
- fn compute<T>(x: &T, y: &T) -> T
- where for<'a> &'a T: RefNum<T>
- {
- &(&(&(&(x * y) / y) % y) + y) - y
- }
- assert_eq!(compute(&1, &2), 1)
-}
-
-#[test]
-fn check_numassign_ops() {
- fn compute<T: NumAssign + Copy>(mut x: T, y: T) -> T {
- x *= y;
- x /= y;
- x %= y;
- x += y;
- x -= y;
- x
- }
- assert_eq!(compute(1, 2), 1)
-}
-
-// TODO test `NumAssignRef`, but even the standard numeric types don't
-// implement this yet. (see rust pr41336)
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/ops/checked.rs
+++ /dev/null
@@ -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);
-
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/ops/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod saturating;
-pub mod checked;
-pub mod wrapping;
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/ops/saturating.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-/// Saturating math operations
-pub trait Saturating {
- /// Saturating addition operator.
- /// Returns a+b, saturating at the numeric bounds instead of overflowing.
- fn saturating_add(self, v: Self) -> Self;
-
- /// Saturating subtraction operator.
- /// Returns a-b, saturating at the numeric bounds instead of overflowing.
- fn saturating_sub(self, v: Self) -> Self;
-}
-
-macro_rules! saturating_impl {
- ($trait_name:ident for $($t:ty)*) => {$(
- impl $trait_name for $t {
- #[inline]
- fn saturating_add(self, v: Self) -> Self {
- Self::saturating_add(self, v)
- }
-
- #[inline]
- fn saturating_sub(self, v: Self) -> Self {
- Self::saturating_sub(self, v)
- }
- }
- )*}
-}
-
-saturating_impl!(Saturating for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/ops/wrapping.rs
+++ /dev/null
@@ -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));
-}
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/pow.rs
+++ /dev/null
@@ -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)
-}
deleted file mode 100644
--- a/third_party/rust/num-traits-0.1.41/src/sign.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-use std::ops::Neg;
-use std::{f32, f64};
-use std::num::Wrapping;
-
-use Num;
-
-/// Useful functions for signed numbers (i.e. numbers that can be negative).
-pub trait Signed: Sized + Num + Neg<Output = Self> {
- /// Computes the absolute value.
- ///
- /// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`.
- ///
- /// For signed integers, `::MIN` will be returned if the number is `::MIN`.
- fn abs(&self) -> Self;
-
- /// The positive difference of two numbers.
- ///
- /// Returns `zero` if the number is less than or equal to `other`, otherwise the difference
- /// between `self` and `other` is returned.
- fn abs_sub(&self, other: &Self) -> Self;
-
- /// Returns the sign of the number.
- ///
- /// For `f32` and `f64`:
- ///
- /// * `1.0` if the number is positive, `+0.0` or `INFINITY`
- /// * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
- /// * `NaN` if the number is `NaN`
- ///
- /// For signed integers:
- ///
- /// * `0` if the number is zero
- /// * `1` if the number is positive
- /// * `-1` if the number is negative
- fn signum(&self) -> Self;
-
- /// Returns true if the number is positive and false if the number is zero or negative.
- fn is_positive(&self) -> bool;
-
- /// Returns true if the number is negative and false if the number is zero or positive.
- fn is_negative(&self) -> bool;
-}
-
-macro_rules! signed_impl {
- ($($t:ty)*) => ($(
- impl Signed for $t {
- #[inline]
- fn abs(&self) -> $t {
- if self.is_negative() { -*self } else { *self }
- }
-
- #[inline]
- fn abs_sub(&self, other: &$t) -> $t {
- if *self <= *other { 0 } else { *self - *other }
- }
-
- #[inline]
- fn signum(&self) -> $t {
- match *self {
- n if n > 0 => 1,
- 0 => 0,
- _ => -1,
- }
- }
-
- #[inline]
- fn is_positive(&self) -> bool { *self > 0 }
-
- #[inline]
- fn is_negative(&self) -> bool { *self < 0 }
- }
- )*)
-}
-
-signed_impl!(isize i8 i16 i32 i64);
-
-impl<T: Signed> Signed for Wrapping<T> where Wrapping<T>: Num + Neg<Output=Wrapping<T>>
-{
- #[inline]
- fn abs(&self) -> Self {
- Wrapping(self.0.abs())
- }
-
- #[inline]
- fn abs_sub(&self, other: &Self) -> Self {
- Wrapping(self.0.abs_sub(&other.0))
- }
-
- #[inline]
- fn signum(&self) -> Self {
- Wrapping(self.0.signum())
- }
-
- #[inline]
- fn is_positive(&self) -> bool { self.0.is_positive() }
-
- #[inline]
- fn is_negative(&self) -> bool { self.0.is_negative() }
-}
-
-macro_rules! signed_float_impl {
- ($t:ty, $nan:expr, $inf:expr, $neg_inf:expr) => {
- impl Signed for $t {
- /// Computes the absolute value. Returns `NAN` if the number is `NAN`.
- #[inline]
- fn abs(&self) -> $t {
- <$t>::abs(*self)
- }
-
- /// The positive difference of two numbers. Returns `0.0` if the number is
- /// less than or equal to `other`, otherwise the difference between`self`
- /// and `other` is returned.
- #[inline]
- #[allow(deprecated)]
- fn abs_sub(&self, other: &$t) -> $t {
- <$t>::abs_sub(*self, *other)
- }
-
- /// # Returns
- ///
- /// - `1.0` if the number is positive, `+0.0` or `INFINITY`
- /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
- /// - `NAN` if the number is NaN
- #[inline]
- fn signum(&self) -> $t {
- <$t>::signum(*self)
- }
-
- /// Returns `true` if the number is positive, including `+0.0` and `INFINITY`
- #[inline]
- fn is_positive(&self) -> bool { *self > 0.0 || (1.0 / *self) == $inf }
-
- /// Returns `true` if the number is negative, including `-0.0` and `NEG_INFINITY`
- #[inline]
- fn is_negative(&self) -> bool { *self < 0.0 || (1.0 / *self) == $neg_inf }
- }
- }
-}
-
-signed_float_impl!(f32, f32::NAN, f32::INFINITY, f32::NEG_INFINITY);
-signed_float_impl!(f64, f64::NAN, f64::INFINITY, f64::NEG_INFINITY);
-
-/// Computes the absolute value.
-///
-/// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`
-///
-/// For signed integers, `::MIN` will be returned if the number is `::MIN`.
-#[inline(always)]
-pub fn abs<T: Signed>(value: T) -> T {
- value.abs()
-}
-
-/// The positive difference of two numbers.
-///
-/// Returns zero if `x` is less than or equal to `y`, otherwise the difference
-/// between `x` and `y` is returned.
-#[inline(always)]
-pub fn abs_sub<T: Signed>(x: T, y: T) -> T {
- x.abs_sub(&y)
-}
-
-/// Returns the sign of the number.
-///
-/// For `f32` and `f64`:
-///
-/// * `1.0` if the number is positive, `+0.0` or `INFINITY`
-/// * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
-/// * `NaN` if the number is `NaN`
-///
-/// For signed integers:
-///
-/// * `0` if the number is zero
-/// * `1` if the number is positive
-/// * `-1` if the number is negative
-#[inline(always)] pub fn signum<T: Signed>(value: T) -> T { value.signum() }
-
-/// A trait for values which cannot be negative
-pub trait Unsigned: Num {}
-
-macro_rules! empty_trait_impl {
- ($name:ident for $($t:ty)*) => ($(
- impl $name for $t {}
- )*)
-}
-
-empty_trait_impl!(Unsigned for usize u8 u16 u32 u64);
-
-impl<T: Unsigned> Unsigned for Wrapping<T> where Wrapping<T>: Num {}
-
-#[test]
-fn unsigned_wrapping_is_unsigned() {
- fn require_unsigned<T: Unsigned>(_: &T) {}
- require_unsigned(&Wrapping(42_u32));
-}
-/*
-// Commenting this out since it doesn't compile on Rust 1.8,
-// because on this version Wrapping doesn't implement Neg and therefore can't
-// implement Signed.
-#[test]
-fn signed_wrapping_is_signed() {
- fn require_signed<T: Signed>(_: &T) {}
- require_signed(&Wrapping(-42));
-}
-*/
new file mode 100644
--- /dev/null
+++ b/third_party/rust/num-traits-0.1.43/.cargo-checksum.json
@@ -0,0 +1,1 @@
+{"files":{".travis.yml":"7990ad4ebc08510942aa5d4e0823870574448b8777ae8626adaca5e1a9ade9df","Cargo.toml":"b3ca516be2bbfdf5b76fd95da36d75b40161074f5f75f81391737b7c7cdee4c6","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"b49a361bd2026fbbe3c778ab9ce1c100bbf459a5c47f6d35f55086c0c4da1285","RELEASES.md":"86c3e6703e6948bfc23c165a8b121930b8da4ffc7c38ab49d7a9e27b1655090e","bors.toml":"1c81ede536a37edd30fe4e622ff0531b25372403ac9475a5d6c50f14156565a2","ci/rustup.sh":"723d546a1ffefcdd5d4db9fb26dbf4128954e3991aff32932284cdc67fa5c85e","ci/test_full.sh":"c66b8c60fa2a643f521cd645aa9338d74dd29ee064c670557ae95b73f919b5cb","src/lib.rs":"3beb14151cfb7fe47f1c4f42869df5c4a347efac34b93b34ec776c158be78fcc"},"package":"92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31"}
\ No newline at end of file
new file mode 100644
--- /dev/null
+++ b/third_party/rust/num-traits-0.1.43/.travis.yml
@@ -0,0 +1,20 @@
+language: rust
+rust:
+ - 1.8.0
+ - stable
+ - beta
+ - nightly
+sudo: false
+script:
+ - cargo build --verbose
+ - ./ci/test_full.sh
+notifications:
+ email:
+ on_success: never
+branches:
+ only:
+ - master
+ - num-traits-0.1.x
+ - next
+ - staging
+ - trying
new file mode 100644
--- /dev/null
+++ b/third_party/rust/num-traits-0.1.43/Cargo.toml
@@ -0,0 +1,29 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g. crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "num-traits"
+version = "0.1.43"
+authors = ["The Rust Project Developers"]
+description = "Numeric traits for generic mathematics"
+homepage = "https://github.com/rust-num/num-traits"
+documentation = "https://docs.rs/num-traits"
+readme = "README.md"
+keywords = ["mathematics", "numerics"]
+categories = ["algorithms", "science"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/rust-num/num-traits"
+
+[lib]
+doctest = false
+[dependencies.num-traits]
+version = "0.2.0"
rename from third_party/rust/num-traits-0.1.41/LICENSE-APACHE
rename to third_party/rust/num-traits-0.1.43/LICENSE-APACHE
rename from third_party/rust/num-traits-0.1.41/LICENSE-MIT
rename to third_party/rust/num-traits-0.1.43/LICENSE-MIT
new file mode 100644
--- /dev/null
+++ b/third_party/rust/num-traits-0.1.43/README.md
@@ -0,0 +1,33 @@
+# num-traits
+
+[](https://crates.io/crates/num-traits)
+[](https://docs.rs/num-traits)
+[](https://travis-ci.org/rust-num/num-traits)
+
+Numeric traits for generic mathematics in Rust.
+
+This version of the crate only exists to re-export compatible
+items from `num-traits` 0.2. Please consider updating!
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+num-traits = "0.1"
+```
+
+and this to your crate root:
+
+```rust
+extern crate num_traits;
+```
+
+## Releases
+
+Release notes are available in [RELEASES.md](RELEASES.md).
+
+## Compatibility
+
+The `num-traits` crate is tested for rustc 1.8 and greater.
new file mode 100644
--- /dev/null
+++ b/third_party/rust/num-traits-0.1.43/RELEASES.md
@@ -0,0 +1,41 @@
+# Release 0.2.0
+
+- **breaking change**: There is now a `std` feature, 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
+
+# Release 0.1.43
+
+- All items are now re-exported from num-traits 0.2 for compatibility.
+
+# Release 0.1.42
+
+- [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!
new file mode 100644
--- /dev/null
+++ b/third_party/rust/num-traits-0.1.43/bors.toml
@@ -0,0 +1,3 @@
+status = [
+ "continuous-integration/travis-ci/push",
+]
new file mode 100755
--- /dev/null
+++ b/third_party/rust/num-traits-0.1.43/ci/rustup.sh
@@ -0,0 +1,12 @@
+#!/bin/sh
+# Use rustup to locally run the same suite of tests as .travis.yml.
+# (You should first install/update 1.8.0, stable, beta, and nightly.)
+
+set -ex
+
+export TRAVIS_RUST_VERSION
+for TRAVIS_RUST_VERSION in 1.8.0 stable beta nightly; do
+ run="rustup run $TRAVIS_RUST_VERSION"
+ $run cargo build --verbose
+ $run $PWD/ci/test_full.sh
+done
new file mode 100755
--- /dev/null
+++ b/third_party/rust/num-traits-0.1.43/ci/test_full.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -ex
+
+echo Testing num-traits on rustc ${TRAVIS_RUST_VERSION}
+
+# num-integer should build and test everywhere.
+cargo build --verbose
+cargo test --verbose
+
+# We have no features to test...
new file mode 100644
--- /dev/null
+++ b/third_party/rust/num-traits-0.1.43/src/lib.rs
@@ -0,0 +1,88 @@
+// 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
+//!
+//! This version of the crate only exists to re-export compatible
+//! items from num-traits 0.2. Please consider updating!
+
+#![doc(html_root_url = "https://docs.rs/num-traits/0.1")]
+
+extern crate num_traits;
+
+pub use bounds::Bounded;
+pub use float::{Float, FloatConst};
+// pub use real::Real; // NOTE: Don't do this, it breaks `use num_traits::*;`.
+pub use identities::{Zero, One, zero, one};
+pub use ops::checked::{CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, CheckedShl, CheckedShr};
+pub use ops::wrapping::{WrappingAdd, WrappingMul, WrappingSub};
+pub use ops::saturating::Saturating;
+pub use sign::{Signed, Unsigned, abs, abs_sub, signum};
+pub use cast::{AsPrimitive, FromPrimitive, ToPrimitive, NumCast, cast};
+pub use int::PrimInt;
+pub use pow::{pow, checked_pow};
+
+
+// Re-exports from num-traits 0.2!
+
+pub use num_traits::{Num, NumOps, NumRef, RefNum};
+pub use num_traits::{NumAssignOps, NumAssign, NumAssignRef};
+pub use num_traits::{FloatErrorKind, ParseFloatError};
+pub use num_traits::clamp;
+
+// Note: the module structure is explicitly re-created, rather than re-exporting en masse,
+// so we won't expose any items that may be added later in the new version.
+
+pub mod identities {
+ pub use num_traits::identities::{Zero, One, zero, one};
+}
+
+pub mod sign {
+ pub use num_traits::sign::{Signed, Unsigned, abs, abs_sub, signum};
+}
+
+pub mod ops {
+ pub mod saturating {
+ pub use num_traits::ops::saturating::Saturating;
+ }
+
+ pub mod checked {
+ pub use num_traits::ops::checked::{CheckedAdd, CheckedSub, CheckedMul, CheckedDiv,
+ CheckedShl, CheckedShr};
+ }
+
+ pub mod wrapping {
+ pub use num_traits::ops::wrapping::{WrappingAdd, WrappingMul, WrappingSub};
+ }
+}
+
+pub mod bounds {
+ pub use num_traits::bounds::Bounded;
+}
+
+pub mod float {
+ pub use num_traits::float::{Float, FloatConst};
+}
+
+pub mod real {
+ pub use num_traits::real::Real;
+}
+
+pub mod cast {
+ pub use num_traits::cast::{AsPrimitive, FromPrimitive, ToPrimitive, NumCast, cast};
+}
+
+pub mod int {
+ pub use num_traits::int::PrimInt;
+}
+
+pub mod pow {
+ pub use num_traits::pow::{pow, checked_pow};
+}