69: Automatically detect support for i128/u128 r=cuviper a=cuviper



Co-authored-by: Josh Stone <cuviper@gmail.com>
This commit is contained in:
bors[bot] 2018-05-11 23:02:02 +00:00
commit f4125621ac
16 changed files with 130 additions and 82 deletions

View File

@ -8,11 +8,12 @@ categories = ["algorithms", "science", "no-std"]
license = "MIT/Apache-2.0" license = "MIT/Apache-2.0"
repository = "https://github.com/rust-num/num-traits" repository = "https://github.com/rust-num/num-traits"
name = "num-traits" name = "num-traits"
version = "0.2.3" version = "0.2.4"
readme = "README.md" readme = "README.md"
build = "build.rs"
[package.metadata.docs.rs] [package.metadata.docs.rs]
all-features = true features = ["std"]
[dependencies] [dependencies]

View File

@ -38,7 +38,9 @@ The `Float` and `Real` traits are only available when `std` is enabled. The
and `f64` also require `std`, as do implementations of signed and floating- and `f64` also require `std`, as do implementations of signed and floating-
point exponents in `Pow`. point exponents in `Pow`.
Implementations for `i128` and `u128` are only available when `i128` is enabled. Implementations for `i128` and `u128` are only available with Rust 1.26 and
later. The build script automatically detects this, but you can make it
mandatory by enabling the `i128` crate feature.
## Releases ## Releases

View File

@ -1,3 +1,13 @@
# Release 0.2.4
- [Support for 128-bit integers is now automatically detected and enabled.][69]
Setting the `i128` crate feature now causes the build script to panic if such
support is not detected.
**Contributors**: @cuviper
[69]: https://github.com/rust-num/num-traits/pull/69
# Release 0.2.3 # Release 0.2.3
- [The new `CheckedNeg` and `CheckedRem` traits][63] perform checked `Neg` and - [The new `CheckedNeg` and `CheckedRem` traits][63] perform checked `Neg` and

35
build.rs Normal file
View File

@ -0,0 +1,35 @@
use std::env;
use std::io::Write;
use std::process::{Command, Stdio};
fn main() {
if probe("fn main() { 0i128; }") {
println!("cargo:rustc-cfg=has_i128");
} else if env::var_os("CARGO_FEATURE_I128").is_some() {
panic!("i128 support was not detected!");
}
}
/// Test if a code snippet can be compiled
fn probe(code: &str) -> bool {
let rustc = env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
let out_dir = env::var_os("OUT_DIR").expect("environment variable OUT_DIR");
let mut child = Command::new(rustc)
.arg("--out-dir")
.arg(out_dir)
.arg("--emit=obj")
.arg("-")
.stdin(Stdio::piped())
.spawn()
.expect("rustc probe");
child
.stdin
.as_mut()
.expect("rustc stdin")
.write_all(code.as_bytes())
.expect("write rustc stdin");
child.wait().expect("rustc probe").success()
}

View File

