| author | Matt Brubeck <mbrubeck@mozilla.com> |
| Mon, 19 Mar 2018 10:24:54 -0700 | |
| changeset 409586 | e11b86d0c8e4332b5499c74d3817d8c34727830a |
| parent 409585 | 93a43f1d8ea0fa0f545e962a4b361b137fa55830 |
| child 409587 | 09f496975981051ad17639ee00242998598149d5 |
| push id | 101247 |
| push user | nerli@mozilla.com |
| push date | Thu, 22 Mar 2018 23:00:51 +0000 |
| treeherder | mozilla-inbound@02e384bdf97d [default view] [failures only] |
| perfherder | [talos] [build metrics] [platform microbench] (compared to previous push) |
| reviewers | ted |
| bugs | 1447062 |
| milestone | 61.0a1 |
| first release with | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
| last release without | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
--- 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 = [ @@ -1326,17 +1329,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]] @@ -1640,17 +1643,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.5.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", @@ -2024,17 +2027,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", @@ -2284,17 +2287,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.5.4 (registry+https://github.com/rust-lang/crates.io-index)" = "9fd9d732f2de194336fb02fe11f9eed13d9e76f13f4315b4d88a14ca411750cd" "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}; +}