Struct otter_base::prelude::Wrapping 1.0.0[−][src]
#[repr(transparent)]pub struct Wrapping<T>(pub T);
Expand description
Provides intentionally-wrapped arithmetic on T
.
Operations like +
on u32
values are intended to never overflow,
and in some debug configurations overflow is detected and results
in a panic. While most arithmetic falls into this category, some
code explicitly expects and relies upon modular arithmetic (e.g.,
hashing).
Wrapping arithmetic can be achieved either through methods like
wrapping_add
, or through the Wrapping<T>
type, which says that
all standard arithmetic operations on the underlying value are
intended to have wrapping semantics.
The underlying value can be retrieved through the .0
index of the
Wrapping
tuple.
Examples
use std::num::Wrapping; let zero = Wrapping(0u32); let one = Wrapping(1u32); assert_eq!(u32::MAX, (zero - one).0);
Implementations
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<usize>>::MIN, Wrapping(usize::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<usize>>::MAX, Wrapping(usize::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<usize>>::BITS, usize::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100usize); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0usize).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000usize); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ausize); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<usize>>::from_be(n), n) } else { assert_eq!(<Wrapping<usize>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ausize); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<usize>>::from_le(n), n) } else { assert_eq!(<Wrapping<usize>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ausize); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ausize); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3usize).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u8>>::MIN, Wrapping(u8::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u8>>::MAX, Wrapping(u8::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u8>>::BITS, u8::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u8); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u8).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u8); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au8); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u8>>::from_be(n), n) } else { assert_eq!(<Wrapping<u8>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au8); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u8>>::from_le(n), n) } else { assert_eq!(<Wrapping<u8>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au8); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au8); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u8).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u16>>::MIN, Wrapping(u16::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u16>>::MAX, Wrapping(u16::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u16>>::BITS, u16::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u16); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u16).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u16); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au16); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u16>>::from_be(n), n) } else { assert_eq!(<Wrapping<u16>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au16); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u16>>::from_le(n), n) } else { assert_eq!(<Wrapping<u16>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au16); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au16); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u16).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u32>>::MIN, Wrapping(u32::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u32>>::MAX, Wrapping(u32::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u32>>::BITS, u32::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u32); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u32).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u32); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au32); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u32>>::from_be(n), n) } else { assert_eq!(<Wrapping<u32>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au32); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u32>>::from_le(n), n) } else { assert_eq!(<Wrapping<u32>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au32); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au32); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u32).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u64>>::MIN, Wrapping(u64::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u64>>::MAX, Wrapping(u64::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u64>>::BITS, u64::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u64); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u64).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u64); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au64); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u64>>::from_be(n), n) } else { assert_eq!(<Wrapping<u64>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au64); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u64>>::from_le(n), n) } else { assert_eq!(<Wrapping<u64>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au64); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au64); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u64).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u128>>::MIN, Wrapping(u128::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u128>>::MAX, Wrapping(u128::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u128>>::BITS, u128::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u128); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u128).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u128); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au128); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u128>>::from_be(n), n) } else { assert_eq!(<Wrapping<u128>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au128); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u128>>::from_le(n), n) } else { assert_eq!(<Wrapping<u128>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au128); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au128); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u128).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<isize>>::MIN, Wrapping(isize::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<isize>>::MAX, Wrapping(isize::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<isize>>::BITS, isize::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100isize); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0isize).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000isize); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Aisize); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<isize>>::from_be(n), n) } else { assert_eq!(<Wrapping<isize>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Aisize); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<isize>>::from_le(n), n) } else { assert_eq!(<Wrapping<isize>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Aisize); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Aisize); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3isize).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i8>>::MIN, Wrapping(i8::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i8>>::MAX, Wrapping(i8::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i8>>::BITS, i8::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i8); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i8).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i8); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai8); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i8>>::from_be(n), n) } else { assert_eq!(<Wrapping<i8>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai8); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i8>>::from_le(n), n) } else { assert_eq!(<Wrapping<i8>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai8); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai8); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i16>>::MIN, Wrapping(i16::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i16>>::MAX, Wrapping(i16::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i16>>::BITS, i16::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i16); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i16).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i16); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai16); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i16>>::from_be(n), n) } else { assert_eq!(<Wrapping<i16>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai16); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i16>>::from_le(n), n) } else { assert_eq!(<Wrapping<i16>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai16); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai16); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i16).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i32>>::MIN, Wrapping(i32::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i32>>::MAX, Wrapping(i32::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i32>>::BITS, i32::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i32); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i32).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i32); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai32); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i32>>::from_be(n), n) } else { assert_eq!(<Wrapping<i32>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai32); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i32>>::from_le(n), n) } else { assert_eq!(<Wrapping<i32>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai32); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai32); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i32).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i64>>::MIN, Wrapping(i64::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i64>>::MAX, Wrapping(i64::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i64>>::BITS, i64::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i64); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i64).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i64); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai64); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i64>>::from_be(n), n) } else { assert_eq!(<Wrapping<i64>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai64); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i64>>::from_le(n), n) } else { assert_eq!(<Wrapping<i64>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai64); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai64); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i64).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i128>>::MIN, Wrapping(i128::MIN));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i128>>::MAX, Wrapping(i128::MAX));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i128>>::BITS, i128::BITS);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i128); assert_eq!(n.count_ones(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i128).count_zeros(), 0);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i128); assert_eq!(n.trailing_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai128); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i128>>::from_be(n), n) } else { assert_eq!(<Wrapping<i128>>::from_be(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai128); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i128>>::from_le(n), n) } else { assert_eq!(<Wrapping<i128>>::from_le(n), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai128); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai128); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i128).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(isize::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100isize).abs(), Wrapping(100)); assert_eq!(Wrapping(-100isize).abs(), Wrapping(100)); assert_eq!(Wrapping(isize::MIN).abs(), Wrapping(isize::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10isize).signum(), Wrapping(1)); assert_eq!(Wrapping(0isize).signum(), Wrapping(0)); assert_eq!(Wrapping(-10isize).signum(), Wrapping(-1));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10isize).is_positive()); assert!(!Wrapping(-10isize).is_positive());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10isize).is_negative()); assert!(!Wrapping(10isize).is_negative());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i8::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i8).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i8).abs(), Wrapping(100)); assert_eq!(Wrapping(i8::MIN).abs(), Wrapping(i8::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i8).signum(), Wrapping(1)); assert_eq!(Wrapping(0i8).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i8).signum(), Wrapping(-1));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i8).is_positive()); assert!(!Wrapping(-10i8).is_positive());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i8).is_negative()); assert!(!Wrapping(10i8).is_negative());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i16::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i16).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i16).abs(), Wrapping(100)); assert_eq!(Wrapping(i16::MIN).abs(), Wrapping(i16::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i16).signum(), Wrapping(1)); assert_eq!(Wrapping(0i16).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i16).signum(), Wrapping(-1));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i16).is_positive()); assert!(!Wrapping(-10i16).is_positive());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i16).is_negative()); assert!(!Wrapping(10i16).is_negative());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i32::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i32).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i32).abs(), Wrapping(100)); assert_eq!(Wrapping(i32::MIN).abs(), Wrapping(i32::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i32).signum(), Wrapping(1)); assert_eq!(Wrapping(0i32).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i32).signum(), Wrapping(-1));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i32).is_positive()); assert!(!Wrapping(-10i32).is_positive());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i32).is_negative()); assert!(!Wrapping(10i32).is_negative());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i64::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i64).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i64).abs(), Wrapping(100)); assert_eq!(Wrapping(i64::MIN).abs(), Wrapping(i64::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i64).signum(), Wrapping(1)); assert_eq!(Wrapping(0i64).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i64).signum(), Wrapping(-1));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i64).is_positive()); assert!(!Wrapping(-10i64).is_positive());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i64).is_negative()); assert!(!Wrapping(10i64).is_negative());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i128::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i128).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i128).abs(), Wrapping(100)); assert_eq!(Wrapping(i128::MIN).abs(), Wrapping(i128::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i128).signum(), Wrapping(1)); assert_eq!(Wrapping(0i128).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i128).signum(), Wrapping(-1));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i128).is_positive()); assert!(!Wrapping(-10i128).is_positive());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i128).is_negative()); assert!(!Wrapping(10i128).is_negative());
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(usize::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16usize).is_power_of_two()); assert!(!Wrapping(10usize).is_power_of_two());
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2usize).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3usize).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u8::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u8).is_power_of_two()); assert!(!Wrapping(10u8).is_power_of_two());
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u8).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u8).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u16::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u16).is_power_of_two()); assert!(!Wrapping(10u16).is_power_of_two());
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u16).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u16).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u32::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u32).is_power_of_two()); assert!(!Wrapping(10u32).is_power_of_two());
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u32).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u32).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u64::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u64).is_power_of_two()); assert!(!Wrapping(10u64).is_power_of_two());
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u64).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u64).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u128::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u128).is_power_of_two()); assert!(!Wrapping(10u128).is_power_of_two());
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u128).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u128).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
Trait Implementations
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
pub fn deserialize<D>(
deserializer: D
) -> Result<Wrapping<T>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
pub fn deserialize<D>(
deserializer: D
) -> Result<Wrapping<T>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Converts an isize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an i8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an i16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an i32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an i64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an i128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts a usize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts a f32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
impl<T> Num for Wrapping<T> where
T: Num,
Wrapping<T>: Mul<Wrapping<T>>,
Wrapping<T>: Add<Wrapping<T>>,
Wrapping<T>: Div<Wrapping<T>>,
Wrapping<T>: Rem<Wrapping<T>>,
Wrapping<T>: Sub<Wrapping<T>>,
<Wrapping<T> as Add<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Sub<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Mul<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Div<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Rem<Wrapping<T>>>::Output == Wrapping<T>,
impl<T> Num for Wrapping<T> where
T: Num,
Wrapping<T>: Mul<Wrapping<T>>,
Wrapping<T>: Add<Wrapping<T>>,
Wrapping<T>: Div<Wrapping<T>>,
Wrapping<T>: Rem<Wrapping<T>>,
Wrapping<T>: Sub<Wrapping<T>>,
<Wrapping<T> as Add<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Sub<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Mul<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Div<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Rem<Wrapping<T>>>::Output == Wrapping<T>,
type FromStrRadixErr = <T as Num>::FromStrRadixErr
pub fn from_str_radix(
str: &str,
radix: u32
) -> Result<Wrapping<T>, <Wrapping<T> as Num>::FromStrRadixErr>
pub fn from_str_radix(
str: &str,
radix: u32
) -> Result<Wrapping<T>, <Wrapping<T> as Num>::FromStrRadixErr>
Convert from a string and radix (typically 2..=36
). Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
pub fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
pub fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
Serialize this value into the given Serde serializer. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
The positive difference of two numbers. Read more
Returns true if the number is positive and false if the number is zero or negative.
Returns true if the number is negative and false if the number is zero or positive.
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Converts the value of self
to an isize
. If the value cannot be
represented by an isize
, then None
is returned. Read more
Converts the value of self
to an i8
. If the value cannot be
represented by an i8
, then None
is returned. Read more
Converts the value of self
to an i16
. If the value cannot be
represented by an i16
, then None
is returned. Read more
Converts the value of self
to an i32
. If the value cannot be
represented by an i32
, then None
is returned. Read more
Converts the value of self
to an i64
. If the value cannot be
represented by an i64
, then None
is returned. Read more
Converts the value of self
to an i128
. If the value cannot be
represented by an i128
(i64
under the default implementation), then
None
is returned. Read more
Converts the value of self
to a usize
. If the value cannot be
represented by a usize
, then None
is returned. Read more
Converts the value of self
to a u8
. If the value cannot be
represented by a u8
, then None
is returned. Read more
Converts the value of self
to a u16
. If the value cannot be
represented by a u16
, then None
is returned. Read more
Converts the value of self
to a u32
. If the value cannot be
represented by a u32
, then None
is returned. Read more
Converts the value of self
to a u64
. If the value cannot be
represented by a u64
, then None
is returned. Read more
Converts the value of self
to a u128
. If the value cannot be
represented by a u128
(u64
under the default implementation), then
None
is returned. Read more
Converts the value of self
to an f32
. Overflows may map to positive
or negative inifinity, otherwise None
is returned if the value cannot
be represented by an f32
. Read more
Wrapping (modular) addition. Computes self + other
, wrapping around at the boundary of
the type. Read more
Wrapping (modular) multiplication. Computes self * other
, wrapping around at the boundary
of the type. Read more
impl<T> WrappingNeg for Wrapping<T> where
T: WrappingNeg,
Wrapping<T>: Neg,
<Wrapping<T> as Neg>::Output == Wrapping<T>,
impl<T> WrappingNeg for Wrapping<T> where
T: WrappingNeg,
Wrapping<T>: Neg,
<Wrapping<T> as Neg>::Output == Wrapping<T>,
Wrapping (modular) negation. Computes -self
,
wrapping around at the boundary of the type. Read more
Panic-free bitwise shift-left; yields self << mask(rhs)
,
where mask
removes any high order bits of rhs
that would
cause the shift to exceed the bitwidth of the type. Read more
Panic-free bitwise shift-right; yields self >> mask(rhs)
,
where mask
removes any high order bits of rhs
that would
cause the shift to exceed the bitwidth of the type. Read more
Wrapping (modular) subtraction. Computes self - other
, wrapping around at the boundary
of the type. Read more
Auto Trait Implementations
impl<T> RefUnwindSafe for Wrapping<T> where
T: RefUnwindSafe,
impl<T> UnwindSafe for Wrapping<T> where
T: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
impl<T, Rhs> NumAssignOps<Rhs> for T where
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,