@ -2,7 +2,7 @@ use core::{usize, u8, u16, u32, u64};
use core::{isize, i8, i16, i32, i64}; use core::{isize, i8, i16, i32, i64};
use core::{f32, f64}; use core::{f32, f64};
use core::num::Wrapping; use core::num::Wrapping;
#[cfg(feature = "i128")] #[cfg(has_i128)]
use core::{i128, u128}; use core::{i128, u128};
/// Numbers which have upper and lower bounds /// Numbers which have upper and lower bounds
@ -31,7 +31,7 @@ bounded_impl!(u8, u8::MIN, u8::MAX);
bounded_impl!(u16, u16::MIN, u16::MAX); bounded_impl!(u16, u16::MIN, u16::MAX);
bounded_impl!(u32, u32::MIN, u32::MAX); bounded_impl!(u32, u32::MIN, u32::MAX);
bounded_impl!(u64, u64::MIN, u64::MAX); bounded_impl!(u64, u64::MIN, u64::MAX);
#[cfg(feature = "i128")] #[cfg(has_i128)]
bounded_impl!(u128, u128::MIN, u128::MAX); bounded_impl!(u128, u128::MIN, u128::MAX);
bounded_impl!(isize, isize::MIN, isize::MAX); bounded_impl!(isize, isize::MIN, isize::MAX);
@ -39,7 +39,7 @@ bounded_impl!(i8, i8::MIN, i8::MAX);
bounded_impl!(i16, i16::MIN, i16::MAX); bounded_impl!(i16, i16::MIN, i16::MAX);
bounded_impl!(i32, i32::MIN, i32::MAX); bounded_impl!(i32, i32::MIN, i32::MAX);
bounded_impl!(i64, i64::MIN, i64::MAX); bounded_impl!(i64, i64::MIN, i64::MAX);
#[cfg(feature = "i128")] #[cfg(has_i128)]
bounded_impl!(i128, i128::MIN, i128::MAX); bounded_impl!(i128, i128::MIN, i128::MAX);
impl<T: Bounded> Bounded for Wrapping<T> { impl<T: Bounded> Bounded for Wrapping<T> {
@ -97,7 +97,7 @@ fn wrapping_bounded() {
test_wrapping_bounded!(usize u8 u16 u32 u64 isize i8 i16 i32 i64); test_wrapping_bounded!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
} }
#[cfg(feature = "i128")] #[cfg(has_i128)]
#[test] #[test]
fn wrapping_bounded_i128() { fn wrapping_bounded_i128() {
macro_rules! test_wrapping_bounded { macro_rules! test_wrapping_bounded {

View File

@ -3,7 +3,7 @@ use core::{u8, u16, u32, u64, usize};
use core::{f32, f64}; use core::{f32, f64};
use core::mem::size_of; use core::mem::size_of;
use core::num::Wrapping; use core::num::Wrapping;
#[cfg(feature = "i128")] #[cfg(has_i128)]
use core::{i128, u128}; use core::{i128, u128};
use float::FloatCore; use float::FloatCore;
@ -44,7 +44,7 @@ pub trait ToPrimitive {
/// The default implementation converts through `to_i64()`. Types implementing /// The default implementation converts through `to_i64()`. Types implementing
/// this trait should override this method if they can represent a greater range. /// this trait should override this method if they can represent a greater range.
#[inline] #[inline]
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_i128(&self) -> Option<i128> { fn to_i128(&self) -> Option<i128> {
self.to_i64().map(From::from) self.to_i64().map(From::from)
} }
@ -84,7 +84,7 @@ pub trait ToPrimitive {
/// The default implementation converts through `to_u64()`. Types implementing /// The default implementation converts through `to_u64()`. Types implementing
/// this trait should override this method if they can represent a greater range. /// this trait should override this method if they can represent a greater range.
#[inline] #[inline]
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_u128(&self) -> Option<u128> { fn to_u128(&self) -> Option<u128> {
self.to_u64().map(From::from) self.to_u64().map(From::from)
} }
@ -142,7 +142,7 @@ macro_rules! impl_to_primitive_int {
fn to_i16 -> i16; fn to_i16 -> i16;
fn to_i32 -> i32; fn to_i32 -> i32;
fn to_i64 -> i64; fn to_i64 -> i64;
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_i128 -> i128; fn to_i128 -> i128;
} }
@ -152,7 +152,7 @@ macro_rules! impl_to_primitive_int {
fn to_u16 -> u16; fn to_u16 -> u16;
fn to_u32 -> u32; fn to_u32 -> u32;
fn to_u64 -> u64; fn to_u64 -> u64;
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_u128 -> u128; fn to_u128 -> u128;
} }
@ -169,7 +169,7 @@ impl_to_primitive_int!(i8);
impl_to_primitive_int!(i16); impl_to_primitive_int!(i16);
impl_to_primitive_int!(i32); impl_to_primitive_int!(i32);
impl_to_primitive_int!(i64); impl_to_primitive_int!(i64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
impl_to_primitive_int!(i128); impl_to_primitive_int!(i128);
macro_rules! impl_to_primitive_uint_to_int { macro_rules! impl_to_primitive_uint_to_int {
@ -211,7 +211,7 @@ macro_rules! impl_to_primitive_uint {
fn to_i16 -> i16; fn to_i16 -> i16;
fn to_i32 -> i32; fn to_i32 -> i32;
fn to_i64 -> i64; fn to_i64 -> i64;
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_i128 -> i128; fn to_i128 -> i128;
} }
@ -221,7 +221,7 @@ macro_rules! impl_to_primitive_uint {
fn to_u16 -> u16; fn to_u16 -> u16;
fn to_u32 -> u32; fn to_u32 -> u32;
fn to_u64 -> u64; fn to_u64 -> u64;
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_u128 -> u128; fn to_u128 -> u128;
} }
@ -238,7 +238,7 @@ impl_to_primitive_uint!(u8);
impl_to_primitive_uint!(u16); impl_to_primitive_uint!(u16);
impl_to_primitive_uint!(u32); impl_to_primitive_uint!(u32);
impl_to_primitive_uint!(u64); impl_to_primitive_uint!(u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
impl_to_primitive_uint!(u128); impl_to_primitive_uint!(u128);
macro_rules! impl_to_primitive_float_to_float { macro_rules! impl_to_primitive_float_to_float {
@ -324,7 +324,7 @@ macro_rules! impl_to_primitive_float {
fn to_i16 -> i16; fn to_i16 -> i16;
fn to_i32 -> i32; fn to_i32 -> i32;
fn to_i64 -> i64; fn to_i64 -> i64;
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_i128 -> i128; fn to_i128 -> i128;
} }
@ -334,7 +334,7 @@ macro_rules! impl_to_primitive_float {
fn to_u16 -> u16; fn to_u16 -> u16;
fn to_u32 -> u32; fn to_u32 -> u32;
fn to_u64 -> u64; fn to_u64 -> u64;
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_u128 -> u128; fn to_u128 -> u128;
} }
@ -391,7 +391,7 @@ pub trait FromPrimitive: Sized {
/// The default implementation converts through `from_i64()`. Types implementing /// The default implementation converts through `from_i64()`. Types implementing
/// this trait should override this method if they can represent a greater range. /// this trait should override this method if they can represent a greater range.
#[inline] #[inline]
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn from_i128(n: i128) -> Option<Self> { fn from_i128(n: i128) -> Option<Self> {
n.to_i64().and_then(FromPrimitive::from_i64) n.to_i64().and_then(FromPrimitive::from_i64)
} }
@ -436,7 +436,7 @@ pub trait FromPrimitive: Sized {
/// The default implementation converts through `from_u64()`. Types implementing /// The default implementation converts through `from_u64()`. Types implementing
/// this trait should override this method if they can represent a greater range. /// this trait should override this method if they can represent a greater range.
#[inline] #[inline]
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn from_u128(n: u128) -> Option<Self> { fn from_u128(n: u128) -> Option<Self> {
n.to_u64().and_then(FromPrimitive::from_u64) n.to_u64().and_then(FromPrimitive::from_u64)
} }
@ -464,14 +464,14 @@ macro_rules! impl_from_primitive {
#[inline] fn from_i16(n: i16) -> 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_i32(n: i32) -> Option<$T> { n.$to_ty() }
#[inline] fn from_i64(n: i64) -> Option<$T> { n.$to_ty() } #[inline] fn from_i64(n: i64) -> Option<$T> { n.$to_ty() }
#[cfg(feature = "i128")] #[cfg(has_i128)]
#[inline] fn from_i128(n: i128) -> Option<$T> { n.$to_ty() } #[inline] fn from_i128(n: i128) -> Option<$T> { n.$to_ty() }
#[inline] fn from_u8(n: u8) -> 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_u16(n: u16) -> Option<$T> { n.$to_ty() }
#[inline] fn from_u32(n: u32) -> 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_u64(n: u64) -> Option<$T> { n.$to_ty() }
#[cfg(feature = "i128")] #[cfg(has_i128)]
#[inline] fn from_u128(n: u128) -> Option<$T> { n.$to_ty() } #[inline] fn from_u128(n: u128) -> Option<$T> { n.$to_ty() }
#[inline] fn from_f32(n: f32) -> Option<$T> { n.$to_ty() } #[inline] fn from_f32(n: f32) -> Option<$T> { n.$to_ty() }
@ -485,14 +485,14 @@ impl_from_primitive!(i8, to_i8);
impl_from_primitive!(i16, to_i16); impl_from_primitive!(i16, to_i16);
impl_from_primitive!(i32, to_i32); impl_from_primitive!(i32, to_i32);
impl_from_primitive!(i64, to_i64); impl_from_primitive!(i64, to_i64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
impl_from_primitive!(i128, to_i128); impl_from_primitive!(i128, to_i128);
impl_from_primitive!(usize, to_usize); impl_from_primitive!(usize, to_usize);
impl_from_primitive!(u8, to_u8); impl_from_primitive!(u8, to_u8);
impl_from_primitive!(u16, to_u16); impl_from_primitive!(u16, to_u16);
impl_from_primitive!(u32, to_u32); impl_from_primitive!(u32, to_u32);
impl_from_primitive!(u64, to_u64); impl_from_primitive!(u64, to_u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
impl_from_primitive!(u128, to_u128); impl_from_primitive!(u128, to_u128);
impl_from_primitive!(f32, to_f32); impl_from_primitive!(f32, to_f32);
impl_from_primitive!(f64, to_f64); impl_from_primitive!(f64, to_f64);
@ -515,7 +515,7 @@ impl<T: ToPrimitive> ToPrimitive for Wrapping<T> {
fn to_i16 -> i16; fn to_i16 -> i16;
fn to_i32 -> i32; fn to_i32 -> i32;
fn to_i64 -> i64; fn to_i64 -> i64;
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_i128 -> i128; fn to_i128 -> i128;
fn to_usize -> usize; fn to_usize -> usize;
@ -523,7 +523,7 @@ impl<T: ToPrimitive> ToPrimitive for Wrapping<T> {
fn to_u16 -> u16; fn to_u16 -> u16;
fn to_u32 -> u32; fn to_u32 -> u32;
fn to_u64 -> u64; fn to_u64 -> u64;
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn to_u128 -> u128; fn to_u128 -> u128;
fn to_f32 -> f32; fn to_f32 -> f32;
@ -548,7 +548,7 @@ impl<T: FromPrimitive> FromPrimitive for Wrapping<T> {
fn from_i16(i16); fn from_i16(i16);
fn from_i32(i32); fn from_i32(i32);
fn from_i64(i64); fn from_i64(i64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn from_i128(i128); fn from_i128(i128);
fn from_usize(usize); fn from_usize(usize);
@ -556,7 +556,7 @@ impl<T: FromPrimitive> FromPrimitive for Wrapping<T> {
fn from_u16(u16); fn from_u16(u16);
fn from_u32(u32); fn from_u32(u32);
fn from_u64(u64); fn from_u64(u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn from_u128(u128); fn from_u128(u128);
fn from_f32(f32); fn from_f32(f32);
@ -605,14 +605,14 @@ impl_num_cast!(u8, to_u8);
impl_num_cast!(u16, to_u16); impl_num_cast!(u16, to_u16);
impl_num_cast!(u32, to_u32); impl_num_cast!(u32, to_u32);
impl_num_cast!(u64, to_u64); impl_num_cast!(u64, to_u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
impl_num_cast!(u128, to_u128); impl_num_cast!(u128, to_u128);
impl_num_cast!(usize, to_usize); impl_num_cast!(usize, to_usize);
impl_num_cast!(i8, to_i8); impl_num_cast!(i8, to_i8);
impl_num_cast!(i16, to_i16); impl_num_cast!(i16, to_i16);
impl_num_cast!(i32, to_i32); impl_num_cast!(i32, to_i32);
impl_num_cast!(i64, to_i64); impl_num_cast!(i64, to_i64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
impl_num_cast!(i128, to_i128); impl_num_cast!(i128, to_i128);
impl_num_cast!(isize, to_isize); impl_num_cast!(isize, to_isize);
impl_num_cast!(f32, to_f32); impl_num_cast!(f32, to_f32);
@ -680,9 +680,9 @@ macro_rules! impl_as_primitive {
($T: ty => { $( $U: ty ),* } ) => { ($T: ty => { $( $U: ty ),* } ) => {
impl_as_primitive!(@ $T => { $( $U ),* }); impl_as_primitive!(@ $T => { $( $U ),* });
impl_as_primitive!(@ $T => { u8, u16, u32, u64, usize }); impl_as_primitive!(@ $T => { u8, u16, u32, u64, usize });
impl_as_primitive!(@ $T => #[cfg(feature = "i128")] impl u128); impl_as_primitive!(@ $T => #[cfg(has_i128)] impl u128);
impl_as_primitive!(@ $T => { i8, i16, i32, i64, isize }); impl_as_primitive!(@ $T => { i8, i16, i32, i64, isize });
impl_as_primitive!(@ $T => #[cfg(feature = "i128")] impl i128); impl_as_primitive!(@ $T => #[cfg(has_i128)] impl i128);
}; };
} }
@ -694,9 +694,9 @@ impl_as_primitive!(u32 => { f32, f64 });
impl_as_primitive!(i32 => { f32, f64 }); impl_as_primitive!(i32 => { f32, f64 });
impl_as_primitive!(u64 => { f32, f64 }); impl_as_primitive!(u64 => { f32, f64 });
impl_as_primitive!(i64 => { f32, f64 }); impl_as_primitive!(i64 => { f32, f64 });
#[cfg(feature = "i128")] #[cfg(has_i128)]
impl_as_primitive!(u128 => { f32, f64 }); impl_as_primitive!(u128 => { f32, f64 });
#[cfg(feature = "i128")] #[cfg(has_i128)]
impl_as_primitive!(i128 => { f32, f64 }); impl_as_primitive!(i128 => { f32, f64 });
impl_as_primitive!(usize => { f32, f64 }); impl_as_primitive!(usize => { f32, f64 });
impl_as_primitive!(isize => { f32, f64 }); impl_as_primitive!(isize => { f32, f64 });

View File

@ -41,7 +41,7 @@ zero_impl!(u8, 0);
zero_impl!(u16, 0); zero_impl!(u16, 0);
zero_impl!(u32, 0); zero_impl!(u32, 0);
zero_impl!(u64, 0); zero_impl!(u64, 0);
#[cfg(feature = "i128")] #[cfg(has_i128)]
zero_impl!(u128, 0); zero_impl!(u128, 0);
zero_impl!(isize, 0); zero_impl!(isize, 0);
@ -49,7 +49,7 @@ zero_impl!(i8, 0);
zero_impl!(i16, 0); zero_impl!(i16, 0);
zero_impl!(i32, 0); zero_impl!(i32, 0);
zero_impl!(i64, 0); zero_impl!(i64, 0);
#[cfg(feature = "i128")] #[cfg(has_i128)]
zero_impl!(i128, 0); zero_impl!(i128, 0);
zero_impl!(f32, 0.0); zero_impl!(f32, 0.0);
@ -109,7 +109,7 @@ one_impl!(u8, 1);
one_impl!(u16, 1); one_impl!(u16, 1);
one_impl!(u32, 1); one_impl!(u32, 1);
one_impl!(u64, 1); one_impl!(u64, 1);
#[cfg(feature = "i128")] #[cfg(has_i128)]
one_impl!(u128, 1); one_impl!(u128, 1);
one_impl!(isize, 1); one_impl!(isize, 1);
@ -117,7 +117,7 @@ one_impl!(i8, 1);
one_impl!(i16, 1); one_impl!(i16, 1);
one_impl!(i32, 1); one_impl!(i32, 1);
one_impl!(i64, 1); one_impl!(i64, 1);
#[cfg(feature = "i128")] #[cfg(has_i128)]
one_impl!(i128, 1); one_impl!(i128, 1);
one_impl!(f32, 1.0); one_impl!(f32, 1.0);

View File

@ -368,13 +368,13 @@ prim_int_impl!(u8, i8, u8);
prim_int_impl!(u16, i16, u16); prim_int_impl!(u16, i16, u16);
prim_int_impl!(u32, i32, u32); prim_int_impl!(u32, i32, u32);
prim_int_impl!(u64, i64, u64); prim_int_impl!(u64, i64, u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
prim_int_impl!(u128, i128, u128); prim_int_impl!(u128, i128, u128);
prim_int_impl!(usize, isize, usize); prim_int_impl!(usize, isize, usize);
prim_int_impl!(i8, i8, u8); prim_int_impl!(i8, i8, u8);
prim_int_impl!(i16, i16, u16); prim_int_impl!(i16, i16, u16);
prim_int_impl!(i32, i32, u32); prim_int_impl!(i32, i32, u32);
prim_int_impl!(i64, i64, u64); prim_int_impl!(i64, i64, u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
prim_int_impl!(i128, i128, u128); prim_int_impl!(i128, i128, u128);
prim_int_impl!(isize, isize, usize); prim_int_impl!(isize, isize, usize);

View File

@ -160,7 +160,7 @@ macro_rules! int_trait_impl {
)*) )*)
} }
int_trait_impl!(Num for usize u8 u16 u32 u64 isize i8 i16 i32 i64); int_trait_impl!(Num for usize u8 u16 u32 u64 isize i8 i16 i32 i64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
int_trait_impl!(Num for u128 i128); int_trait_impl!(Num for u128 i128);
impl<T: Num> Num for Wrapping<T> impl<T: Num> Num for Wrapping<T>

View File

@ -24,7 +24,7 @@ checked_impl!(CheckedAdd, checked_add, u16);
checked_impl!(CheckedAdd, checked_add, u32); checked_impl!(CheckedAdd, checked_add, u32);
checked_impl!(CheckedAdd, checked_add, u64); checked_impl!(CheckedAdd, checked_add, u64);
checked_impl!(CheckedAdd, checked_add, usize); checked_impl!(CheckedAdd, checked_add, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedAdd, checked_add, u128); checked_impl!(CheckedAdd, checked_add, u128);
checked_impl!(CheckedAdd, checked_add, i8); checked_impl!(CheckedAdd, checked_add, i8);
@ -32,7 +32,7 @@ checked_impl!(CheckedAdd, checked_add, i16);
checked_impl!(CheckedAdd, checked_add, i32); checked_impl!(CheckedAdd, checked_add, i32);
checked_impl!(CheckedAdd, checked_add, i64); checked_impl!(CheckedAdd, checked_add, i64);
checked_impl!(CheckedAdd, checked_add, isize); checked_impl!(CheckedAdd, checked_add, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedAdd, checked_add, i128); checked_impl!(CheckedAdd, checked_add, i128);
/// Performs subtraction that returns `None` instead of wrapping around on underflow. /// Performs subtraction that returns `None` instead of wrapping around on underflow.
@ -47,7 +47,7 @@ checked_impl!(CheckedSub, checked_sub, u16);
checked_impl!(CheckedSub, checked_sub, u32); checked_impl!(CheckedSub, checked_sub, u32);
checked_impl!(CheckedSub, checked_sub, u64); checked_impl!(CheckedSub, checked_sub, u64);
checked_impl!(CheckedSub, checked_sub, usize); checked_impl!(CheckedSub, checked_sub, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedSub, checked_sub, u128); checked_impl!(CheckedSub, checked_sub, u128);
checked_impl!(CheckedSub, checked_sub, i8); checked_impl!(CheckedSub, checked_sub, i8);
@ -55,7 +55,7 @@ checked_impl!(CheckedSub, checked_sub, i16);
checked_impl!(CheckedSub, checked_sub, i32); checked_impl!(CheckedSub, checked_sub, i32);
checked_impl!(CheckedSub, checked_sub, i64); checked_impl!(CheckedSub, checked_sub, i64);
checked_impl!(CheckedSub, checked_sub, isize); checked_impl!(CheckedSub, checked_sub, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedSub, checked_sub, i128); checked_impl!(CheckedSub, checked_sub, i128);
/// Performs multiplication that returns `None` instead of wrapping around on underflow or /// Performs multiplication that returns `None` instead of wrapping around on underflow or
@ -71,7 +71,7 @@ checked_impl!(CheckedMul, checked_mul, u16);
checked_impl!(CheckedMul, checked_mul, u32); checked_impl!(CheckedMul, checked_mul, u32);
checked_impl!(CheckedMul, checked_mul, u64); checked_impl!(CheckedMul, checked_mul, u64);
checked_impl!(CheckedMul, checked_mul, usize); checked_impl!(CheckedMul, checked_mul, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedMul, checked_mul, u128); checked_impl!(CheckedMul, checked_mul, u128);
checked_impl!(CheckedMul, checked_mul, i8); checked_impl!(CheckedMul, checked_mul, i8);
@ -79,7 +79,7 @@ checked_impl!(CheckedMul, checked_mul, i16);
checked_impl!(CheckedMul, checked_mul, i32); checked_impl!(CheckedMul, checked_mul, i32);
checked_impl!(CheckedMul, checked_mul, i64); checked_impl!(CheckedMul, checked_mul, i64);
checked_impl!(CheckedMul, checked_mul, isize); checked_impl!(CheckedMul, checked_mul, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedMul, checked_mul, i128); checked_impl!(CheckedMul, checked_mul, i128);
/// Performs division that returns `None` instead of panicking on division by zero and instead of /// Performs division that returns `None` instead of panicking on division by zero and instead of
@ -95,7 +95,7 @@ checked_impl!(CheckedDiv, checked_div, u16);
checked_impl!(CheckedDiv, checked_div, u32); checked_impl!(CheckedDiv, checked_div, u32);
checked_impl!(CheckedDiv, checked_div, u64); checked_impl!(CheckedDiv, checked_div, u64);
checked_impl!(CheckedDiv, checked_div, usize); checked_impl!(CheckedDiv, checked_div, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedDiv, checked_div, u128); checked_impl!(CheckedDiv, checked_div, u128);
checked_impl!(CheckedDiv, checked_div, i8); checked_impl!(CheckedDiv, checked_div, i8);
@ -103,7 +103,7 @@ checked_impl!(CheckedDiv, checked_div, i16);
checked_impl!(CheckedDiv, checked_div, i32); checked_impl!(CheckedDiv, checked_div, i32);
checked_impl!(CheckedDiv, checked_div, i64); checked_impl!(CheckedDiv, checked_div, i64);
checked_impl!(CheckedDiv, checked_div, isize); checked_impl!(CheckedDiv, checked_div, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedDiv, checked_div, i128); checked_impl!(CheckedDiv, checked_div, i128);
/// Performs an integral remainder that returns `None` instead of panicking on division by zero and /// Performs an integral remainder that returns `None` instead of panicking on division by zero and
@ -136,7 +136,7 @@ checked_impl!(CheckedRem, checked_rem, u16);
checked_impl!(CheckedRem, checked_rem, u32); checked_impl!(CheckedRem, checked_rem, u32);
checked_impl!(CheckedRem, checked_rem, u64); checked_impl!(CheckedRem, checked_rem, u64);
checked_impl!(CheckedRem, checked_rem, usize); checked_impl!(CheckedRem, checked_rem, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedRem, checked_rem, u128); checked_impl!(CheckedRem, checked_rem, u128);
checked_impl!(CheckedRem, checked_rem, i8); checked_impl!(CheckedRem, checked_rem, i8);
@ -144,7 +144,7 @@ checked_impl!(CheckedRem, checked_rem, i16);
checked_impl!(CheckedRem, checked_rem, i32); checked_impl!(CheckedRem, checked_rem, i32);
checked_impl!(CheckedRem, checked_rem, i64); checked_impl!(CheckedRem, checked_rem, i64);
checked_impl!(CheckedRem, checked_rem, isize); checked_impl!(CheckedRem, checked_rem, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl!(CheckedRem, checked_rem, i128); checked_impl!(CheckedRem, checked_rem, i128);
macro_rules! checked_impl_unary { macro_rules! checked_impl_unary {
@ -184,7 +184,7 @@ checked_impl_unary!(CheckedNeg, checked_neg, u16);
checked_impl_unary!(CheckedNeg, checked_neg, u32); checked_impl_unary!(CheckedNeg, checked_neg, u32);
checked_impl_unary!(CheckedNeg, checked_neg, u64); checked_impl_unary!(CheckedNeg, checked_neg, u64);
checked_impl_unary!(CheckedNeg, checked_neg, usize); checked_impl_unary!(CheckedNeg, checked_neg, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl_unary!(CheckedNeg, checked_neg, u128); checked_impl_unary!(CheckedNeg, checked_neg, u128);
checked_impl_unary!(CheckedNeg, checked_neg, i8); checked_impl_unary!(CheckedNeg, checked_neg, i8);
@ -192,7 +192,7 @@ checked_impl_unary!(CheckedNeg, checked_neg, i16);
checked_impl_unary!(CheckedNeg, checked_neg, i32); checked_impl_unary!(CheckedNeg, checked_neg, i32);
checked_impl_unary!(CheckedNeg, checked_neg, i64); checked_impl_unary!(CheckedNeg, checked_neg, i64);
checked_impl_unary!(CheckedNeg, checked_neg, isize); checked_impl_unary!(CheckedNeg, checked_neg, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_impl_unary!(CheckedNeg, checked_neg, i128); checked_impl_unary!(CheckedNeg, checked_neg, i128);
/// Performs a left shift that returns `None` on overflow. /// Performs a left shift that returns `None` on overflow.
@ -229,7 +229,7 @@ checked_shift_impl!(CheckedShl, checked_shl, u16);
checked_shift_impl!(CheckedShl, checked_shl, u32); checked_shift_impl!(CheckedShl, checked_shl, u32);
checked_shift_impl!(CheckedShl, checked_shl, u64); checked_shift_impl!(CheckedShl, checked_shl, u64);
checked_shift_impl!(CheckedShl, checked_shl, usize); checked_shift_impl!(CheckedShl, checked_shl, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_shift_impl!(CheckedShl, checked_shl, u128); checked_shift_impl!(CheckedShl, checked_shl, u128);
checked_shift_impl!(CheckedShl, checked_shl, i8); checked_shift_impl!(CheckedShl, checked_shl, i8);
@ -237,7 +237,7 @@ checked_shift_impl!(CheckedShl, checked_shl, i16);
checked_shift_impl!(CheckedShl, checked_shl, i32); checked_shift_impl!(CheckedShl, checked_shl, i32);
checked_shift_impl!(CheckedShl, checked_shl, i64); checked_shift_impl!(CheckedShl, checked_shl, i64);
checked_shift_impl!(CheckedShl, checked_shl, isize); checked_shift_impl!(CheckedShl, checked_shl, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_shift_impl!(CheckedShl, checked_shl, i128); checked_shift_impl!(CheckedShl, checked_shl, i128);
/// Performs a right shift that returns `None` on overflow. /// Performs a right shift that returns `None` on overflow.
@ -263,7 +263,7 @@ checked_shift_impl!(CheckedShr, checked_shr, u16);
checked_shift_impl!(CheckedShr, checked_shr, u32); checked_shift_impl!(CheckedShr, checked_shr, u32);
checked_shift_impl!(CheckedShr, checked_shr, u64); checked_shift_impl!(CheckedShr, checked_shr, u64);
checked_shift_impl!(CheckedShr, checked_shr, usize); checked_shift_impl!(CheckedShr, checked_shr, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_shift_impl!(CheckedShr, checked_shr, u128); checked_shift_impl!(CheckedShr, checked_shr, u128);
checked_shift_impl!(CheckedShr, checked_shr, i8); checked_shift_impl!(CheckedShr, checked_shr, i8);
@ -271,5 +271,5 @@ checked_shift_impl!(CheckedShr, checked_shr, i16);
checked_shift_impl!(CheckedShr, checked_shr, i32); checked_shift_impl!(CheckedShr, checked_shr, i32);
checked_shift_impl!(CheckedShr, checked_shr, i64); checked_shift_impl!(CheckedShr, checked_shr, i64);
checked_shift_impl!(CheckedShr, checked_shr, isize); checked_shift_impl!(CheckedShr, checked_shr, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
checked_shift_impl!(CheckedShr, checked_shr, i128); checked_shift_impl!(CheckedShr, checked_shr, i128);

View File

@ -67,7 +67,7 @@ macro_rules! mul_add_impl {
} }
mul_add_impl!(MulAdd for isize usize i8 u8 i16 u16 i32 u32 i64 u64); mul_add_impl!(MulAdd for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
mul_add_impl!(MulAdd for i128 u128); mul_add_impl!(MulAdd for i128 u128);
#[cfg(feature = "std")] #[cfg(feature = "std")]
@ -98,7 +98,7 @@ macro_rules! mul_add_assign_impl {
} }
mul_add_assign_impl!(MulAddAssign for isize usize i8 u8 i16 u16 i32 u32 i64 u64); mul_add_assign_impl!(MulAddAssign for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
mul_add_assign_impl!(MulAddAssign for i128 u128); mul_add_assign_impl!(MulAddAssign for i128 u128);
#[cfg(test)] #[cfg(test)]

View File

@ -26,5 +26,5 @@ macro_rules! saturating_impl {
} }
saturating_impl!(Saturating for isize usize i8 u8 i16 u16 i32 u32 i64 u64); saturating_impl!(Saturating for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
saturating_impl!(Saturating for i128 u128); saturating_impl!(Saturating for i128 u128);

View File

@ -32,7 +32,7 @@ wrapping_impl!(WrappingAdd, wrapping_add, u16);
wrapping_impl!(WrappingAdd, wrapping_add, u32); wrapping_impl!(WrappingAdd, wrapping_add, u32);
wrapping_impl!(WrappingAdd, wrapping_add, u64); wrapping_impl!(WrappingAdd, wrapping_add, u64);
wrapping_impl!(WrappingAdd, wrapping_add, usize); wrapping_impl!(WrappingAdd, wrapping_add, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
wrapping_impl!(WrappingAdd, wrapping_add, u128); wrapping_impl!(WrappingAdd, wrapping_add, u128);
wrapping_impl!(WrappingAdd, wrapping_add, i8); wrapping_impl!(WrappingAdd, wrapping_add, i8);
@ -40,7 +40,7 @@ wrapping_impl!(WrappingAdd, wrapping_add, i16);
wrapping_impl!(WrappingAdd, wrapping_add, i32); wrapping_impl!(WrappingAdd, wrapping_add, i32);
wrapping_impl!(WrappingAdd, wrapping_add, i64); wrapping_impl!(WrappingAdd, wrapping_add, i64);
wrapping_impl!(WrappingAdd, wrapping_add, isize); wrapping_impl!(WrappingAdd, wrapping_add, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
wrapping_impl!(WrappingAdd, wrapping_add, i128); wrapping_impl!(WrappingAdd, wrapping_add, i128);
/// Performs subtraction that wraps around on overflow. /// Performs subtraction that wraps around on overflow.
@ -55,7 +55,7 @@ wrapping_impl!(WrappingSub, wrapping_sub, u16);
wrapping_impl!(WrappingSub, wrapping_sub, u32); wrapping_impl!(WrappingSub, wrapping_sub, u32);
wrapping_impl!(WrappingSub, wrapping_sub, u64); wrapping_impl!(WrappingSub, wrapping_sub, u64);
wrapping_impl!(WrappingSub, wrapping_sub, usize); wrapping_impl!(WrappingSub, wrapping_sub, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
wrapping_impl!(WrappingSub, wrapping_sub, u128); wrapping_impl!(WrappingSub, wrapping_sub, u128);
wrapping_impl!(WrappingSub, wrapping_sub, i8); wrapping_impl!(WrappingSub, wrapping_sub, i8);
@ -63,7 +63,7 @@ wrapping_impl!(WrappingSub, wrapping_sub, i16);
wrapping_impl!(WrappingSub, wrapping_sub, i32); wrapping_impl!(WrappingSub, wrapping_sub, i32);
wrapping_impl!(WrappingSub, wrapping_sub, i64); wrapping_impl!(WrappingSub, wrapping_sub, i64);
wrapping_impl!(WrappingSub, wrapping_sub, isize); wrapping_impl!(WrappingSub, wrapping_sub, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
wrapping_impl!(WrappingSub, wrapping_sub, i128); wrapping_impl!(WrappingSub, wrapping_sub, i128);
/// Performs multiplication that wraps around on overflow. /// Performs multiplication that wraps around on overflow.
@ -78,7 +78,7 @@ wrapping_impl!(WrappingMul, wrapping_mul, u16);
wrapping_impl!(WrappingMul, wrapping_mul, u32); wrapping_impl!(WrappingMul, wrapping_mul, u32);
wrapping_impl!(WrappingMul, wrapping_mul, u64); wrapping_impl!(WrappingMul, wrapping_mul, u64);
wrapping_impl!(WrappingMul, wrapping_mul, usize); wrapping_impl!(WrappingMul, wrapping_mul, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
wrapping_impl!(WrappingMul, wrapping_mul, u128); wrapping_impl!(WrappingMul, wrapping_mul, u128);
wrapping_impl!(WrappingMul, wrapping_mul, i8); wrapping_impl!(WrappingMul, wrapping_mul, i8);
@ -86,7 +86,7 @@ wrapping_impl!(WrappingMul, wrapping_mul, i16);
wrapping_impl!(WrappingMul, wrapping_mul, i32); wrapping_impl!(WrappingMul, wrapping_mul, i32);
wrapping_impl!(WrappingMul, wrapping_mul, i64); wrapping_impl!(WrappingMul, wrapping_mul, i64);
wrapping_impl!(WrappingMul, wrapping_mul, isize); wrapping_impl!(WrappingMul, wrapping_mul, isize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
wrapping_impl!(WrappingMul, wrapping_mul, i128); wrapping_impl!(WrappingMul, wrapping_mul, i128);
// Well this is a bit funny, but all the more appropriate. // Well this is a bit funny, but all the more appropriate.

View File

@ -99,22 +99,22 @@ pow_impl!(i64, u16, u32, i64::pow);
pow_impl!(i64, u32, u32, i64::pow); pow_impl!(i64, u32, u32, i64::pow);
pow_impl!(i64, usize); pow_impl!(i64, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(u128, u8, u32, u128::pow); pow_impl!(u128, u8, u32, u128::pow);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(u128, u16, u32, u128::pow); pow_impl!(u128, u16, u32, u128::pow);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(u128, u32, u32, u128::pow); pow_impl!(u128, u32, u32, u128::pow);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(u128, usize); pow_impl!(u128, usize);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(i128, u8, u32, i128::pow); pow_impl!(i128, u8, u32, i128::pow);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(i128, u16, u32, i128::pow); pow_impl!(i128, u16, u32, i128::pow);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(i128, u32, u32, i128::pow); pow_impl!(i128, u32, u32, i128::pow);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(i128, usize); pow_impl!(i128, usize);
pow_impl!(usize, u8, u32, usize::pow); pow_impl!(usize, u8, u32, usize::pow);
@ -133,9 +133,9 @@ pow_impl!(Wrapping<u32>);
pow_impl!(Wrapping<i32>); pow_impl!(Wrapping<i32>);
pow_impl!(Wrapping<u64>); pow_impl!(Wrapping<u64>);
pow_impl!(Wrapping<i64>); pow_impl!(Wrapping<i64>);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(Wrapping<u128>); pow_impl!(Wrapping<u128>);
#[cfg(feature = "i128")] #[cfg(has_i128)]
pow_impl!(Wrapping<i128>); pow_impl!(Wrapping<i128>);
pow_impl!(Wrapping<usize>); pow_impl!(Wrapping<usize>);
pow_impl!(Wrapping<isize>); pow_impl!(Wrapping<isize>);

View File

@ -74,7 +74,7 @@ macro_rules! signed_impl {
signed_impl!(isize i8 i16 i32 i64); signed_impl!(isize i8 i16 i32 i64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
signed_impl!(i128); signed_impl!(i128);
impl<T: Signed> Signed for Wrapping<T> where Wrapping<T>: Num + Neg<Output=Wrapping<T>> impl<T: Signed> Signed for Wrapping<T> where Wrapping<T>: Num + Neg<Output=Wrapping<T>>
@ -186,7 +186,7 @@ macro_rules! empty_trait_impl {
} }
empty_trait_impl!(Unsigned for usize u8 u16 u32 u64); empty_trait_impl!(Unsigned for usize u8 u16 u32 u64);
#[cfg(feature = "i128")] #[cfg(has_i128)]
empty_trait_impl!(Unsigned for u128); empty_trait_impl!(Unsigned for u128);
impl<T: Unsigned> Unsigned for Wrapping<T> where Wrapping<T>: Num {} impl<T: Unsigned> Unsigned for Wrapping<T> where Wrapping<T>: Num {}

View File

@ -13,7 +13,7 @@ use num_traits::cast::*;
use core::{i8, i16, i32, i64, isize}; use core::{i8, i16, i32, i64, isize};
use core::{u8, u16, u32, u64, usize}; use core::{u8, u16, u32, u64, usize};
use core::{f32, f64}; use core::{f32, f64};
#[cfg(feature = "i128")] #[cfg(has_i128)]
use core::{i128, u128}; use core::{i128, u128};
use core::mem; use core::mem;
@ -144,7 +144,7 @@ fn cast_to_unsigned_int_checks_overflow() {
} }
#[test] #[test]
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn cast_to_i128_checks_overflow() { fn cast_to_i128_checks_overflow() {
let big_f: f64 = 1.0e123; let big_f: f64 = 1.0e123;
let normal_f: f64 = 1.0; let normal_f: f64 = 1.0;
@ -240,7 +240,7 @@ fn cast_float_to_int_edge_cases() {
} }
#[test] #[test]
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn cast_float_to_i128_edge_cases() { fn cast_float_to_i128_edge_cases() {
float_test_edge!(f32 -> i128 u128); float_test_edge!(f32 -> i128 u128);
float_test_edge!(f64 -> i128 u128); float_test_edge!(f64 -> i128 u128);
@ -299,7 +299,7 @@ fn cast_int_to_int_edge_cases() {
} }
#[test] #[test]
#[cfg(feature = "i128")] #[cfg(has_i128)]
fn cast_int_to_128_edge_cases() { fn cast_int_to_128_edge_cases() {
use core::cmp::Ordering::*; use core::cmp::Ordering::*;