1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Numeric traits and functions for the built-in numeric types.
13 #![stable(feature = "rust1", since = "1.0.0")]
20 /// Provides intentionally-wrapped arithmetic on `T`.
22 /// Operations like `+` on `u32` values is intended to never overflow,
23 /// and in some debug configurations overflow is detected and results
24 /// in a panic. While most arithmetic falls into this category, some
25 /// code explicitly expects and relies upon modular arithmetic (e.g.,
28 /// Wrapping arithmetic can be achieved either through methods like
29 /// `wrapping_add`, or through the `Wrapping<T>` type, which says that
30 /// all standard arithmetic operations on the underlying value are
31 /// intended to have wrapping semantics.
36 /// use std::num::Wrapping;
38 /// let zero = Wrapping(0u32);
39 /// let one = Wrapping(1u32);
41 /// assert_eq!(std::u32::MAX, (zero - one).0);
43 #[stable(feature = "rust1", since = "1.0.0")]
44 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default, Hash)]
45 pub struct Wrapping<T>(#[stable(feature = "rust1", since = "1.0.0")]
48 #[stable(feature = "rust1", since = "1.0.0")]
49 impl<T: fmt::Debug> fmt::Debug for Wrapping<T> {
50 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
55 #[stable(feature = "wrapping_display", since = "1.10.0")]
56 impl<T: fmt::Display> fmt::Display for Wrapping<T> {
57 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
62 #[stable(feature = "wrapping_fmt", since = "1.11.0")]
63 impl<T: fmt::Binary> fmt::Binary for Wrapping<T> {
64 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
69 #[stable(feature = "wrapping_fmt", since = "1.11.0")]
70 impl<T: fmt::Octal> fmt::Octal for Wrapping<T> {
71 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
76 #[stable(feature = "wrapping_fmt", since = "1.11.0")]
77 impl<T: fmt::LowerHex> fmt::LowerHex for Wrapping<T> {
78 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
83 #[stable(feature = "wrapping_fmt", since = "1.11.0")]
84 impl<T: fmt::UpperHex> fmt::UpperHex for Wrapping<T> {
85 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
92 // All these modules are technically private and only exposed for coretests:
98 // `Int` + `SignedInt` implemented for signed integers
99 macro_rules! int_impl {
100 ($SelfT:ty, $ActualT:ident, $UnsignedT:ty, $BITS:expr,
101 $add_with_overflow:path,
102 $sub_with_overflow:path,
103 $mul_with_overflow:path) => {
104 /// Returns the smallest value that can be represented by this integer type.
109 /// assert_eq!(i8::min_value(), -128);
111 #[stable(feature = "rust1", since = "1.0.0")]
113 pub const fn min_value() -> Self {
114 !0 ^ ((!0 as $UnsignedT) >> 1) as Self
117 /// Returns the largest value that can be represented by this integer type.
122 /// assert_eq!(i8::max_value(), 127);
124 #[stable(feature = "rust1", since = "1.0.0")]
126 pub const fn max_value() -> Self {
130 /// Converts a string slice in a given base to an integer.
132 /// Leading and trailing whitespace represent an error.
139 /// assert_eq!(i32::from_str_radix("A", 16), Ok(10));
141 #[stable(feature = "rust1", since = "1.0.0")]
142 pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
143 from_str_radix(src, radix)
146 /// Returns the number of ones in the binary representation of `self`.
153 /// let n = -0b1000_0000i8;
155 /// assert_eq!(n.count_ones(), 1);
157 #[stable(feature = "rust1", since = "1.0.0")]
159 pub fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() }
161 /// Returns the number of zeros in the binary representation of `self`.
168 /// let n = -0b1000_0000i8;
170 /// assert_eq!(n.count_zeros(), 7);
172 #[stable(feature = "rust1", since = "1.0.0")]
174 pub fn count_zeros(self) -> u32 {
178 /// Returns the number of leading zeros in the binary representation
188 /// assert_eq!(n.leading_zeros(), 0);
190 #[stable(feature = "rust1", since = "1.0.0")]
192 pub fn leading_zeros(self) -> u32 {
193 (self as $UnsignedT).leading_zeros()
196 /// Returns the number of trailing zeros in the binary representation
206 /// assert_eq!(n.trailing_zeros(), 2);
208 #[stable(feature = "rust1", since = "1.0.0")]
210 pub fn trailing_zeros(self) -> u32 {
211 (self as $UnsignedT).trailing_zeros()
214 /// Shifts the bits to the left by a specified amount, `n`,
215 /// wrapping the truncated bits to the end of the resulting integer.
217 /// Please note this isn't the same operation as `<<`!
224 /// let n = 0x0123456789ABCDEFi64;
225 /// let m = -0x76543210FEDCBA99i64;
227 /// assert_eq!(n.rotate_left(32), m);
229 #[stable(feature = "rust1", since = "1.0.0")]
231 pub fn rotate_left(self, n: u32) -> Self {
232 (self as $UnsignedT).rotate_left(n) as Self
235 /// Shifts the bits to the right by a specified amount, `n`,
236 /// wrapping the truncated bits to the beginning of the resulting
239 /// Please note this isn't the same operation as `>>`!
246 /// let n = 0x0123456789ABCDEFi64;
247 /// let m = -0xFEDCBA987654322i64;
249 /// assert_eq!(n.rotate_right(4), m);
251 #[stable(feature = "rust1", since = "1.0.0")]
253 pub fn rotate_right(self, n: u32) -> Self {
254 (self as $UnsignedT).rotate_right(n) as Self
257 /// Reverses the byte order of the integer.
264 /// let n = 0x0123456789ABCDEFi64;
265 /// let m = -0x1032547698BADCFFi64;
267 /// assert_eq!(n.swap_bytes(), m);
269 #[stable(feature = "rust1", since = "1.0.0")]
271 pub fn swap_bytes(self) -> Self {
272 (self as $UnsignedT).swap_bytes() as Self
275 /// Converts an integer from big endian to the target's endianness.
277 /// On big endian this is a no-op. On little endian the bytes are
285 /// let n = 0x0123456789ABCDEFi64;
287 /// if cfg!(target_endian = "big") {
288 /// assert_eq!(i64::from_be(n), n)
290 /// assert_eq!(i64::from_be(n), n.swap_bytes())
293 #[stable(feature = "rust1", since = "1.0.0")]
295 pub fn from_be(x: Self) -> Self {
296 if cfg!(target_endian = "big") { x } else { x.swap_bytes() }
299 /// Converts an integer from little endian to the target's endianness.
301 /// On little endian this is a no-op. On big endian the bytes are
309 /// let n = 0x0123456789ABCDEFi64;
311 /// if cfg!(target_endian = "little") {
312 /// assert_eq!(i64::from_le(n), n)
314 /// assert_eq!(i64::from_le(n), n.swap_bytes())
317 #[stable(feature = "rust1", since = "1.0.0")]
319 pub fn from_le(x: Self) -> Self {
320 if cfg!(target_endian = "little") { x } else { x.swap_bytes() }
323 /// Converts `self` to big endian from the target's endianness.
325 /// On big endian this is a no-op. On little endian the bytes are
333 /// let n = 0x0123456789ABCDEFi64;
335 /// if cfg!(target_endian = "big") {
336 /// assert_eq!(n.to_be(), n)
338 /// assert_eq!(n.to_be(), n.swap_bytes())
341 #[stable(feature = "rust1", since = "1.0.0")]
343 pub fn to_be(self) -> Self { // or not to be?
344 if cfg!(target_endian = "big") { self } else { self.swap_bytes() }
347 /// Converts `self` to little endian from the target's endianness.
349 /// On little endian this is a no-op. On big endian the bytes are
357 /// let n = 0x0123456789ABCDEFi64;
359 /// if cfg!(target_endian = "little") {
360 /// assert_eq!(n.to_le(), n)
362 /// assert_eq!(n.to_le(), n.swap_bytes())
365 #[stable(feature = "rust1", since = "1.0.0")]
367 pub fn to_le(self) -> Self {
368 if cfg!(target_endian = "little") { self } else { self.swap_bytes() }
371 /// Checked integer addition. Computes `self + other`, returning `None`
372 /// if overflow occurred.
379 /// assert_eq!(7i16.checked_add(32760), Some(32767));
380 /// assert_eq!(8i16.checked_add(32760), None);
382 #[stable(feature = "rust1", since = "1.0.0")]
384 pub fn checked_add(self, other: Self) -> Option<Self> {
385 let (a, b) = self.overflowing_add(other);
386 if b {None} else {Some(a)}
389 /// Checked integer subtraction. Computes `self - other`, returning
390 /// `None` if underflow occurred.
397 /// assert_eq!((-127i8).checked_sub(1), Some(-128));
398 /// assert_eq!((-128i8).checked_sub(1), None);
400 #[stable(feature = "rust1", since = "1.0.0")]
402 pub fn checked_sub(self, other: Self) -> Option<Self> {
403 let (a, b) = self.overflowing_sub(other);
404 if b {None} else {Some(a)}
407 /// Checked integer multiplication. Computes `self * other`, returning
408 /// `None` if underflow or overflow occurred.
415 /// assert_eq!(6i8.checked_mul(21), Some(126));
416 /// assert_eq!(6i8.checked_mul(22), None);
418 #[stable(feature = "rust1", since = "1.0.0")]
420 pub fn checked_mul(self, other: Self) -> Option<Self> {
421 let (a, b) = self.overflowing_mul(other);
422 if b {None} else {Some(a)}
425 /// Checked integer division. Computes `self / other`, returning `None`
426 /// if `other == 0` or the operation results in underflow or overflow.
433 /// assert_eq!((-127i8).checked_div(-1), Some(127));
434 /// assert_eq!((-128i8).checked_div(-1), None);
435 /// assert_eq!((1i8).checked_div(0), None);
437 #[stable(feature = "rust1", since = "1.0.0")]
439 pub fn checked_div(self, other: Self) -> Option<Self> {
440 if other == 0 || (self == Self::min_value() && other == -1) {
443 Some(unsafe { intrinsics::unchecked_div(self, other) })
447 /// Checked integer remainder. Computes `self % other`, returning `None`
448 /// if `other == 0` or the operation results in underflow or overflow.
457 /// assert_eq!(5i32.checked_rem(2), Some(1));
458 /// assert_eq!(5i32.checked_rem(0), None);
459 /// assert_eq!(i32::MIN.checked_rem(-1), None);
461 #[stable(feature = "wrapping", since = "1.7.0")]
463 pub fn checked_rem(self, other: Self) -> Option<Self> {
464 if other == 0 || (self == Self::min_value() && other == -1) {
467 Some(unsafe { intrinsics::unchecked_rem(self, other) })
471 /// Checked negation. Computes `-self`, returning `None` if `self ==
481 /// assert_eq!(5i32.checked_neg(), Some(-5));
482 /// assert_eq!(i32::MIN.checked_neg(), None);
484 #[stable(feature = "wrapping", since = "1.7.0")]
486 pub fn checked_neg(self) -> Option<Self> {
487 let (a, b) = self.overflowing_neg();
488 if b {None} else {Some(a)}
491 /// Checked shift left. Computes `self << rhs`, returning `None`
492 /// if `rhs` is larger than or equal to the number of bits in `self`.
499 /// assert_eq!(0x10i32.checked_shl(4), Some(0x100));
500 /// assert_eq!(0x10i32.checked_shl(33), None);
502 #[stable(feature = "wrapping", since = "1.7.0")]
504 pub fn checked_shl(self, rhs: u32) -> Option<Self> {
505 let (a, b) = self.overflowing_shl(rhs);
506 if b {None} else {Some(a)}
509 /// Checked shift right. Computes `self >> rhs`, returning `None`
510 /// if `rhs` is larger than or equal to the number of bits in `self`.
517 /// assert_eq!(0x10i32.checked_shr(4), Some(0x1));
518 /// assert_eq!(0x10i32.checked_shr(33), None);
520 #[stable(feature = "wrapping", since = "1.7.0")]
522 pub fn checked_shr(self, rhs: u32) -> Option<Self> {
523 let (a, b) = self.overflowing_shr(rhs);
524 if b {None} else {Some(a)}
527 /// Checked absolute value. Computes `self.abs()`, returning `None` if
537 /// assert_eq!((-5i32).checked_abs(), Some(5));
538 /// assert_eq!(i32::MIN.checked_abs(), None);
540 #[stable(feature = "no_panic_abs", since = "1.13.0")]
542 pub fn checked_abs(self) -> Option<Self> {
543 if self.is_negative() {
550 /// Saturating integer addition. Computes `self + other`, saturating at
551 /// the numeric bounds instead of overflowing.
558 /// assert_eq!(100i8.saturating_add(1), 101);
559 /// assert_eq!(100i8.saturating_add(127), 127);
561 #[stable(feature = "rust1", since = "1.0.0")]
563 pub fn saturating_add(self, other: Self) -> Self {
564 match self.checked_add(other) {
566 None if other >= 0 => Self::max_value(),
567 None => Self::min_value(),
571 /// Saturating integer subtraction. Computes `self - other`, saturating
572 /// at the numeric bounds instead of overflowing.
579 /// assert_eq!(100i8.saturating_sub(127), -27);
580 /// assert_eq!((-100i8).saturating_sub(127), -128);
582 #[stable(feature = "rust1", since = "1.0.0")]
584 pub fn saturating_sub(self, other: Self) -> Self {
585 match self.checked_sub(other) {
587 None if other >= 0 => Self::min_value(),
588 None => Self::max_value(),
592 /// Saturating integer multiplication. Computes `self * other`,
593 /// saturating at the numeric bounds instead of overflowing.
602 /// assert_eq!(100i32.saturating_mul(127), 12700);
603 /// assert_eq!((1i32 << 23).saturating_mul(1 << 23), i32::MAX);
604 /// assert_eq!((-1i32 << 23).saturating_mul(1 << 23), i32::MIN);
606 #[stable(feature = "wrapping", since = "1.7.0")]
608 pub fn saturating_mul(self, other: Self) -> Self {
609 self.checked_mul(other).unwrap_or_else(|| {
610 if (self < 0 && other < 0) || (self > 0 && other > 0) {
618 /// Wrapping (modular) addition. Computes `self + other`,
619 /// wrapping around at the boundary of the type.
626 /// assert_eq!(100i8.wrapping_add(27), 127);
627 /// assert_eq!(100i8.wrapping_add(127), -29);
629 #[stable(feature = "rust1", since = "1.0.0")]
631 pub fn wrapping_add(self, rhs: Self) -> Self {
633 intrinsics::overflowing_add(self, rhs)
637 /// Wrapping (modular) subtraction. Computes `self - other`,
638 /// wrapping around at the boundary of the type.
645 /// assert_eq!(0i8.wrapping_sub(127), -127);
646 /// assert_eq!((-2i8).wrapping_sub(127), 127);
648 #[stable(feature = "rust1", since = "1.0.0")]
650 pub fn wrapping_sub(self, rhs: Self) -> Self {
652 intrinsics::overflowing_sub(self, rhs)
656 /// Wrapping (modular) multiplication. Computes `self *
657 /// other`, wrapping around at the boundary of the type.
664 /// assert_eq!(10i8.wrapping_mul(12), 120);
665 /// assert_eq!(11i8.wrapping_mul(12), -124);
667 #[stable(feature = "rust1", since = "1.0.0")]
669 pub fn wrapping_mul(self, rhs: Self) -> Self {
671 intrinsics::overflowing_mul(self, rhs)
675 /// Wrapping (modular) division. Computes `self / other`,
676 /// wrapping around at the boundary of the type.
678 /// The only case where such wrapping can occur is when one
679 /// divides `MIN / -1` on a signed type (where `MIN` is the
680 /// negative minimal value for the type); this is equivalent
681 /// to `-MIN`, a positive value that is too large to represent
682 /// in the type. In such a case, this function returns `MIN`
687 /// This function will panic if `rhs` is 0.
694 /// assert_eq!(100u8.wrapping_div(10), 10);
695 /// assert_eq!((-128i8).wrapping_div(-1), -128);
697 #[stable(feature = "num_wrapping", since = "1.2.0")]
699 pub fn wrapping_div(self, rhs: Self) -> Self {
700 self.overflowing_div(rhs).0
703 /// Wrapping (modular) remainder. Computes `self % other`,
704 /// wrapping around at the boundary of the type.
706 /// Such wrap-around never actually occurs mathematically;
707 /// implementation artifacts make `x % y` invalid for `MIN /
708 /// -1` on a signed type (where `MIN` is the negative
709 /// minimal value). In such a case, this function returns `0`.
713 /// This function will panic if `rhs` is 0.
720 /// assert_eq!(100i8.wrapping_rem(10), 0);
721 /// assert_eq!((-128i8).wrapping_rem(-1), 0);
723 #[stable(feature = "num_wrapping", since = "1.2.0")]
725 pub fn wrapping_rem(self, rhs: Self) -> Self {
726 self.overflowing_rem(rhs).0
729 /// Wrapping (modular) negation. Computes `-self`,
730 /// wrapping around at the boundary of the type.
732 /// The only case where such wrapping can occur is when one
733 /// negates `MIN` on a signed type (where `MIN` is the
734 /// negative minimal value for the type); this is a positive
735 /// value that is too large to represent in the type. In such
736 /// a case, this function returns `MIN` itself.
743 /// assert_eq!(100i8.wrapping_neg(), -100);
744 /// assert_eq!((-128i8).wrapping_neg(), -128);
746 #[stable(feature = "num_wrapping", since = "1.2.0")]
748 pub fn wrapping_neg(self) -> Self {
749 self.overflowing_neg().0
752 /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
753 /// where `mask` removes any high-order bits of `rhs` that
754 /// would cause the shift to exceed the bitwidth of the type.
756 /// Note that this is *not* the same as a rotate-left; the
757 /// RHS of a wrapping shift-left is restricted to the range
758 /// of the type, rather than the bits shifted out of the LHS
759 /// being returned to the other end. The primitive integer
760 /// types all implement a `rotate_left` function, which may
761 /// be what you want instead.
768 /// assert_eq!((-1i8).wrapping_shl(7), -128);
769 /// assert_eq!((-1i8).wrapping_shl(8), -1);
771 #[stable(feature = "num_wrapping", since = "1.2.0")]
773 pub fn wrapping_shl(self, rhs: u32) -> Self {
775 intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
779 /// Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
780 /// where `mask` removes any high-order bits of `rhs` that
781 /// would cause the shift to exceed the bitwidth of the type.
783 /// Note that this is *not* the same as a rotate-right; the
784 /// RHS of a wrapping shift-right is restricted to the range
785 /// of the type, rather than the bits shifted out of the LHS
786 /// being returned to the other end. The primitive integer
787 /// types all implement a `rotate_right` function, which may
788 /// be what you want instead.
795 /// assert_eq!((-128i8).wrapping_shr(7), -1);
796 /// assert_eq!((-128i8).wrapping_shr(8), -128);
798 #[stable(feature = "num_wrapping", since = "1.2.0")]
800 pub fn wrapping_shr(self, rhs: u32) -> Self {
802 intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
806 /// Wrapping (modular) absolute value. Computes `self.abs()`,
807 /// wrapping around at the boundary of the type.
809 /// The only case where such wrapping can occur is when one takes
810 /// the absolute value of the negative minimal value for the type
811 /// this is a positive value that is too large to represent in the
812 /// type. In such a case, this function returns `MIN` itself.
819 /// assert_eq!(100i8.wrapping_abs(), 100);
820 /// assert_eq!((-100i8).wrapping_abs(), 100);
821 /// assert_eq!((-128i8).wrapping_abs(), -128);
822 /// assert_eq!((-128i8).wrapping_abs() as u8, 128);
824 #[stable(feature = "no_panic_abs", since = "1.13.0")]
826 pub fn wrapping_abs(self) -> Self {
827 if self.is_negative() {
834 /// Calculates `self` + `rhs`
836 /// Returns a tuple of the addition along with a boolean indicating
837 /// whether an arithmetic overflow would occur. If an overflow would
838 /// have occurred then the wrapped value is returned.
847 /// assert_eq!(5i32.overflowing_add(2), (7, false));
848 /// assert_eq!(i32::MAX.overflowing_add(1), (i32::MIN, true));
851 #[stable(feature = "wrapping", since = "1.7.0")]
852 pub fn overflowing_add(self, rhs: Self) -> (Self, bool) {
854 let (a, b) = $add_with_overflow(self as $ActualT,
860 /// Calculates `self` - `rhs`
862 /// Returns a tuple of the subtraction along with a boolean indicating
863 /// whether an arithmetic overflow would occur. If an overflow would
864 /// have occurred then the wrapped value is returned.
873 /// assert_eq!(5i32.overflowing_sub(2), (3, false));
874 /// assert_eq!(i32::MIN.overflowing_sub(1), (i32::MAX, true));
877 #[stable(feature = "wrapping", since = "1.7.0")]
878 pub fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
880 let (a, b) = $sub_with_overflow(self as $ActualT,
886 /// Calculates the multiplication of `self` and `rhs`.
888 /// Returns a tuple of the multiplication along with a boolean
889 /// indicating whether an arithmetic overflow would occur. If an
890 /// overflow would have occurred then the wrapped value is returned.
897 /// assert_eq!(5i32.overflowing_mul(2), (10, false));
898 /// assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true));
901 #[stable(feature = "wrapping", since = "1.7.0")]
902 pub fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
904 let (a, b) = $mul_with_overflow(self as $ActualT,
910 /// Calculates the divisor when `self` is divided by `rhs`.
912 /// Returns a tuple of the divisor along with a boolean indicating
913 /// whether an arithmetic overflow would occur. If an overflow would
914 /// occur then self is returned.
918 /// This function will panic if `rhs` is 0.
927 /// assert_eq!(5i32.overflowing_div(2), (2, false));
928 /// assert_eq!(i32::MIN.overflowing_div(-1), (i32::MIN, true));
931 #[stable(feature = "wrapping", since = "1.7.0")]
932 pub fn overflowing_div(self, rhs: Self) -> (Self, bool) {
933 if self == Self::min_value() && rhs == -1 {
940 /// Calculates the remainder when `self` is divided by `rhs`.
942 /// Returns a tuple of the remainder after dividing along with a boolean
943 /// indicating whether an arithmetic overflow would occur. If an
944 /// overflow would occur then 0 is returned.
948 /// This function will panic if `rhs` is 0.
957 /// assert_eq!(5i32.overflowing_rem(2), (1, false));
958 /// assert_eq!(i32::MIN.overflowing_rem(-1), (0, true));
961 #[stable(feature = "wrapping", since = "1.7.0")]
962 pub fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
963 if self == Self::min_value() && rhs == -1 {
970 /// Negates self, overflowing if this is equal to the minimum value.
972 /// Returns a tuple of the negated version of self along with a boolean
973 /// indicating whether an overflow happened. If `self` is the minimum
974 /// value (e.g. `i32::MIN` for values of type `i32`), then the minimum
975 /// value will be returned again and `true` will be returned for an
976 /// overflow happening.
985 /// assert_eq!(2i32.overflowing_neg(), (-2, false));
986 /// assert_eq!(i32::MIN.overflowing_neg(), (i32::MIN, true));
989 #[stable(feature = "wrapping", since = "1.7.0")]
990 pub fn overflowing_neg(self) -> (Self, bool) {
991 if self == Self::min_value() {
992 (Self::min_value(), true)
998 /// Shifts self left by `rhs` bits.
1000 /// Returns a tuple of the shifted version of self along with a boolean
1001 /// indicating whether the shift value was larger than or equal to the
1002 /// number of bits. If the shift value is too large, then value is
1003 /// masked (N-1) where N is the number of bits, and this value is then
1004 /// used to perform the shift.
1011 /// assert_eq!(0x10i32.overflowing_shl(4), (0x100, false));
1012 /// assert_eq!(0x10i32.overflowing_shl(36), (0x100, true));
1015 #[stable(feature = "wrapping", since = "1.7.0")]
1016 pub fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
1017 (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
1020 /// Shifts self right by `rhs` bits.
1022 /// Returns a tuple of the shifted version of self along with a boolean
1023 /// indicating whether the shift value was larger than or equal to the
1024 /// number of bits. If the shift value is too large, then value is
1025 /// masked (N-1) where N is the number of bits, and this value is then
1026 /// used to perform the shift.
1033 /// assert_eq!(0x10i32.overflowing_shr(4), (0x1, false));
1034 /// assert_eq!(0x10i32.overflowing_shr(36), (0x1, true));
1037 #[stable(feature = "wrapping", since = "1.7.0")]
1038 pub fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
1039 (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
1042 /// Computes the absolute value of `self`.
1044 /// Returns a tuple of the absolute version of self along with a
1045 /// boolean indicating whether an overflow happened. If self is the
1046 /// minimum value (e.g. i32::MIN for values of type i32), then the
1047 /// minimum value will be returned again and true will be returned for
1048 /// an overflow happening.
1055 /// assert_eq!(10i8.overflowing_abs(), (10,false));
1056 /// assert_eq!((-10i8).overflowing_abs(), (10,false));
1057 /// assert_eq!((-128i8).overflowing_abs(), (-128,true));
1059 #[stable(feature = "no_panic_abs", since = "1.13.0")]
1061 pub fn overflowing_abs(self) -> (Self, bool) {
1062 if self.is_negative() {
1063 self.overflowing_neg()
1069 /// Raises self to the power of `exp`, using exponentiation by squaring.
1076 /// let x: i32 = 2; // or any other integer type
1078 /// assert_eq!(x.pow(4), 16);
1080 #[stable(feature = "rust1", since = "1.0.0")]
1082 #[rustc_inherit_overflow_checks]
1083 pub fn pow(self, mut exp: u32) -> Self {
1084 let mut base = self;
1095 // Deal with the final bit of the exponent separately, since
1096 // squaring the base afterwards is not necessary and may cause a
1097 // needless overflow.
1105 /// Computes the absolute value of `self`.
1107 /// # Overflow behavior
1109 /// The absolute value of `i32::min_value()` cannot be represented as an
1110 /// `i32`, and attempting to calculate it will cause an overflow. This
1111 /// means that code in debug mode will trigger a panic on this case and
1112 /// optimized code will return `i32::min_value()` without a panic.
1119 /// assert_eq!(10i8.abs(), 10);
1120 /// assert_eq!((-10i8).abs(), 10);
1122 #[stable(feature = "rust1", since = "1.0.0")]
1124 #[rustc_inherit_overflow_checks]
1125 pub fn abs(self) -> Self {
1126 if self.is_negative() {
1127 // Note that the #[inline] above means that the overflow
1128 // semantics of this negation depend on the crate we're being
1136 /// Returns a number representing sign of `self`.
1138 /// - `0` if the number is zero
1139 /// - `1` if the number is positive
1140 /// - `-1` if the number is negative
1147 /// assert_eq!(10i8.signum(), 1);
1148 /// assert_eq!(0i8.signum(), 0);
1149 /// assert_eq!((-10i8).signum(), -1);
1151 #[stable(feature = "rust1", since = "1.0.0")]
1153 pub fn signum(self) -> Self {
1161 /// Returns `true` if `self` is positive and `false` if the number
1162 /// is zero or negative.
1169 /// assert!(10i8.is_positive());
1170 /// assert!(!(-10i8).is_positive());
1172 #[stable(feature = "rust1", since = "1.0.0")]
1174 pub fn is_positive(self) -> bool { self > 0 }
1176 /// Returns `true` if `self` is negative and `false` if the number
1177 /// is zero or positive.
1184 /// assert!((-10i8).is_negative());
1185 /// assert!(!10i8.is_negative());
1187 #[stable(feature = "rust1", since = "1.0.0")]
1189 pub fn is_negative(self) -> bool { self < 0 }
1195 int_impl! { i8, i8, u8, 8,
1196 intrinsics::add_with_overflow,
1197 intrinsics::sub_with_overflow,
1198 intrinsics::mul_with_overflow }
1203 int_impl! { i16, i16, u16, 16,
1204 intrinsics::add_with_overflow,
1205 intrinsics::sub_with_overflow,
1206 intrinsics::mul_with_overflow }
1211 int_impl! { i32, i32, u32, 32,
1212 intrinsics::add_with_overflow,
1213 intrinsics::sub_with_overflow,
1214 intrinsics::mul_with_overflow }
1219 int_impl! { i64, i64, u64, 64,
1220 intrinsics::add_with_overflow,
1221 intrinsics::sub_with_overflow,
1222 intrinsics::mul_with_overflow }
1227 int_impl! { i128, i128, u128, 128,
1228 intrinsics::add_with_overflow,
1229 intrinsics::sub_with_overflow,
1230 intrinsics::mul_with_overflow }
1233 #[cfg(target_pointer_width = "16")]
1236 int_impl! { isize, i16, u16, 16,
1237 intrinsics::add_with_overflow,
1238 intrinsics::sub_with_overflow,
1239 intrinsics::mul_with_overflow }
1242 #[cfg(target_pointer_width = "32")]
1245 int_impl! { isize, i32, u32, 32,
1246 intrinsics::add_with_overflow,
1247 intrinsics::sub_with_overflow,
1248 intrinsics::mul_with_overflow }
1251 #[cfg(target_pointer_width = "64")]
1254 int_impl! { isize, i64, u64, 64,
1255 intrinsics::add_with_overflow,
1256 intrinsics::sub_with_overflow,
1257 intrinsics::mul_with_overflow }
1260 // `Int` + `UnsignedInt` implemented for unsigned integers
1261 macro_rules! uint_impl {
1262 ($SelfT:ty, $ActualT:ty, $BITS:expr,
1267 $add_with_overflow:path,
1268 $sub_with_overflow:path,
1269 $mul_with_overflow:path) => {
1270 /// Returns the smallest value that can be represented by this integer type.
1275 /// assert_eq!(u8::min_value(), 0);
1277 #[stable(feature = "rust1", since = "1.0.0")]
1279 pub const fn min_value() -> Self { 0 }
1281 /// Returns the largest value that can be represented by this integer type.
1286 /// assert_eq!(u8::max_value(), 255);
1288 #[stable(feature = "rust1", since = "1.0.0")]
1290 pub const fn max_value() -> Self { !0 }
1292 /// Converts a string slice in a given base to an integer.
1294 /// Leading and trailing whitespace represent an error.
1301 /// assert_eq!(u32::from_str_radix("A", 16), Ok(10));
1303 #[stable(feature = "rust1", since = "1.0.0")]
1304 pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
1305 from_str_radix(src, radix)
1308 /// Returns the number of ones in the binary representation of `self`.
1315 /// let n = 0b01001100u8;
1317 /// assert_eq!(n.count_ones(), 3);
1319 #[stable(feature = "rust1", since = "1.0.0")]
1321 pub fn count_ones(self) -> u32 {
1322 unsafe { $ctpop(self as $ActualT) as u32 }
1325 /// Returns the number of zeros in the binary representation of `self`.
1332 /// let n = 0b01001100u8;
1334 /// assert_eq!(n.count_zeros(), 5);
1336 #[stable(feature = "rust1", since = "1.0.0")]
1338 pub fn count_zeros(self) -> u32 {
1339 (!self).count_ones()
1342 /// Returns the number of leading zeros in the binary representation
1350 /// let n = 0b0101000u16;
1352 /// assert_eq!(n.leading_zeros(), 10);
1354 #[stable(feature = "rust1", since = "1.0.0")]
1356 pub fn leading_zeros(self) -> u32 {
1357 unsafe { $ctlz(self as $ActualT) as u32 }
1360 /// Returns the number of trailing zeros in the binary representation
1368 /// let n = 0b0101000u16;
1370 /// assert_eq!(n.trailing_zeros(), 3);
1372 #[stable(feature = "rust1", since = "1.0.0")]
1374 pub fn trailing_zeros(self) -> u32 {
1375 // As of LLVM 3.6 the codegen for the zero-safe cttz8 intrinsic
1376 // emits two conditional moves on x86_64. By promoting the value to
1377 // u16 and setting bit 8, we get better code without any conditional
1379 // FIXME: There's a LLVM patch (http://reviews.llvm.org/D9284)
1380 // pending, remove this workaround once LLVM generates better code
1384 intrinsics::cttz(self as u16 | 0x100) as u32
1386 intrinsics::cttz(self) as u32
1391 /// Shifts the bits to the left by a specified amount, `n`,
1392 /// wrapping the truncated bits to the end of the resulting integer.
1394 /// Please note this isn't the same operation as `<<`!
1401 /// let n = 0x0123456789ABCDEFu64;
1402 /// let m = 0x3456789ABCDEF012u64;
1404 /// assert_eq!(n.rotate_left(12), m);
1406 #[stable(feature = "rust1", since = "1.0.0")]
1408 pub fn rotate_left(self, n: u32) -> Self {
1409 // Protect against undefined behaviour for over-long bit shifts
1411 (self << n) | (self >> (($BITS - n) % $BITS))
1414 /// Shifts the bits to the right by a specified amount, `n`,
1415 /// wrapping the truncated bits to the beginning of the resulting
1418 /// Please note this isn't the same operation as `>>`!
1425 /// let n = 0x0123456789ABCDEFu64;
1426 /// let m = 0xDEF0123456789ABCu64;
1428 /// assert_eq!(n.rotate_right(12), m);
1430 #[stable(feature = "rust1", since = "1.0.0")]
1432 pub fn rotate_right(self, n: u32) -> Self {
1433 // Protect against undefined behaviour for over-long bit shifts
1435 (self >> n) | (self << (($BITS - n) % $BITS))
1438 /// Reverses the byte order of the integer.
1445 /// let n = 0x0123456789ABCDEFu64;
1446 /// let m = 0xEFCDAB8967452301u64;
1448 /// assert_eq!(n.swap_bytes(), m);
1450 #[stable(feature = "rust1", since = "1.0.0")]
1452 pub fn swap_bytes(self) -> Self {
1453 unsafe { $bswap(self as $ActualT) as Self }
1456 /// Converts an integer from big endian to the target's endianness.
1458 /// On big endian this is a no-op. On little endian the bytes are
1466 /// let n = 0x0123456789ABCDEFu64;
1468 /// if cfg!(target_endian = "big") {
1469 /// assert_eq!(u64::from_be(n), n)
1471 /// assert_eq!(u64::from_be(n), n.swap_bytes())
1474 #[stable(feature = "rust1", since = "1.0.0")]
1476 pub fn from_be(x: Self) -> Self {
1477 if cfg!(target_endian = "big") { x } else { x.swap_bytes() }
1480 /// Converts an integer from little endian to the target's endianness.
1482 /// On little endian this is a no-op. On big endian the bytes are
1490 /// let n = 0x0123456789ABCDEFu64;
1492 /// if cfg!(target_endian = "little") {
1493 /// assert_eq!(u64::from_le(n), n)
1495 /// assert_eq!(u64::from_le(n), n.swap_bytes())
1498 #[stable(feature = "rust1", since = "1.0.0")]
1500 pub fn from_le(x: Self) -> Self {
1501 if cfg!(target_endian = "little") { x } else { x.swap_bytes() }
1504 /// Converts `self` to big endian from the target's endianness.
1506 /// On big endian this is a no-op. On little endian the bytes are
1514 /// let n = 0x0123456789ABCDEFu64;
1516 /// if cfg!(target_endian = "big") {
1517 /// assert_eq!(n.to_be(), n)
1519 /// assert_eq!(n.to_be(), n.swap_bytes())
1522 #[stable(feature = "rust1", since = "1.0.0")]
1524 pub fn to_be(self) -> Self { // or not to be?
1525 if cfg!(target_endian = "big") { self } else { self.swap_bytes() }
1528 /// Converts `self` to little endian from the target's endianness.
1530 /// On little endian this is a no-op. On big endian the bytes are
1538 /// let n = 0x0123456789ABCDEFu64;
1540 /// if cfg!(target_endian = "little") {
1541 /// assert_eq!(n.to_le(), n)
1543 /// assert_eq!(n.to_le(), n.swap_bytes())
1546 #[stable(feature = "rust1", since = "1.0.0")]
1548 pub fn to_le(self) -> Self {
1549 if cfg!(target_endian = "little") { self } else { self.swap_bytes() }
1552 /// Checked integer addition. Computes `self + other`, returning `None`
1553 /// if overflow occurred.
1560 /// assert_eq!(5u16.checked_add(65530), Some(65535));
1561 /// assert_eq!(6u16.checked_add(65530), None);
1563 #[stable(feature = "rust1", since = "1.0.0")]
1565 pub fn checked_add(self, other: Self) -> Option<Self> {
1566 let (a, b) = self.overflowing_add(other);
1567 if b {None} else {Some(a)}
1570 /// Checked integer subtraction. Computes `self - other`, returning
1571 /// `None` if underflow occurred.
1578 /// assert_eq!(1u8.checked_sub(1), Some(0));
1579 /// assert_eq!(0u8.checked_sub(1), None);
1581 #[stable(feature = "rust1", since = "1.0.0")]
1583 pub fn checked_sub(self, other: Self) -> Option<Self> {
1584 let (a, b) = self.overflowing_sub(other);
1585 if b {None} else {Some(a)}
1588 /// Checked integer multiplication. Computes `self * other`, returning
1589 /// `None` if underflow or overflow occurred.
1596 /// assert_eq!(5u8.checked_mul(51), Some(255));
1597 /// assert_eq!(5u8.checked_mul(52), None);
1599 #[stable(feature = "rust1", since = "1.0.0")]
1601 pub fn checked_mul(self, other: Self) -> Option<Self> {
1602 let (a, b) = self.overflowing_mul(other);
1603 if b {None} else {Some(a)}
1606 /// Checked integer division. Computes `self / other`, returning `None`
1607 /// if `other == 0` or the operation results in underflow or overflow.
1614 /// assert_eq!(128u8.checked_div(2), Some(64));
1615 /// assert_eq!(1u8.checked_div(0), None);
1617 #[stable(feature = "rust1", since = "1.0.0")]
1619 pub fn checked_div(self, other: Self) -> Option<Self> {
1622 other => Some(unsafe { intrinsics::unchecked_div(self, other) }),
1626 /// Checked integer remainder. Computes `self % other`, returning `None`
1627 /// if `other == 0` or the operation results in underflow or overflow.
1634 /// assert_eq!(5u32.checked_rem(2), Some(1));
1635 /// assert_eq!(5u32.checked_rem(0), None);
1637 #[stable(feature = "wrapping", since = "1.7.0")]
1639 pub fn checked_rem(self, other: Self) -> Option<Self> {
1643 Some(unsafe { intrinsics::unchecked_rem(self, other) })
1647 /// Checked negation. Computes `-self`, returning `None` unless `self ==
1650 /// Note that negating any positive integer will overflow.
1657 /// assert_eq!(0u32.checked_neg(), Some(0));
1658 /// assert_eq!(1u32.checked_neg(), None);
1660 #[stable(feature = "wrapping", since = "1.7.0")]
1662 pub fn checked_neg(self) -> Option<Self> {
1663 let (a, b) = self.overflowing_neg();
1664 if b {None} else {Some(a)}
1667 /// Checked shift left. Computes `self << rhs`, returning `None`
1668 /// if `rhs` is larger than or equal to the number of bits in `self`.
1675 /// assert_eq!(0x10u32.checked_shl(4), Some(0x100));
1676 /// assert_eq!(0x10u32.checked_shl(33), None);
1678 #[stable(feature = "wrapping", since = "1.7.0")]
1680 pub fn checked_shl(self, rhs: u32) -> Option<Self> {
1681 let (a, b) = self.overflowing_shl(rhs);
1682 if b {None} else {Some(a)}
1685 /// Checked shift right. Computes `self >> rhs`, returning `None`
1686 /// if `rhs` is larger than or equal to the number of bits in `self`.
1693 /// assert_eq!(0x10u32.checked_shr(4), Some(0x1));
1694 /// assert_eq!(0x10u32.checked_shr(33), None);
1696 #[stable(feature = "wrapping", since = "1.7.0")]
1698 pub fn checked_shr(self, rhs: u32) -> Option<Self> {
1699 let (a, b) = self.overflowing_shr(rhs);
1700 if b {None} else {Some(a)}
1703 /// Saturating integer addition. Computes `self + other`, saturating at
1704 /// the numeric bounds instead of overflowing.
1711 /// assert_eq!(100u8.saturating_add(1), 101);
1712 /// assert_eq!(200u8.saturating_add(127), 255);
1714 #[stable(feature = "rust1", since = "1.0.0")]
1716 pub fn saturating_add(self, other: Self) -> Self {
1717 match self.checked_add(other) {
1719 None => Self::max_value(),
1723 /// Saturating integer subtraction. Computes `self - other`, saturating
1724 /// at the numeric bounds instead of overflowing.
1731 /// assert_eq!(100u8.saturating_sub(27), 73);
1732 /// assert_eq!(13u8.saturating_sub(127), 0);
1734 #[stable(feature = "rust1", since = "1.0.0")]
1736 pub fn saturating_sub(self, other: Self) -> Self {
1737 match self.checked_sub(other) {
1739 None => Self::min_value(),
1743 /// Saturating integer multiplication. Computes `self * other`,
1744 /// saturating at the numeric bounds instead of overflowing.
1753 /// assert_eq!(100u32.saturating_mul(127), 12700);
1754 /// assert_eq!((1u32 << 23).saturating_mul(1 << 23), u32::MAX);
1756 #[stable(feature = "wrapping", since = "1.7.0")]
1758 pub fn saturating_mul(self, other: Self) -> Self {
1759 self.checked_mul(other).unwrap_or(Self::max_value())
1762 /// Wrapping (modular) addition. Computes `self + other`,
1763 /// wrapping around at the boundary of the type.
1770 /// assert_eq!(200u8.wrapping_add(55), 255);
1771 /// assert_eq!(200u8.wrapping_add(155), 99);
1773 #[stable(feature = "rust1", since = "1.0.0")]
1775 pub fn wrapping_add(self, rhs: Self) -> Self {
1777 intrinsics::overflowing_add(self, rhs)
1781 /// Wrapping (modular) subtraction. Computes `self - other`,
1782 /// wrapping around at the boundary of the type.
1789 /// assert_eq!(100u8.wrapping_sub(100), 0);
1790 /// assert_eq!(100u8.wrapping_sub(155), 201);
1792 #[stable(feature = "rust1", since = "1.0.0")]
1794 pub fn wrapping_sub(self, rhs: Self) -> Self {
1796 intrinsics::overflowing_sub(self, rhs)
1800 /// Wrapping (modular) multiplication. Computes `self *
1801 /// other`, wrapping around at the boundary of the type.
1808 /// assert_eq!(10u8.wrapping_mul(12), 120);
1809 /// assert_eq!(25u8.wrapping_mul(12), 44);
1811 #[stable(feature = "rust1", since = "1.0.0")]
1813 pub fn wrapping_mul(self, rhs: Self) -> Self {
1815 intrinsics::overflowing_mul(self, rhs)
1819 /// Wrapping (modular) division. Computes `self / other`.
1820 /// Wrapped division on unsigned types is just normal division.
1821 /// There's no way wrapping could ever happen.
1822 /// This function exists, so that all operations
1823 /// are accounted for in the wrapping operations.
1830 /// assert_eq!(100u8.wrapping_div(10), 10);
1832 #[stable(feature = "num_wrapping", since = "1.2.0")]
1834 pub fn wrapping_div(self, rhs: Self) -> Self {
1838 /// Wrapping (modular) remainder. Computes `self % other`.
1839 /// Wrapped remainder calculation on unsigned types is
1840 /// just the regular remainder calculation.
1841 /// There's no way wrapping could ever happen.
1842 /// This function exists, so that all operations
1843 /// are accounted for in the wrapping operations.
1850 /// assert_eq!(100u8.wrapping_rem(10), 0);
1852 #[stable(feature = "num_wrapping", since = "1.2.0")]
1854 pub fn wrapping_rem(self, rhs: Self) -> Self {
1858 /// Wrapping (modular) negation. Computes `-self`,
1859 /// wrapping around at the boundary of the type.
1861 /// Since unsigned types do not have negative equivalents
1862 /// all applications of this function will wrap (except for `-0`).
1863 /// For values smaller than the corresponding signed type's maximum
1864 /// the result is the same as casting the corresponding signed value.
1865 /// Any larger values are equivalent to `MAX + 1 - (val - MAX - 1)` where
1866 /// `MAX` is the corresponding signed type's maximum.
1873 /// assert_eq!(100u8.wrapping_neg(), 156);
1874 /// assert_eq!(0u8.wrapping_neg(), 0);
1875 /// assert_eq!(180u8.wrapping_neg(), 76);
1876 /// assert_eq!(180u8.wrapping_neg(), (127 + 1) - (180u8 - (127 + 1)));
1878 #[stable(feature = "num_wrapping", since = "1.2.0")]
1880 pub fn wrapping_neg(self) -> Self {
1881 self.overflowing_neg().0
1884 /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
1885 /// where `mask` removes any high-order bits of `rhs` that
1886 /// would cause the shift to exceed the bitwidth of the type.
1888 /// Note that this is *not* the same as a rotate-left; the
1889 /// RHS of a wrapping shift-left is restricted to the range
1890 /// of the type, rather than the bits shifted out of the LHS
1891 /// being returned to the other end. The primitive integer
1892 /// types all implement a `rotate_left` function, which may
1893 /// be what you want instead.
1900 /// assert_eq!(1u8.wrapping_shl(7), 128);
1901 /// assert_eq!(1u8.wrapping_shl(8), 1);
1903 #[stable(feature = "num_wrapping", since = "1.2.0")]
1905 pub fn wrapping_shl(self, rhs: u32) -> Self {
1907 intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
1911 /// Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
1912 /// where `mask` removes any high-order bits of `rhs` that
1913 /// would cause the shift to exceed the bitwidth of the type.
1915 /// Note that this is *not* the same as a rotate-right; the
1916 /// RHS of a wrapping shift-right is restricted to the range
1917 /// of the type, rather than the bits shifted out of the LHS
1918 /// being returned to the other end. The primitive integer
1919 /// types all implement a `rotate_right` function, which may
1920 /// be what you want instead.
1927 /// assert_eq!(128u8.wrapping_shr(7), 1);
1928 /// assert_eq!(128u8.wrapping_shr(8), 128);
1930 #[stable(feature = "num_wrapping", since = "1.2.0")]
1932 pub fn wrapping_shr(self, rhs: u32) -> Self {
1934 intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
1938 /// Calculates `self` + `rhs`
1940 /// Returns a tuple of the addition along with a boolean indicating
1941 /// whether an arithmetic overflow would occur. If an overflow would
1942 /// have occurred then the wrapped value is returned.
1951 /// assert_eq!(5u32.overflowing_add(2), (7, false));
1952 /// assert_eq!(u32::MAX.overflowing_add(1), (0, true));
1955 #[stable(feature = "wrapping", since = "1.7.0")]
1956 pub fn overflowing_add(self, rhs: Self) -> (Self, bool) {
1958 let (a, b) = $add_with_overflow(self as $ActualT,
1964 /// Calculates `self` - `rhs`
1966 /// Returns a tuple of the subtraction along with a boolean indicating
1967 /// whether an arithmetic overflow would occur. If an overflow would
1968 /// have occurred then the wrapped value is returned.
1977 /// assert_eq!(5u32.overflowing_sub(2), (3, false));
1978 /// assert_eq!(0u32.overflowing_sub(1), (u32::MAX, true));
1981 #[stable(feature = "wrapping", since = "1.7.0")]
1982 pub fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
1984 let (a, b) = $sub_with_overflow(self as $ActualT,
1990 /// Calculates the multiplication of `self` and `rhs`.
1992 /// Returns a tuple of the multiplication along with a boolean
1993 /// indicating whether an arithmetic overflow would occur. If an
1994 /// overflow would have occurred then the wrapped value is returned.
2001 /// assert_eq!(5u32.overflowing_mul(2), (10, false));
2002 /// assert_eq!(1_000_000_000u32.overflowing_mul(10), (1410065408, true));
2005 #[stable(feature = "wrapping", since = "1.7.0")]
2006 pub fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
2008 let (a, b) = $mul_with_overflow(self as $ActualT,
2014 /// Calculates the divisor when `self` is divided by `rhs`.
2016 /// Returns a tuple of the divisor along with a boolean indicating
2017 /// whether an arithmetic overflow would occur. Note that for unsigned
2018 /// integers overflow never occurs, so the second value is always
2023 /// This function will panic if `rhs` is 0.
2030 /// assert_eq!(5u32.overflowing_div(2), (2, false));
2033 #[stable(feature = "wrapping", since = "1.7.0")]
2034 pub fn overflowing_div(self, rhs: Self) -> (Self, bool) {
2038 /// Calculates the remainder when `self` is divided by `rhs`.
2040 /// Returns a tuple of the remainder after dividing along with a boolean
2041 /// indicating whether an arithmetic overflow would occur. Note that for
2042 /// unsigned integers overflow never occurs, so the second value is
2047 /// This function will panic if `rhs` is 0.
2054 /// assert_eq!(5u32.overflowing_rem(2), (1, false));
2057 #[stable(feature = "wrapping", since = "1.7.0")]
2058 pub fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
2062 /// Negates self in an overflowing fashion.
2064 /// Returns `!self + 1` using wrapping operations to return the value
2065 /// that represents the negation of this unsigned value. Note that for
2066 /// positive unsigned values overflow always occurs, but negating 0 does
2074 /// assert_eq!(0u32.overflowing_neg(), (0, false));
2075 /// assert_eq!(2u32.overflowing_neg(), (-2i32 as u32, true));
2078 #[stable(feature = "wrapping", since = "1.7.0")]
2079 pub fn overflowing_neg(self) -> (Self, bool) {
2080 ((!self).wrapping_add(1), self != 0)
2083 /// Shifts self left by `rhs` bits.
2085 /// Returns a tuple of the shifted version of self along with a boolean
2086 /// indicating whether the shift value was larger than or equal to the
2087 /// number of bits. If the shift value is too large, then value is
2088 /// masked (N-1) where N is the number of bits, and this value is then
2089 /// used to perform the shift.
2096 /// assert_eq!(0x10u32.overflowing_shl(4), (0x100, false));
2097 /// assert_eq!(0x10u32.overflowing_shl(36), (0x100, true));
2100 #[stable(feature = "wrapping", since = "1.7.0")]
2101 pub fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
2102 (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
2105 /// Shifts self right by `rhs` bits.
2107 /// Returns a tuple of the shifted version of self along with a boolean
2108 /// indicating whether the shift value was larger than or equal to the
2109 /// number of bits. If the shift value is too large, then value is
2110 /// masked (N-1) where N is the number of bits, and this value is then
2111 /// used to perform the shift.
2118 /// assert_eq!(0x10u32.overflowing_shr(4), (0x1, false));
2119 /// assert_eq!(0x10u32.overflowing_shr(36), (0x1, true));
2122 #[stable(feature = "wrapping", since = "1.7.0")]
2123 pub fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
2124 (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
2128 /// Raises self to the power of `exp`, using exponentiation by squaring.
2135 /// assert_eq!(2u32.pow(4), 16);
2137 #[stable(feature = "rust1", since = "1.0.0")]
2139 #[rustc_inherit_overflow_checks]
2140 pub fn pow(self, mut exp: u32) -> Self {
2141 let mut base = self;
2152 // Deal with the final bit of the exponent separately, since
2153 // squaring the base afterwards is not necessary and may cause a
2154 // needless overflow.
2162 /// Returns `true` if and only if `self == 2^k` for some `k`.
2169 /// assert!(16u8.is_power_of_two());
2170 /// assert!(!10u8.is_power_of_two());
2172 #[stable(feature = "rust1", since = "1.0.0")]
2174 pub fn is_power_of_two(self) -> bool {
2175 (self.wrapping_sub(1)) & self == 0 && !(self == 0)
2178 // Returns one less than next power of two.
2179 // (For 8u8 next power of two is 8u8 and for 6u8 it is 8u8)
2181 // 8u8.one_less_than_next_power_of_two() == 7
2182 // 6u8.one_less_than_next_power_of_two() == 7
2184 // This method cannot overflow, as in the `next_power_of_two`
2185 // overflow cases it instead ends up returning the maximum value
2186 // of the type, and can return 0 for 0.
2187 fn one_less_than_next_power_of_two(self) -> Self {
2188 if self <= 1 { return 0; }
2190 // Because `p > 0`, it cannot consist entirely of leading zeros.
2191 // That means the shift is always in-bounds, and some processors
2192 // (such as intel pre-haswell) have more efficient ctlz
2193 // intrinsics when the argument is non-zero.
2195 let z = p.leading_zeros();
2196 <$SelfT>::max_value() >> z
2199 /// Returns the smallest power of two greater than or equal to `self`.
2201 /// When return value overflows (i.e. `self > (1 << (N-1))` for type
2202 /// `uN`), it panics in debug mode and return value is wrapped to 0 in
2203 /// release mode (the only situation in which method can return 0).
2210 /// assert_eq!(2u8.next_power_of_two(), 2);
2211 /// assert_eq!(3u8.next_power_of_two(), 4);
2213 #[stable(feature = "rust1", since = "1.0.0")]
2215 pub fn next_power_of_two(self) -> Self {
2216 self.one_less_than_next_power_of_two() + 1
2219 /// Returns the smallest power of two greater than or equal to `n`. If
2220 /// the next power of two is greater than the type's maximum value,
2221 /// `None` is returned, otherwise the power of two is wrapped in `Some`.
2228 /// assert_eq!(2u8.checked_next_power_of_two(), Some(2));
2229 /// assert_eq!(3u8.checked_next_power_of_two(), Some(4));
2230 /// assert_eq!(200u8.checked_next_power_of_two(), None);
2232 #[stable(feature = "rust1", since = "1.0.0")]
2233 pub fn checked_next_power_of_two(self) -> Option<Self> {
2234 self.one_less_than_next_power_of_two().checked_add(1)
2241 uint_impl! { u8, u8, 8,
2246 intrinsics::add_with_overflow,
2247 intrinsics::sub_with_overflow,
2248 intrinsics::mul_with_overflow }
2253 uint_impl! { u16, u16, 16,
2258 intrinsics::add_with_overflow,
2259 intrinsics::sub_with_overflow,
2260 intrinsics::mul_with_overflow }
2265 uint_impl! { u32, u32, 32,
2270 intrinsics::add_with_overflow,
2271 intrinsics::sub_with_overflow,
2272 intrinsics::mul_with_overflow }
2277 uint_impl! { u64, u64, 64,
2282 intrinsics::add_with_overflow,
2283 intrinsics::sub_with_overflow,
2284 intrinsics::mul_with_overflow }
2289 uint_impl! { u128, u128, 128,
2294 intrinsics::add_with_overflow,
2295 intrinsics::sub_with_overflow,
2296 intrinsics::mul_with_overflow }
2299 #[cfg(target_pointer_width = "16")]
2302 uint_impl! { usize, u16, 16,
2307 intrinsics::add_with_overflow,
2308 intrinsics::sub_with_overflow,
2309 intrinsics::mul_with_overflow }
2311 #[cfg(target_pointer_width = "32")]
2314 uint_impl! { usize, u32, 32,
2319 intrinsics::add_with_overflow,
2320 intrinsics::sub_with_overflow,
2321 intrinsics::mul_with_overflow }
2324 #[cfg(target_pointer_width = "64")]
2327 uint_impl! { usize, u64, 64,
2332 intrinsics::add_with_overflow,
2333 intrinsics::sub_with_overflow,
2334 intrinsics::mul_with_overflow }
2337 /// A classification of floating point numbers.
2339 /// This `enum` is used as the return type for [`f32::classify`] and [`f64::classify`]. See
2340 /// their documentation for more.
2342 /// [`f32::classify`]: ../../std/primitive.f32.html#method.classify
2343 /// [`f64::classify`]: ../../std/primitive.f64.html#method.classify
2348 /// use std::num::FpCategory;
2351 /// let num = 12.4_f32;
2352 /// let inf = f32::INFINITY;
2353 /// let zero = 0f32;
2354 /// let sub: f32 = 1.1754942e-38;
2355 /// let nan = f32::NAN;
2357 /// assert_eq!(num.classify(), FpCategory::Normal);
2358 /// assert_eq!(inf.classify(), FpCategory::Infinite);
2359 /// assert_eq!(zero.classify(), FpCategory::Zero);
2360 /// assert_eq!(nan.classify(), FpCategory::Nan);
2361 /// assert_eq!(sub.classify(), FpCategory::Subnormal);
2363 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
2364 #[stable(feature = "rust1", since = "1.0.0")]
2365 pub enum FpCategory {
2366 /// "Not a Number", often obtained by dividing by zero.
2367 #[stable(feature = "rust1", since = "1.0.0")]
2370 /// Positive or negative infinity.
2371 #[stable(feature = "rust1", since = "1.0.0")]
2374 /// Positive or negative zero.
2375 #[stable(feature = "rust1", since = "1.0.0")]
2378 /// De-normalized floating point representation (less precise than `Normal`).
2379 #[stable(feature = "rust1", since = "1.0.0")]
2382 /// A regular floating point number.
2383 #[stable(feature = "rust1", since = "1.0.0")]
2387 /// A built-in floating point number.
2389 #[unstable(feature = "core_float",
2390 reason = "stable interface is via `impl f{32,64}` in later crates",
2392 pub trait Float: Sized {
2393 /// Returns `true` if this value is NaN and false otherwise.
2394 #[stable(feature = "core", since = "1.6.0")]
2395 fn is_nan(self) -> bool;
2396 /// Returns `true` if this value is positive infinity or negative infinity and
2397 /// false otherwise.
2398 #[stable(feature = "core", since = "1.6.0")]
2399 fn is_infinite(self) -> bool;
2400 /// Returns `true` if this number is neither infinite nor NaN.
2401 #[stable(feature = "core", since = "1.6.0")]
2402 fn is_finite(self) -> bool;
2403 /// Returns `true` if this number is neither zero, infinite, denormal, or NaN.
2404 #[stable(feature = "core", since = "1.6.0")]
2405 fn is_normal(self) -> bool;
2406 /// Returns the category that this number falls into.
2407 #[stable(feature = "core", since = "1.6.0")]
2408 fn classify(self) -> FpCategory;
2410 /// Computes the absolute value of `self`. Returns `Float::nan()` if the
2411 /// number is `Float::nan()`.
2412 #[stable(feature = "core", since = "1.6.0")]
2413 fn abs(self) -> Self;
2414 /// Returns a number that represents the sign of `self`.
2416 /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()`
2417 /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()`
2418 /// - `Float::nan()` if the number is `Float::nan()`
2419 #[stable(feature = "core", since = "1.6.0")]
2420 fn signum(self) -> Self;
2422 /// Returns `true` if `self` is positive, including `+0.0` and
2423 /// `Float::infinity()`.
2424 #[stable(feature = "core", since = "1.6.0")]
2425 fn is_sign_positive(self) -> bool;
2426 /// Returns `true` if `self` is negative, including `-0.0` and
2427 /// `Float::neg_infinity()`.
2428 #[stable(feature = "core", since = "1.6.0")]
2429 fn is_sign_negative(self) -> bool;
2431 /// Take the reciprocal (inverse) of a number, `1/x`.
2432 #[stable(feature = "core", since = "1.6.0")]
2433 fn recip(self) -> Self;
2435 /// Raise a number to an integer power.
2437 /// Using this function is generally faster than using `powf`
2438 #[stable(feature = "core", since = "1.6.0")]
2439 fn powi(self, n: i32) -> Self;
2441 /// Convert radians to degrees.
2442 #[stable(feature = "deg_rad_conversions", since="1.7.0")]
2443 fn to_degrees(self) -> Self;
2444 /// Convert degrees to radians.
2445 #[stable(feature = "deg_rad_conversions", since="1.7.0")]
2446 fn to_radians(self) -> Self;
2449 macro_rules! from_str_radix_int_impl {
2451 #[stable(feature = "rust1", since = "1.0.0")]
2452 impl FromStr for $t {
2453 type Err = ParseIntError;
2454 fn from_str(src: &str) -> Result<Self, ParseIntError> {
2455 from_str_radix(src, 10)
2460 from_str_radix_int_impl! { isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128 }
2462 /// The error type returned when a checked integral type conversion fails.
2463 #[unstable(feature = "try_from", issue = "33417")]
2464 #[derive(Debug, Copy, Clone)]
2465 pub struct TryFromIntError(());
2467 impl TryFromIntError {
2468 #[unstable(feature = "int_error_internals",
2469 reason = "available through Error trait and this method should \
2470 not be exposed publicly",
2473 pub fn __description(&self) -> &str {
2474 "out of range integral type conversion attempted"
2478 #[unstable(feature = "try_from", issue = "33417")]
2479 impl fmt::Display for TryFromIntError {
2480 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
2481 self.__description().fmt(fmt)
2485 macro_rules! same_sign_try_from_int_impl {
2486 ($storage:ty, $target:ty, $($source:ty),*) => {$(
2487 #[unstable(feature = "try_from", issue = "33417")]
2488 impl TryFrom<$source> for $target {
2489 type Error = TryFromIntError;
2491 fn try_from(u: $source) -> Result<$target, TryFromIntError> {
2492 let min = <$target as FromStrRadixHelper>::min_value() as $storage;
2493 let max = <$target as FromStrRadixHelper>::max_value() as $storage;
2494 if u as $storage < min || u as $storage > max {
2495 Err(TryFromIntError(()))
2504 same_sign_try_from_int_impl!(u128, u8, u8, u16, u32, u64, u128, usize);
2505 same_sign_try_from_int_impl!(i128, i8, i8, i16, i32, i64, i128, isize);
2506 same_sign_try_from_int_impl!(u128, u16, u8, u16, u32, u64, u128, usize);
2507 same_sign_try_from_int_impl!(i128, i16, i8, i16, i32, i64, i128, isize);
2508 same_sign_try_from_int_impl!(u128, u32, u8, u16, u32, u64, u128, usize);
2509 same_sign_try_from_int_impl!(i128, i32, i8, i16, i32, i64, i128, isize);
2510 same_sign_try_from_int_impl!(u128, u64, u8, u16, u32, u64, u128, usize);
2511 same_sign_try_from_int_impl!(i128, i64, i8, i16, i32, i64, i128, isize);
2512 same_sign_try_from_int_impl!(u128, u128, u8, u16, u32, u64, u128, usize);
2513 same_sign_try_from_int_impl!(i128, i128, i8, i16, i32, i64, i128, isize);
2514 same_sign_try_from_int_impl!(u128, usize, u8, u16, u32, u64, u128, usize);
2515 same_sign_try_from_int_impl!(i128, isize, i8, i16, i32, i64, i128, isize);
2517 macro_rules! cross_sign_from_int_impl {
2518 ($unsigned:ty, $($signed:ty),*) => {$(
2519 #[unstable(feature = "try_from", issue = "33417")]
2520 impl TryFrom<$unsigned> for $signed {
2521 type Error = TryFromIntError;
2523 fn try_from(u: $unsigned) -> Result<$signed, TryFromIntError> {
2524 let max = <$signed as FromStrRadixHelper>::max_value() as u128;
2525 if u as u128 > max {
2526 Err(TryFromIntError(()))
2533 #[unstable(feature = "try_from", issue = "33417")]
2534 impl TryFrom<$signed> for $unsigned {
2535 type Error = TryFromIntError;
2537 fn try_from(u: $signed) -> Result<$unsigned, TryFromIntError> {
2538 let max = <$unsigned as FromStrRadixHelper>::max_value() as u128;
2539 if u < 0 || u as u128 > max {
2540 Err(TryFromIntError(()))
2549 cross_sign_from_int_impl!(u8, i8, i16, i32, i64, i128, isize);
2550 cross_sign_from_int_impl!(u16, i8, i16, i32, i64, i128, isize);
2551 cross_sign_from_int_impl!(u32, i8, i16, i32, i64, i128, isize);
2552 cross_sign_from_int_impl!(u64, i8, i16, i32, i64, i128, isize);
2553 cross_sign_from_int_impl!(u128, i8, i16, i32, i64, i128, isize);
2554 cross_sign_from_int_impl!(usize, i8, i16, i32, i64, i128, isize);
2557 trait FromStrRadixHelper: PartialOrd + Copy {
2558 fn min_value() -> Self;
2559 fn max_value() -> Self;
2560 fn from_u32(u: u32) -> Self;
2561 fn checked_mul(&self, other: u32) -> Option<Self>;
2562 fn checked_sub(&self, other: u32) -> Option<Self>;
2563 fn checked_add(&self, other: u32) -> Option<Self>;
2567 ($($t:ty)*) => ($(impl FromStrRadixHelper for $t {
2568 fn min_value() -> Self { Self::min_value() }
2569 fn max_value() -> Self { Self::max_value() }
2570 fn from_u32(u: u32) -> Self { u as Self }
2571 fn checked_mul(&self, other: u32) -> Option<Self> {
2572 Self::checked_mul(*self, other as Self)
2574 fn checked_sub(&self, other: u32) -> Option<Self> {
2575 Self::checked_sub(*self, other as Self)
2577 fn checked_add(&self, other: u32) -> Option<Self> {
2578 Self::checked_add(*self, other as Self)
2582 doit! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }
2584 fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, ParseIntError> {
2585 use self::IntErrorKind::*;
2586 use self::ParseIntError as PIE;
2588 assert!(radix >= 2 && radix <= 36,
2589 "from_str_radix_int: must lie in the range `[2, 36]` - found {}",
2593 return Err(PIE { kind: Empty });
2596 let is_signed_ty = T::from_u32(0) > T::min_value();
2598 // all valid digits are ascii, so we will just iterate over the utf8 bytes
2599 // and cast them to chars. .to_digit() will safely return None for anything
2600 // other than a valid ascii digit for the given radix, including the first-byte
2601 // of multi-byte sequences
2602 let src = src.as_bytes();
2604 let (is_positive, digits) = match src[0] {
2605 b'+' => (true, &src[1..]),
2606 b'-' if is_signed_ty => (false, &src[1..]),
2610 if digits.is_empty() {
2611 return Err(PIE { kind: Empty });
2614 let mut result = T::from_u32(0);
2616 // The number is positive
2618 let x = match (c as char).to_digit(radix) {
2620 None => return Err(PIE { kind: InvalidDigit }),
2622 result = match result.checked_mul(radix) {
2623 Some(result) => result,
2624 None => return Err(PIE { kind: Overflow }),
2626 result = match result.checked_add(x) {
2627 Some(result) => result,
2628 None => return Err(PIE { kind: Overflow }),
2632 // The number is negative
2634 let x = match (c as char).to_digit(radix) {
2636 None => return Err(PIE { kind: InvalidDigit }),
2638 result = match result.checked_mul(radix) {
2639 Some(result) => result,
2640 None => return Err(PIE { kind: Underflow }),
2642 result = match result.checked_sub(x) {
2643 Some(result) => result,
2644 None => return Err(PIE { kind: Underflow }),
2651 /// An error which can be returned when parsing an integer.
2653 /// This error is used as the error type for the `from_str_radix()` functions
2654 /// on the primitive integer types, such as [`i8::from_str_radix`].
2656 /// [`i8::from_str_radix`]: ../../std/primitive.i8.html#method.from_str_radix
2657 #[derive(Debug, Clone, PartialEq, Eq)]
2658 #[stable(feature = "rust1", since = "1.0.0")]
2659 pub struct ParseIntError {
2663 #[derive(Debug, Clone, PartialEq, Eq)]
2671 impl ParseIntError {
2672 #[unstable(feature = "int_error_internals",
2673 reason = "available through Error trait and this method should \
2674 not be exposed publicly",
2677 pub fn __description(&self) -> &str {
2679 IntErrorKind::Empty => "cannot parse integer from empty string",
2680 IntErrorKind::InvalidDigit => "invalid digit found in string",
2681 IntErrorKind::Overflow => "number too large to fit in target type",
2682 IntErrorKind::Underflow => "number too small to fit in target type",
2687 #[stable(feature = "rust1", since = "1.0.0")]
2688 impl fmt::Display for ParseIntError {
2689 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2690 self.__description().fmt(f)
2694 #[stable(feature = "rust1", since = "1.0.0")]
2695 pub use num::dec2flt::ParseFloatError;
2697 // Conversion traits for primitive integer and float types
2698 // Conversions T -> T are covered by a blanket impl and therefore excluded
2699 // Some conversions from and to usize/isize are not implemented due to portability concerns
2700 macro_rules! impl_from {
2701 ($Small: ty, $Large: ty, #[$attr:meta]) => {
2703 impl From<$Small> for $Large {
2705 fn from(small: $Small) -> $Large {
2712 // Unsigned -> Unsigned
2713 impl_from! { u8, u16, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2714 impl_from! { u8, u32, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2715 impl_from! { u8, u64, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2716 impl_from! { u8, u128, #[unstable(feature = "i128", issue = "35118")] }
2717 impl_from! { u8, usize, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2718 impl_from! { u16, u32, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2719 impl_from! { u16, u64, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2720 impl_from! { u16, u128, #[unstable(feature = "i128", issue = "35118")] }
2721 impl_from! { u32, u64, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2722 impl_from! { u32, u128, #[unstable(feature = "i128", issue = "35118")] }
2723 impl_from! { u64, u128, #[unstable(feature = "i128", issue = "35118")] }
2726 impl_from! { i8, i16, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2727 impl_from! { i8, i32, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2728 impl_from! { i8, i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2729 impl_from! { i8, i128, #[unstable(feature = "i128", issue = "35118")] }
2730 impl_from! { i8, isize, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2731 impl_from! { i16, i32, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2732 impl_from! { i16, i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2733 impl_from! { i16, i128, #[unstable(feature = "i128", issue = "35118")] }
2734 impl_from! { i32, i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2735 impl_from! { i32, i128, #[unstable(feature = "i128", issue = "35118")] }
2736 impl_from! { i64, i128, #[unstable(feature = "i128", issue = "35118")] }
2738 // Unsigned -> Signed
2739 impl_from! { u8, i16, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2740 impl_from! { u8, i32, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2741 impl_from! { u8, i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2742 impl_from! { u8, i128, #[unstable(feature = "i128", issue = "35118")] }
2743 impl_from! { u16, i32, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2744 impl_from! { u16, i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2745 impl_from! { u16, i128, #[unstable(feature = "i128", issue = "35118")] }
2746 impl_from! { u32, i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")] }
2747 impl_from! { u32, i128, #[unstable(feature = "i128", issue = "35118")] }
2748 impl_from! { u64, i128, #[unstable(feature = "i128", issue = "35118")] }
2750 // Note: integers can only be represented with full precision in a float if
2751 // they fit in the significand, which is 24 bits in f32 and 53 bits in f64.
2752 // Lossy float conversions are not implemented at this time.
2755 impl_from! { i8, f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2756 impl_from! { i8, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2757 impl_from! { i16, f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2758 impl_from! { i16, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2759 impl_from! { i32, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2761 // Unsigned -> Float
2762 impl_from! { u8, f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2763 impl_from! { u8, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2764 impl_from! { u16, f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2765 impl_from! { u16, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2766 impl_from! { u32, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
2769 impl_from! { f32, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }