Primitive Type u32 [−]
The 32-bit unsigned integer type.
Methods
impl u32
const fn min_value() -> u32
Returns the smallest value that can be represented by this integer type.
const fn max_value() -> u32
Returns the largest value that can be represented by this integer type.
fn from_str_radix(src: &str, radix: u32) -> Result<u32, ParseIntError>
Converts a string slice in a given base to an integer.
Leading and trailing whitespace represent an error.
Arguments
- src - A string slice
- radix - The base to use. Must lie in the range [2 .. 36]
Return value
Err(ParseIntError) if the string did not represent a valid number.
Otherwise, Ok(n) where n is the integer represented by src.
fn count_ones(self) -> u32
Returns the number of ones in the binary representation of self.
Examples
Basic usage:
fn main() { let n = 0b01001100u8; assert_eq!(n.count_ones(), 3); }let n = 0b01001100u8; assert_eq!(n.count_ones(), 3);
fn count_zeros(self) -> u32
Returns the number of zeros in the binary representation of self.
Examples
Basic usage:
fn main() { let n = 0b01001100u8; assert_eq!(n.count_zeros(), 5); }let n = 0b01001100u8; assert_eq!(n.count_zeros(), 5);
fn leading_zeros(self) -> u32
Returns the number of leading zeros in the binary representation
of self.
Examples
Basic usage:
fn main() { let n = 0b0101000u16; assert_eq!(n.leading_zeros(), 10); }let n = 0b0101000u16; assert_eq!(n.leading_zeros(), 10);
fn trailing_zeros(self) -> u32
Returns the number of trailing zeros in the binary representation
of self.
Examples
Basic usage:
fn main() { let n = 0b0101000u16; assert_eq!(n.trailing_zeros(), 3); }let n = 0b0101000u16; assert_eq!(n.trailing_zeros(), 3);
fn rotate_left(self, n: u32) -> u32
Shifts the bits to the left by a specified amount, n,
wrapping the truncated bits to the end of the resulting integer.
Examples
Basic usage:
fn main() { let n = 0x0123456789ABCDEFu64; let m = 0x3456789ABCDEF012u64; assert_eq!(n.rotate_left(12), m); }let n = 0x0123456789ABCDEFu64; let m = 0x3456789ABCDEF012u64; assert_eq!(n.rotate_left(12), m);
fn rotate_right(self, n: u32) -> u32
Shifts the bits to the right by a specified amount, n,
wrapping the truncated bits to the beginning of the resulting
integer.
Examples
Basic usage:
fn main() { let n = 0x0123456789ABCDEFu64; let m = 0xDEF0123456789ABCu64; assert_eq!(n.rotate_right(12), m); }let n = 0x0123456789ABCDEFu64; let m = 0xDEF0123456789ABCu64; assert_eq!(n.rotate_right(12), m);
fn swap_bytes(self) -> u32
Reverses the byte order of the integer.
Examples
Basic usage:
fn main() { let n = 0x0123456789ABCDEFu64; let m = 0xEFCDAB8967452301u64; assert_eq!(n.swap_bytes(), m); }let n = 0x0123456789ABCDEFu64; let m = 0xEFCDAB8967452301u64; assert_eq!(n.swap_bytes(), m);
fn from_be(x: u32) -> u32
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:
fn main() { let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "big") { assert_eq!(u64::from_be(n), n) } else { assert_eq!(u64::from_be(n), n.swap_bytes()) } }let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "big") { assert_eq!(u64::from_be(n), n) } else { assert_eq!(u64::from_be(n), n.swap_bytes()) }
fn from_le(x: u32) -> u32
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:
fn main() { let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "little") { assert_eq!(u64::from_le(n), n) } else { assert_eq!(u64::from_le(n), n.swap_bytes()) } }let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "little") { assert_eq!(u64::from_le(n), n) } else { assert_eq!(u64::from_le(n), n.swap_bytes()) }
fn to_be(self) -> u32
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:
fn main() { let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) } }let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
fn to_le(self) -> u32
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:
fn main() { let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) } }let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
fn checked_add(self, other: u32) -> Option<u32>
Checked integer addition. Computes self + other, returning None
if overflow occurred.
Examples
Basic usage:
fn main() { assert_eq!(5u16.checked_add(65530), Some(65535)); assert_eq!(6u16.checked_add(65530), None); }assert_eq!(5u16.checked_add(65530), Some(65535)); assert_eq!(6u16.checked_add(65530), None);
fn checked_sub(self, other: u32) -> Option<u32>
Checked integer subtraction. Computes self - other, returning
None if underflow occurred.
Examples
Basic usage:
fn main() { assert_eq!((-127i8).checked_sub(1), Some(-128)); assert_eq!((-128i8).checked_sub(1), None); }assert_eq!((-127i8).checked_sub(1), Some(-128)); assert_eq!((-128i8).checked_sub(1), None);
fn checked_mul(self, other: u32) -> Option<u32>
Checked integer multiplication. Computes self * other, returning
None if underflow or overflow occurred.
Examples
Basic usage:
fn main() { assert_eq!(5u8.checked_mul(51), Some(255)); assert_eq!(5u8.checked_mul(52), None); }assert_eq!(5u8.checked_mul(51), Some(255)); assert_eq!(5u8.checked_mul(52), None);
fn checked_div(self, other: u32) -> Option<u32>
Checked integer division. Computes self / other, returning None
if other == 0 or the operation results in underflow or overflow.
Examples
Basic usage:
fn main() { assert_eq!((-127i8).checked_div(-1), Some(127)); assert_eq!((-128i8).checked_div(-1), None); assert_eq!((1i8).checked_div(0), None); }assert_eq!((-127i8).checked_div(-1), Some(127)); assert_eq!((-128i8).checked_div(-1), None); assert_eq!((1i8).checked_div(0), None);
fn saturating_add(self, other: u32) -> u32
Saturating integer addition. Computes self + other, saturating at
the numeric bounds instead of overflowing.
Examples
Basic usage:
fn main() { assert_eq!(100i8.saturating_add(1), 101); assert_eq!(100i8.saturating_add(127), 127); }assert_eq!(100i8.saturating_add(1), 101); assert_eq!(100i8.saturating_add(127), 127);
fn saturating_sub(self, other: u32) -> u32
Saturating integer subtraction. Computes self - other, saturating
at the numeric bounds instead of overflowing.
Examples
Basic usage:
fn main() { assert_eq!(100i8.saturating_sub(127), -27); assert_eq!((-100i8).saturating_sub(127), -128); }assert_eq!(100i8.saturating_sub(127), -27); assert_eq!((-100i8).saturating_sub(127), -128);
fn wrapping_add(self, rhs: u32) -> u32
Wrapping (modular) addition. Computes self + other,
wrapping around at the boundary of the type.
Examples
Basic usage:
fn main() { assert_eq!(100i8.wrapping_add(27), 127); assert_eq!(100i8.wrapping_add(127), -29); }assert_eq!(100i8.wrapping_add(27), 127); assert_eq!(100i8.wrapping_add(127), -29);
fn wrapping_sub(self, rhs: u32) -> u32
Wrapping (modular) subtraction. Computes self - other,
wrapping around at the boundary of the type.
Examples
Basic usage:
fn main() { assert_eq!(0i8.wrapping_sub(127), -127); assert_eq!((-2i8).wrapping_sub(127), 127); }assert_eq!(0i8.wrapping_sub(127), -127); assert_eq!((-2i8).wrapping_sub(127), 127);
fn wrapping_mul(self, rhs: u32) -> u32
Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.
Examples
Basic usage:
fn main() { assert_eq!(10i8.wrapping_mul(12), 120); assert_eq!(11i8.wrapping_mul(12), -124); }assert_eq!(10i8.wrapping_mul(12), 120); assert_eq!(11i8.wrapping_mul(12), -124);
fn wrapping_div(self, rhs: u32) -> u32
Wrapping (modular) division. Computes self / other,
wrapping around at the boundary of the type.
The only case where such wrapping can occur is when one
divides MIN / -1 on a signed type (where MIN is the
negative minimal value for the type); this is equivalent
to -MIN, a positive value that is too large to represent
in the type. In such a case, this function returns MIN
itself.
Examples
Basic usage:
fn main() { assert_eq!(100u8.wrapping_div(10), 10); assert_eq!((-128i8).wrapping_div(-1), -128); }assert_eq!(100u8.wrapping_div(10), 10); assert_eq!((-128i8).wrapping_div(-1), -128);
fn wrapping_rem(self, rhs: u32) -> u32
Wrapping (modular) remainder. Computes self % other,
wrapping around at the boundary of the type.
Such wrap-around never actually occurs mathematically;
implementation artifacts make x % y invalid for MIN / -1 on a signed type (where MIN is the negative
minimal value). In such a case, this function returns 0.
Examples
Basic usage:
fn main() { assert_eq!(100i8.wrapping_rem(10), 0); assert_eq!((-128i8).wrapping_rem(-1), 0); }assert_eq!(100i8.wrapping_rem(10), 0); assert_eq!((-128i8).wrapping_rem(-1), 0);
fn wrapping_neg(self) -> u32
Wrapping (modular) negation. Computes -self,
wrapping around at the boundary of the type.
The only case where such wrapping can occur is when one
negates MIN on a signed type (where MIN is 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:
fn main() { assert_eq!(100i8.wrapping_neg(), -100); assert_eq!((-128i8).wrapping_neg(), -128); }assert_eq!(100i8.wrapping_neg(), -100); assert_eq!((-128i8).wrapping_neg(), -128);
fn wrapping_shl(self, rhs: u32) -> u32
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.
Examples
Basic usage:
fn main() { assert_eq!(1u8.wrapping_shl(7), 128); assert_eq!(1u8.wrapping_shl(8), 1); }assert_eq!(1u8.wrapping_shl(7), 128); assert_eq!(1u8.wrapping_shl(8), 1);
fn wrapping_shr(self, rhs: u32) -> u32
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.
Examples
Basic usage:
fn main() { assert_eq!(128u8.wrapping_shr(7), 1); assert_eq!(128u8.wrapping_shr(8), 128); }assert_eq!(128u8.wrapping_shr(7), 1); assert_eq!(128u8.wrapping_shr(8), 128);
fn pow(self, exp: u32) -> u32
Raises self to the power of exp, using exponentiation by squaring.
Examples
Basic usage:
fn main() { assert_eq!(2i32.pow(4), 16); }assert_eq!(2i32.pow(4), 16);
fn is_power_of_two(self) -> bool
Returns true if and only if self == 2^k for some k.
Examples
Basic usage:
fn main() { assert!(16u8.is_power_of_two()); assert!(!10u8.is_power_of_two()); }assert!(16u8.is_power_of_two()); assert!(!10u8.is_power_of_two());
fn next_power_of_two(self) -> u32
Returns the smallest power of two greater than or equal to self.
Unspecified behavior on overflow.
Examples
Basic usage:
fn main() { assert_eq!(2u8.next_power_of_two(), 2); assert_eq!(3u8.next_power_of_two(), 4); }assert_eq!(2u8.next_power_of_two(), 2); assert_eq!(3u8.next_power_of_two(), 4);
fn checked_next_power_of_two(self) -> Option<u32>
Returns the smallest power of two greater than or equal to n. If
the next power of two is greater than the type's maximum value,
None is returned, otherwise the power of two is wrapped in Some.
Examples
Basic usage:
fn main() { assert_eq!(2u8.checked_next_power_of_two(), Some(2)); assert_eq!(3u8.checked_next_power_of_two(), Some(4)); assert_eq!(200u8.checked_next_power_of_two(), None); }assert_eq!(2u8.checked_next_power_of_two(), Some(2)); assert_eq!(3u8.checked_next_power_of_two(), Some(4)); assert_eq!(200u8.checked_next_power_of_two(), None);
Trait Implementations
impl OverflowingOps for u32
fn overflowing_add(self, rhs: u32) -> (u32, bool)
fn overflowing_sub(self, rhs: u32) -> (u32, bool)
fn overflowing_mul(self, rhs: u32) -> (u32, bool)
fn overflowing_div(self, rhs: u32) -> (u32, bool)
fn overflowing_rem(self, rhs: u32) -> (u32, bool)
fn overflowing_shl(self, rhs: u32) -> (u32, bool)
fn overflowing_shr(self, rhs: u32) -> (u32, bool)
fn overflowing_neg(self) -> (u32, bool)
impl FullOps for u32
fn full_add(self, other: u32, carry: bool) -> (bool, u32)
fn full_mul(self, other: u32, carry: u32) -> (u32, u32)
fn full_mul_add(self, other: u32, other2: u32, carry: u32) -> (u32, u32)
fn full_div_rem(self, other: u32, borrow: u32) -> (u32, u32)
impl Zero for u32
impl One for u32
impl FromStr for u32
type Err = ParseIntError
fn from_str(src: &str) -> Result<u32, ParseIntError>
impl From<u8> for u32
impl From<u16> for u32
impl Zeroable for u32
impl Add<u32> for u32
impl<'a> Add<u32> for &'a u32
impl<'a> Add<&'a u32> for u32
impl<'a, 'b> Add<&'a u32> for &'b u32
impl Sub<u32> for u32
impl<'a> Sub<u32> for &'a u32
impl<'a> Sub<&'a u32> for u32
impl<'a, 'b> Sub<&'a u32> for &'b u32
impl Mul<u32> for u32
impl<'a> Mul<u32> for &'a u32
impl<'a> Mul<&'a u32> for u32
impl<'a, 'b> Mul<&'a u32> for &'b u32
impl Div<u32> for u32
This operation rounds towards zero, truncating any fractional part of the exact result.
impl<'a> Div<u32> for &'a u32
impl<'a> Div<&'a u32> for u32
impl<'a, 'b> Div<&'a u32> for &'b u32
impl Rem<u32> for u32
This operation satisfies n % d == n - (n / d) * d. The
result has the same sign as the left operand.