# Trait num_traits::int::PrimInt [−] [src]

    pub trait PrimInt: Sized + Copy + Num + NumCast + Bounded + PartialOrd + Ord + Eq + Not<Output = Self> + BitAnd<Output = Self> + BitOr<Output = Self> + BitXor<Output = Self> + Shl<usize, Output = Self> + Shr<usize, Output = Self> + CheckedAdd<Output = Self> + CheckedSub<Output = Self> + CheckedMul<Output = Self> + CheckedDiv<Output = Self> + Saturating {
        fn count_ones(self) -> u32;
        fn count_zeros(self) -> u32;
        fn leading_zeros(self) -> u32;
        fn trailing_zeros(self) -> u32;
        fn rotate_left(self, n: u32) -> Self;
        fn rotate_right(self, n: u32) -> Self;
        fn signed_shl(self, n: u32) -> Self;
        fn signed_shr(self, n: u32) -> Self;
        fn unsigned_shl(self, n: u32) -> Self;
        fn unsigned_shr(self, n: u32) -> Self;
        fn swap_bytes(self) -> Self;
        fn from_be(x: Self) -> Self;
        fn from_le(x: Self) -> Self;
        fn to_be(self) -> Self;
        fn to_le(self) -> Self;
        fn pow(self, exp: u32) -> Self;
    }

## Required Methods

### `fn count_ones(self) -> u32`

Returns the number of ones in the binary representation of `self`.

# Examples

    use num_traits::PrimInt;

    let n = 0b01001100u8;

    assert_eq!(n.count_ones(), 3);Run

### `fn count_zeros(self) -> u32`

Returns the number of zeros in the binary representation of `self`.

# Examples

    use num_traits::PrimInt;

    let n = 0b01001100u8;

    assert_eq!(n.count_zeros(), 5);Run

### `fn leading_zeros(self) -> u32`

Returns the number of leading zeros in the binary representation of `self`.

# Examples

    use num_traits::PrimInt;

    let n = 0b0101000u16;

    assert_eq!(n.leading_zeros(), 10);Run

### `fn trailing_zeros(self) -> u32`

Returns the number of trailing zeros in the binary representation of `self`.

# Examples

    use num_traits::PrimInt;

    let n = 0b0101000u16;

    assert_eq!(n.trailing_zeros(), 3);Run

### `fn rotate_left(self, n: u32) -> Self`

Shifts the bits to the left by a specified amount amount, `n`, wrapping the truncated bits to the end of the resulting integer.

# Examples

    use num_traits::PrimInt;

    let n = 0x0123456789ABCDEFu64;
    let m = 0x3456789ABCDEF012u64;

    assert_eq!(n.rotate_left(12), m);Run

### `fn rotate_right(self, n: u32) -> Self`

Shifts the bits to the right by a specified amount amount, `n`, wrapping the truncated bits to the beginning of the resulting integer.

# Examples

    use num_traits::PrimInt;

    let n = 0x0123456789ABCDEFu64;
    let m = 0xDEF0123456789ABCu64;

    assert_eq!(n.rotate_right(12), m);Run

### `fn signed_shl(self, n: u32) -> Self`

Shifts the bits to the left by a specified amount amount, `n`, filling zeros in the least significant bits.

This is bitwise equivalent to signed `Shl`.

# Examples

    use num_traits::PrimInt;

    let n = 0x0123456789ABCDEFu64;
    let m = 0x3456789ABCDEF000u64;

    assert_eq!(n.signed_shl(12), m);Run

### `fn signed_shr(self, n: u32) -> Self`

Shifts the bits to the right by a specified amount amount, `n`, copying the "sign bit" in the most significant bits even for unsigned types.

This is bitwise equivalent to signed `Shr`.

# Examples

    use num_traits::PrimInt;

    let n = 0xFEDCBA9876543210u64;
    let m = 0xFFFFEDCBA9876543u64;

    assert_eq!(n.signed_shr(12), m);Run

### `fn unsigned_shl(self, n: u32) -> Self`

Shifts the bits to the left by a specified amount amount, `n`, filling zeros in the least significant bits.

This is bitwise equivalent to unsigned `Shl`.

# Examples

    use num_traits::PrimInt;

    let n = 0x0123456789ABCDEFi64;
    let m = 0x3456789ABCDEF000i64;

    assert_eq!(n.unsigned_shl(12), m);Run

### `fn unsigned_shr(self, n: u32) -> Self`

Shifts the bits to the right by a specified amount amount, `n`, filling zeros in the most significant bits.

This is bitwise equivalent to unsigned `Shr`.

# Examples

    use num_traits::PrimInt;

    let n = 0xFEDCBA9876543210i64;
    let m = 0x000FEDCBA9876543i64;

    assert_eq!(n.unsigned_shr(12), m);Run

### `fn swap_bytes(self) -> Self`

Reverses the byte order of the integer.

# Examples

    use num_traits::PrimInt;

    let n = 0x0123456789ABCDEFu64;
    let m = 0xEFCDAB8967452301u64;

    assert_eq!(n.swap_bytes(), m);Run

### `fn from_be(x: Self) -> Self`

Convert an integer from big endian to the target's endianness.

On big endian this is a no-op. On little endian the bytes are swapped.

# Examples

    use num_traits::PrimInt;

    let n = 0x0123456789ABCDEFu64;

    if cfg!(target_endian = "big") {
        assert_eq!(u64::from_be(n), n)
    } else {
        assert_eq!(u64::from_be(n), n.swap_bytes())
    }Run

### `fn from_le(x: Self) -> Self`

Convert an integer from little endian to the target's endianness.

On little endian this is a no-op. On big endian the bytes are swapped.

# Examples

    use num_traits::PrimInt;

    let n = 0x0123456789ABCDEFu64;

    if cfg!(target_endian = "little") {
        assert_eq!(u64::from_le(n), n)
    } else {
        assert_eq!(u64::from_le(n), n.swap_bytes())
    }Run

### `fn to_be(self) -> Self`

Convert `self` to big endian from the target's endianness.

On big endian this is a no-op. On little endian the bytes are swapped.

# Examples

    use num_traits::PrimInt;

    let n = 0x0123456789ABCDEFu64;

    if cfg!(target_endian = "big") {
        assert_eq!(n.to_be(), n)
    } else {
        assert_eq!(n.to_be(), n.swap_bytes())
    }Run

### `fn to_le(self) -> Self`

Convert `self` to little endian from the target's endianness.

On little endian this is a no-op. On big endian the bytes are swapped.

# Examples

    use num_traits::PrimInt;

    let n = 0x0123456789ABCDEFu64;

    if cfg!(target_endian = "little") {
        assert_eq!(n.to_le(), n)
    } else {
        assert_eq!(n.to_le(), n.swap_bytes())
    }Run

### `fn pow(self, exp: u32) -> Self`

Raises self to the power of `exp`, using exponentiation by squaring.

# Examples

    use num_traits::PrimInt;

    assert_eq!(2i32.pow(4), 16);Run

## Implementors

- `impl PrimInt for u8`
- `impl PrimInt for u16`
- `impl PrimInt for u32`
- `impl PrimInt for u64`
- `impl PrimInt for usize`
- `impl PrimInt for i8`
- `impl PrimInt for i16`
- `impl PrimInt for i32`
- `impl PrimInt for i64`
- `impl PrimInt for isize`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)