# Struct std::num::Saturating

1.74.0 · source ·

    #[repr(transparent)]pub struct Saturating<T>(pub T);

Expand description

Provides intentionally-saturating 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 saturating arithmetic.

Saturating arithmetic can be achieved either through methods like `saturating_add`, or through the `Saturating<T>` type, which says that all standard arithmetic operations on the underlying value are intended to have saturating semantics.

The underlying value can be retrieved through the `.0` index of the `Saturating` tuple.

## Examples

    use std::num::Saturating;

    let max = Saturating(u32::MAX);
    let one = Saturating(1u32);

    assert_eq!(u32::MAX, (max + one).0);

Run

## Tuple Fields§

§`0: T`

## Implementations§

source§

### impl Saturating<usize>

source

#### pub const MIN: Saturating<usize> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<usize>>::MIN, Saturating(usize::MIN));

Run
source

#### pub const MAX: Saturating<usize> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<usize>>::MAX, Saturating(usize::MAX));

Run
source

#### pub const BITS: u32 = 64u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<usize>>::BITS, usize::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100usize);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0usize).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000usize);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<usize>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<usize>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<usize>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<usize>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<usize>) -> Saturating<usize>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ausize);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<usize>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<usize>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<usize>) -> Saturating<usize>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ausize);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<usize>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<usize>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<usize>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ausize);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<usize>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ausize);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<usize>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3usize).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<u8>

source

#### pub const MIN: Saturating<u8> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u8>>::MIN, Saturating(u8::MIN));

Run
source

#### pub const MAX: Saturating<u8> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u8>>::MAX, Saturating(u8::MAX));

Run
source

#### pub const BITS: u32 = 8u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u8>>::BITS, u8::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100u8);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0u8).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000u8);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<u8>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<u8>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<u8>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<u8>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<u8>) -> Saturating<u8>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au8);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<u8>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<u8>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<u8>) -> Saturating<u8>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au8);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<u8>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<u8>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<u8>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au8);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<u8>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au8);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<u8>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3u8).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<u16>

source

#### pub const MIN: Saturating<u16> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u16>>::MIN, Saturating(u16::MIN));

Run
source

#### pub const MAX: Saturating<u16> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u16>>::MAX, Saturating(u16::MAX));

Run
source

#### pub const BITS: u32 = 16u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u16>>::BITS, u16::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100u16);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0u16).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000u16);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<u16>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<u16>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<u16>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<u16>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<u16>) -> Saturating<u16>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au16);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<u16>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<u16>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<u16>) -> Saturating<u16>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au16);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<u16>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<u16>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<u16>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au16);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<u16>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au16);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<u16>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3u16).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<u32>

source

#### pub const MIN: Saturating<u32> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u32>>::MIN, Saturating(u32::MIN));

Run
source

#### pub const MAX: Saturating<u32> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u32>>::MAX, Saturating(u32::MAX));

Run
source

#### pub const BITS: u32 = 32u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u32>>::BITS, u32::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100u32);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0u32).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000u32);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<u32>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<u32>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<u32>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<u32>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<u32>) -> Saturating<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:

    use std::num::Saturating;

    let n = Saturating(0x1Au32);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<u32>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<u32>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<u32>) -> Saturating<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:

    use std::num::Saturating;

    let n = Saturating(0x1Au32);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<u32>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<u32>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<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:

    use std::num::Saturating;

    let n = Saturating(0x1Au32);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<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:

    use std::num::Saturating;

    let n = Saturating(0x1Au32);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<u32>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3u32).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<u64>

source

#### pub const MIN: Saturating<u64> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u64>>::MIN, Saturating(u64::MIN));

Run
source

#### pub const MAX: Saturating<u64> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u64>>::MAX, Saturating(u64::MAX));

Run
source

#### pub const BITS: u32 = 64u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u64>>::BITS, u64::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100u64);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0u64).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000u64);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<u64>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<u64>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<u64>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<u64>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<u64>) -> Saturating<u64>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au64);

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

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<u64>) -> Saturating<u64>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au64);

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

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<u64>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au64);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<u64>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au64);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<u64>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3u64).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<u128>

source

#### pub const MIN: Saturating<u128> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u128>>::MIN, Saturating(u128::MIN));

Run
source

#### pub const MAX: Saturating<u128> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u128>>::MAX, Saturating(u128::MAX));

Run
source

#### pub const BITS: u32 = 128u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<u128>>::BITS, u128::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100u128);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0u128).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000u128);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<u128>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<u128>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<u128>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<u128>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<u128>) -> Saturating<u128>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au128);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<u128>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<u128>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<u128>) -> Saturating<u128>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au128);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<u128>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<u128>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<u128>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au128);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<u128>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Au128);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<u128>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3u128).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<isize>

source

#### pub const MIN: Saturating<isize> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<isize>>::MIN, Saturating(isize::MIN));

Run
source

#### pub const MAX: Saturating<isize> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<isize>>::MAX, Saturating(isize::MAX));

Run
source

#### pub const BITS: u32 = 64u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<isize>>::BITS, isize::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100isize);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0isize).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000isize);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<isize>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<isize>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<isize>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<isize>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<isize>) -> Saturating<isize>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Aisize);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<isize>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<isize>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<isize>) -> Saturating<isize>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Aisize);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<isize>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<isize>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<isize>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Aisize);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<isize>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Aisize);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<isize>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3isize).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<i8>

source

#### pub const MIN: Saturating<i8> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i8>>::MIN, Saturating(i8::MIN));

Run
source

#### pub const MAX: Saturating<i8> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i8>>::MAX, Saturating(i8::MAX));

Run
source

#### pub const BITS: u32 = 8u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i8>>::BITS, i8::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100i8);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0i8).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000i8);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<i8>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<i8>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<i8>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<i8>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<i8>) -> Saturating<i8>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai8);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<i8>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<i8>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<i8>) -> Saturating<i8>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai8);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<i8>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<i8>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<i8>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai8);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<i8>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai8);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<i8>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<i16>

source

#### pub const MIN: Saturating<i16> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i16>>::MIN, Saturating(i16::MIN));

Run
source

#### pub const MAX: Saturating<i16> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i16>>::MAX, Saturating(i16::MAX));

Run
source

#### pub const BITS: u32 = 16u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i16>>::BITS, i16::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100i16);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0i16).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000i16);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<i16>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<i16>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<i16>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<i16>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<i16>) -> Saturating<i16>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai16);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<i16>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<i16>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<i16>) -> Saturating<i16>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai16);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<i16>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<i16>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<i16>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai16);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<i16>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai16);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<i16>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3i16).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<i32>

source

#### pub const MIN: Saturating<i32> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i32>>::MIN, Saturating(i32::MIN));

Run
source

#### pub const MAX: Saturating<i32> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i32>>::MAX, Saturating(i32::MAX));

Run
source

#### pub const BITS: u32 = 32u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i32>>::BITS, i32::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100i32);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0i32).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000i32);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<i32>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<i32>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<i32>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<i32>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<i32>) -> Saturating<i32>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai32);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<i32>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<i32>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<i32>) -> Saturating<i32>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai32);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<i32>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<i32>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<i32>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai32);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<i32>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai32);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<i32>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3i32).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<i64>

source

#### pub const MIN: Saturating<i64> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i64>>::MIN, Saturating(i64::MIN));

Run
source

#### pub const MAX: Saturating<i64> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i64>>::MAX, Saturating(i64::MAX));

Run
source

#### pub const BITS: u32 = 64u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i64>>::BITS, i64::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100i64);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0i64).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000i64);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<i64>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<i64>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<i64>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<i64>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<i64>) -> Saturating<i64>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai64);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<i64>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<i64>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<i64>) -> Saturating<i64>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai64);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<i64>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<i64>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<i64>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai64);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<i64>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai64);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<i64>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3i64).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<i128>

source

#### pub const MIN: Saturating<i128> = _

Returns the smallest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i128>>::MIN, Saturating(i128::MIN));

Run
source

#### pub const MAX: Saturating<i128> = _

Returns the largest value that can be represented by this integer type.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i128>>::MAX, Saturating(i128::MAX));

Run
source

#### pub const BITS: u32 = 128u32

Returns the size of this integer type in bits.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(<Saturating<i128>>::BITS, i128::BITS);

Run
const: 1.74.0 · source

#### pub const fn count_ones(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b01001100i128);

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

Run
const: 1.74.0 · source

#### pub const fn count_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(!0i128).count_zeros(), 0);

Run
const: 1.74.0 · source

#### pub const fn trailing_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(0b0101000i128);

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

Run
const: 1.74.0 · source

#### pub const fn rotate_left(self, n: u32) -> Saturating<i128>

Shifts the bits to the left by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

    assert_eq!(n.rotate_left(32), m);

Run
const: 1.74.0 · source

#### pub const fn rotate_right(self, n: u32) -> Saturating<i128>

Shifts the bits to the right by a specified amount, `n`, saturating 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:

    use std::num::Saturating;

    let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
    let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

    assert_eq!(n.rotate_right(4), m);

Run
const: 1.74.0 · source

#### pub const fn swap_bytes(self) -> Saturating<i128>

Reverses the byte order of the integer.

##### Examples

Basic usage:

    use std::num::Saturating;

    let n: Saturating<i16> = Saturating(0b0000000_01010101);
    assert_eq!(n, Saturating(85));

    let m = n.swap_bytes();

    assert_eq!(m, Saturating(0b01010101_00000000));
    assert_eq!(m, Saturating(21760));

Run
const: 1.74.0 · source

#### pub const fn reverse_bits(self) -> Saturating<i128>

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::Saturating;

    let n = Saturating(0b0000000_01010101i16);
    assert_eq!(n, Saturating(85));

    let m = n.reverse_bits();

    assert_eq!(m.0 as u16, 0b10101010_00000000);
    assert_eq!(m, Saturating(-22016));

Run
const: 1.74.0 · source

#### pub const fn from_be(x: Saturating<i128>) -> Saturating<i128>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai128);

    if cfg!(target_endian = "big") {
        assert_eq!(<Saturating<i128>>::from_be(n), n)
    } else {
        assert_eq!(<Saturating<i128>>::from_be(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn from_le(x: Saturating<i128>) -> Saturating<i128>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai128);

    if cfg!(target_endian = "little") {
        assert_eq!(<Saturating<i128>>::from_le(n), n)
    } else {
        assert_eq!(<Saturating<i128>>::from_le(n), n.swap_bytes())
    }

Run
const: 1.74.0 · source

#### pub const fn to_be(self) -> Saturating<i128>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai128);

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

Run
const: 1.74.0 · source

#### pub const fn to_le(self) -> Saturating<i128>

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:

    use std::num::Saturating;

    let n = Saturating(0x1Ai128);

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

Run
const: 1.74.0 · source

#### pub const fn pow(self, exp: u32) -> Saturating<i128>

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

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(3i128).pow(4), Saturating(81));

Run

Results that are too large are saturated:

    use std::num::Saturating;

    assert_eq!(Saturating(3i8).pow(5), Saturating(127));
    assert_eq!(Saturating(3i8).pow(6), Saturating(127));

Run
source§

### impl Saturating<isize>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(isize::MAX >> 2);

    assert_eq!(n.leading_zeros(), 3);

Run
const: 1.74.0 · source

#### pub const fn abs(self) -> Saturating<isize>

Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self == MIN` instead of overflowing.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(100isize).abs(), Saturating(100));
    assert_eq!(Saturating(-100isize).abs(), Saturating(100));
    assert_eq!(Saturating(isize::MIN).abs(), Saturating((isize::MIN + 1).abs()));
    assert_eq!(Saturating(isize::MIN).abs(), Saturating(isize::MIN.saturating_abs()));
    assert_eq!(Saturating(isize::MIN).abs(), Saturating(isize::MAX));

Run
const: 1.74.0 · source

#### pub const fn signum(self) -> Saturating<isize>

Returns a number representing sign of `self`.

- `0` if the number is zero
- `1` if the number is positive
- `-1` if the number is negative

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(10isize).signum(), Saturating(1));
    assert_eq!(Saturating(0isize).signum(), Saturating(0));
    assert_eq!(Saturating(-10isize).signum(), Saturating(-1));

Run
const: 1.74.0 · source

#### pub const fn is_positive(self) -> bool

Returns `true` if `self` is positive and `false` if the number is zero or negative.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(10isize).is_positive());
    assert!(!Saturating(-10isize).is_positive());

Run
const: 1.74.0 · source

#### pub const fn is_negative(self) -> bool

Returns `true` if `self` is negative and `false` if the number is zero or positive.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(-10isize).is_negative());
    assert!(!Saturating(10isize).is_negative());

Run
source§

### impl Saturating<i8>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(i8::MAX >> 2);

    assert_eq!(n.leading_zeros(), 3);

Run
const: 1.74.0 · source

#### pub const fn abs(self) -> Saturating<i8>

Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self == MIN` instead of overflowing.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(100i8).abs(), Saturating(100));
    assert_eq!(Saturating(-100i8).abs(), Saturating(100));
    assert_eq!(Saturating(i8::MIN).abs(), Saturating((i8::MIN + 1).abs()));
    assert_eq!(Saturating(i8::MIN).abs(), Saturating(i8::MIN.saturating_abs()));
    assert_eq!(Saturating(i8::MIN).abs(), Saturating(i8::MAX));

Run
const: 1.74.0 · source

#### pub const fn signum(self) -> Saturating<i8>

Returns a number representing sign of `self`.

- `0` if the number is zero
- `1` if the number is positive
- `-1` if the number is negative

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(10i8).signum(), Saturating(1));
    assert_eq!(Saturating(0i8).signum(), Saturating(0));
    assert_eq!(Saturating(-10i8).signum(), Saturating(-1));

Run
const: 1.74.0 · source

#### pub const fn is_positive(self) -> bool

Returns `true` if `self` is positive and `false` if the number is zero or negative.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(10i8).is_positive());
    assert!(!Saturating(-10i8).is_positive());

Run
const: 1.74.0 · source

#### pub const fn is_negative(self) -> bool

Returns `true` if `self` is negative and `false` if the number is zero or positive.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(-10i8).is_negative());
    assert!(!Saturating(10i8).is_negative());

Run
source§

### impl Saturating<i16>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(i16::MAX >> 2);

    assert_eq!(n.leading_zeros(), 3);

Run
const: 1.74.0 · source

#### pub const fn abs(self) -> Saturating<i16>

Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self == MIN` instead of overflowing.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(100i16).abs(), Saturating(100));
    assert_eq!(Saturating(-100i16).abs(), Saturating(100));
    assert_eq!(Saturating(i16::MIN).abs(), Saturating((i16::MIN + 1).abs()));
    assert_eq!(Saturating(i16::MIN).abs(), Saturating(i16::MIN.saturating_abs()));
    assert_eq!(Saturating(i16::MIN).abs(), Saturating(i16::MAX));

Run
const: 1.74.0 · source

#### pub const fn signum(self) -> Saturating<i16>

Returns a number representing sign of `self`.

- `0` if the number is zero
- `1` if the number is positive
- `-1` if the number is negative

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(10i16).signum(), Saturating(1));
    assert_eq!(Saturating(0i16).signum(), Saturating(0));
    assert_eq!(Saturating(-10i16).signum(), Saturating(-1));

Run
const: 1.74.0 · source

#### pub const fn is_positive(self) -> bool

Returns `true` if `self` is positive and `false` if the number is zero or negative.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(10i16).is_positive());
    assert!(!Saturating(-10i16).is_positive());

Run
const: 1.74.0 · source

#### pub const fn is_negative(self) -> bool

Returns `true` if `self` is negative and `false` if the number is zero or positive.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(-10i16).is_negative());
    assert!(!Saturating(10i16).is_negative());

Run
source§

### impl Saturating<i32>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(i32::MAX >> 2);

    assert_eq!(n.leading_zeros(), 3);

Run
const: 1.74.0 · source

#### pub const fn abs(self) -> Saturating<i32>

Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self == MIN` instead of overflowing.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(100i32).abs(), Saturating(100));
    assert_eq!(Saturating(-100i32).abs(), Saturating(100));
    assert_eq!(Saturating(i32::MIN).abs(), Saturating((i32::MIN + 1).abs()));
    assert_eq!(Saturating(i32::MIN).abs(), Saturating(i32::MIN.saturating_abs()));
    assert_eq!(Saturating(i32::MIN).abs(), Saturating(i32::MAX));

Run
const: 1.74.0 · source

#### pub const fn signum(self) -> Saturating<i32>

Returns a number representing sign of `self`.

- `0` if the number is zero
- `1` if the number is positive
- `-1` if the number is negative

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(10i32).signum(), Saturating(1));
    assert_eq!(Saturating(0i32).signum(), Saturating(0));
    assert_eq!(Saturating(-10i32).signum(), Saturating(-1));

Run
const: 1.74.0 · source

#### pub const fn is_positive(self) -> bool

Returns `true` if `self` is positive and `false` if the number is zero or negative.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(10i32).is_positive());
    assert!(!Saturating(-10i32).is_positive());

Run
const: 1.74.0 · source

#### pub const fn is_negative(self) -> bool

Returns `true` if `self` is negative and `false` if the number is zero or positive.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(-10i32).is_negative());
    assert!(!Saturating(10i32).is_negative());

Run
source§

### impl Saturating<i64>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(i64::MAX >> 2);

    assert_eq!(n.leading_zeros(), 3);

Run
const: 1.74.0 · source

#### pub const fn abs(self) -> Saturating<i64>

Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self == MIN` instead of overflowing.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(100i64).abs(), Saturating(100));
    assert_eq!(Saturating(-100i64).abs(), Saturating(100));
    assert_eq!(Saturating(i64::MIN).abs(), Saturating((i64::MIN + 1).abs()));
    assert_eq!(Saturating(i64::MIN).abs(), Saturating(i64::MIN.saturating_abs()));
    assert_eq!(Saturating(i64::MIN).abs(), Saturating(i64::MAX));

Run
const: 1.74.0 · source

#### pub const fn signum(self) -> Saturating<i64>

Returns a number representing sign of `self`.

- `0` if the number is zero
- `1` if the number is positive
- `-1` if the number is negative

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(10i64).signum(), Saturating(1));
    assert_eq!(Saturating(0i64).signum(), Saturating(0));
    assert_eq!(Saturating(-10i64).signum(), Saturating(-1));

Run
const: 1.74.0 · source

#### pub const fn is_positive(self) -> bool

Returns `true` if `self` is positive and `false` if the number is zero or negative.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(10i64).is_positive());
    assert!(!Saturating(-10i64).is_positive());

Run
const: 1.74.0 · source

#### pub const fn is_negative(self) -> bool

Returns `true` if `self` is negative and `false` if the number is zero or positive.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(-10i64).is_negative());
    assert!(!Saturating(10i64).is_negative());

Run
source§

### impl Saturating<i128>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(i128::MAX >> 2);

    assert_eq!(n.leading_zeros(), 3);

Run
const: 1.74.0 · source

#### pub const fn abs(self) -> Saturating<i128>

Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self == MIN` instead of overflowing.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(100i128).abs(), Saturating(100));
    assert_eq!(Saturating(-100i128).abs(), Saturating(100));
    assert_eq!(Saturating(i128::MIN).abs(), Saturating((i128::MIN + 1).abs()));
    assert_eq!(Saturating(i128::MIN).abs(), Saturating(i128::MIN.saturating_abs()));
    assert_eq!(Saturating(i128::MIN).abs(), Saturating(i128::MAX));

Run
const: 1.74.0 · source

#### pub const fn signum(self) -> Saturating<i128>

Returns a number representing sign of `self`.

- `0` if the number is zero
- `1` if the number is positive
- `-1` if the number is negative

##### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(10i128).signum(), Saturating(1));
    assert_eq!(Saturating(0i128).signum(), Saturating(0));
    assert_eq!(Saturating(-10i128).signum(), Saturating(-1));

Run
const: 1.74.0 · source

#### pub const fn is_positive(self) -> bool

Returns `true` if `self` is positive and `false` if the number is zero or negative.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(10i128).is_positive());
    assert!(!Saturating(-10i128).is_positive());

Run
const: 1.74.0 · source

#### pub const fn is_negative(self) -> bool

Returns `true` if `self` is negative and `false` if the number is zero or positive.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(-10i128).is_negative());
    assert!(!Saturating(10i128).is_negative());

Run
source§

### impl Saturating<usize>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(usize::MAX >> 2);

    assert_eq!(n.leading_zeros(), 2);

Run
const: 1.74.0 · source

#### pub const fn is_power_of_two(self) -> bool

Returns `true` if and only if `self == 2^k` for some `k`.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(16usize).is_power_of_two());
    assert!(!Saturating(10usize).is_power_of_two());

Run
source§

### impl Saturating<u8>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(u8::MAX >> 2);

    assert_eq!(n.leading_zeros(), 2);

Run
const: 1.74.0 · source

#### pub const fn is_power_of_two(self) -> bool

Returns `true` if and only if `self == 2^k` for some `k`.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(16u8).is_power_of_two());
    assert!(!Saturating(10u8).is_power_of_two());

Run
source§

### impl Saturating<u16>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(u16::MAX >> 2);

    assert_eq!(n.leading_zeros(), 2);

Run
const: 1.74.0 · source

#### pub const fn is_power_of_two(self) -> bool

Returns `true` if and only if `self == 2^k` for some `k`.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(16u16).is_power_of_two());
    assert!(!Saturating(10u16).is_power_of_two());

Run
source§

### impl Saturating<u32>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(u32::MAX >> 2);

    assert_eq!(n.leading_zeros(), 2);

Run
const: 1.74.0 · source

#### pub const fn is_power_of_two(self) -> bool

Returns `true` if and only if `self == 2^k` for some `k`.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(16u32).is_power_of_two());
    assert!(!Saturating(10u32).is_power_of_two());

Run
source§

### impl Saturating<u64>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(u64::MAX >> 2);

    assert_eq!(n.leading_zeros(), 2);

Run
const: 1.74.0 · source

#### pub const fn is_power_of_two(self) -> bool

Returns `true` if and only if `self == 2^k` for some `k`.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(16u64).is_power_of_two());
    assert!(!Saturating(10u64).is_power_of_two());

Run
source§

### impl Saturating<u128>

const: 1.74.0 · source

#### pub const fn leading_zeros(self) -> u32

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

##### Examples

Basic usage:

    use std::num::Saturating;

    let n = Saturating(u128::MAX >> 2);

    assert_eq!(n.leading_zeros(), 2);

Run
const: 1.74.0 · source

#### pub const fn is_power_of_two(self) -> bool

Returns `true` if and only if `self == 2^k` for some `k`.

##### Examples

Basic usage:

    use std::num::Saturating;

    assert!(Saturating(16u128).is_power_of_two());
    assert!(!Saturating(10u128).is_power_of_two());

Run

## Trait Implementations§

source§

### impl Add<&Saturating<i128>> for &Saturating<i128>

§

#### type Output = <Saturating<i128> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i128>) -> <Saturating<i128> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<i128>> for Saturating<i128>

§

#### type Output = <Saturating<i128> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i128>) -> <Saturating<i128> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<i16>> for &Saturating<i16>

§

#### type Output = <Saturating<i16> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i16>) -> <Saturating<i16> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<i16>> for Saturating<i16>

§

#### type Output = <Saturating<i16> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i16>) -> <Saturating<i16> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<i32>> for &Saturating<i32>

§

#### type Output = <Saturating<i32> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i32>) -> <Saturating<i32> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<i32>> for Saturating<i32>

§

#### type Output = <Saturating<i32> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i32>) -> <Saturating<i32> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<i64>> for &Saturating<i64>

§

#### type Output = <Saturating<i64> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i64>) -> <Saturating<i64> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<i64>> for Saturating<i64>

§

#### type Output = <Saturating<i64> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i64>) -> <Saturating<i64> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<i8>> for &Saturating<i8>

§

#### type Output = <Saturating<i8> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i8>) -> <Saturating<i8> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<i8>> for Saturating<i8>

§

#### type Output = <Saturating<i8> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<i8>) -> <Saturating<i8> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<isize>> for &Saturating<isize>

§

#### type Output = <Saturating<isize> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<isize>) -> <Saturating<isize> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<isize>> for Saturating<isize>

§

#### type Output = <Saturating<isize> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<isize>) -> <Saturating<isize> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u128>> for &Saturating<u128>

§

#### type Output = <Saturating<u128> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u128>) -> <Saturating<u128> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u128>> for Saturating<u128>

§

#### type Output = <Saturating<u128> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u128>) -> <Saturating<u128> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u16>> for &Saturating<u16>

§

#### type Output = <Saturating<u16> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u16>) -> <Saturating<u16> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u16>> for Saturating<u16>

§

#### type Output = <Saturating<u16> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u16>) -> <Saturating<u16> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u32>> for &Saturating<u32>

§

#### type Output = <Saturating<u32> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u32>) -> <Saturating<u32> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u32>> for Saturating<u32>

§

#### type Output = <Saturating<u32> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u32>) -> <Saturating<u32> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u64>> for &Saturating<u64>

§

#### type Output = <Saturating<u64> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u64>) -> <Saturating<u64> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u64>> for Saturating<u64>

§

#### type Output = <Saturating<u64> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u64>) -> <Saturating<u64> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u8>> for &Saturating<u8>

§

#### type Output = <Saturating<u8> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u8>) -> <Saturating<u8> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<u8>> for Saturating<u8>

§

#### type Output = <Saturating<u8> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<u8>) -> <Saturating<u8> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<usize>> for &Saturating<usize>

§

#### type Output = <Saturating<usize> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<usize>) -> <Saturating<usize> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add<&Saturating<usize>> for Saturating<usize>

§

#### type Output = <Saturating<usize> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Saturating<usize>) -> <Saturating<usize> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<i128>> for &'a Saturating<i128>

§

#### type Output = <Saturating<i128> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i128>) -> <Saturating<i128> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<i16>> for &'a Saturating<i16>

§

#### type Output = <Saturating<i16> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i16>) -> <Saturating<i16> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<i32>> for &'a Saturating<i32>

§

#### type Output = <Saturating<i32> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i32>) -> <Saturating<i32> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<i64>> for &'a Saturating<i64>

§

#### type Output = <Saturating<i64> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i64>) -> <Saturating<i64> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<i8>> for &'a Saturating<i8>

§

#### type Output = <Saturating<i8> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i8>) -> <Saturating<i8> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<isize>> for &'a Saturating<isize>

§

#### type Output = <Saturating<isize> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<isize>) -> <Saturating<isize> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<u128>> for &'a Saturating<u128>

§

#### type Output = <Saturating<u128> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u128>) -> <Saturating<u128> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<u16>> for &'a Saturating<u16>

§

#### type Output = <Saturating<u16> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u16>) -> <Saturating<u16> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<u32>> for &'a Saturating<u32>

§

#### type Output = <Saturating<u32> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u32>) -> <Saturating<u32> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<u64>> for &'a Saturating<u64>

§

#### type Output = <Saturating<u64> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u64>) -> <Saturating<u64> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<u8>> for &'a Saturating<u8>

§

#### type Output = <Saturating<u8> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u8>) -> <Saturating<u8> as Add>::Output

Performs the `+` operation. Read more
source§

### impl<'a> Add<Saturating<usize>> for &'a Saturating<usize>

§

#### type Output = <Saturating<usize> as Add>::Output

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<usize>) -> <Saturating<usize> as Add>::Output

Performs the `+` operation. Read more
source§

### impl Add for Saturating<i128>

§

#### type Output = Saturating<i128>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i128>) -> Saturating<i128>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<i16>

§

#### type Output = Saturating<i16>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i16>) -> Saturating<i16>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<i32>

§

#### type Output = Saturating<i32>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i32>) -> Saturating<i32>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<i64>

§

#### type Output = Saturating<i64>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i64>) -> Saturating<i64>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<i8>

§

#### type Output = Saturating<i8>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<i8>) -> Saturating<i8>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<isize>

§

#### type Output = Saturating<isize>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<isize>) -> Saturating<isize>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<u128>

§

#### type Output = Saturating<u128>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u128>) -> Saturating<u128>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<u16>

§

#### type Output = Saturating<u16>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u16>) -> Saturating<u16>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<u32>

§

#### type Output = Saturating<u32>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u32>) -> Saturating<u32>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<u64>

§

#### type Output = Saturating<u64>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u64>) -> Saturating<u64>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<u8>

§

#### type Output = Saturating<u8>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<u8>) -> Saturating<u8>

Performs the `+` operation. Read more
source§

### impl Add for Saturating<usize>

§

#### type Output = Saturating<usize>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Saturating<usize>) -> Saturating<usize>

Performs the `+` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<i128>> for Saturating<i128>

source§

#### fn add_assign(&mut self, other: &Saturating<i128>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<i16>> for Saturating<i16>

source§

#### fn add_assign(&mut self, other: &Saturating<i16>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<i32>> for Saturating<i32>

source§

#### fn add_assign(&mut self, other: &Saturating<i32>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<i64>> for Saturating<i64>

source§

#### fn add_assign(&mut self, other: &Saturating<i64>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<i8>> for Saturating<i8>

source§

#### fn add_assign(&mut self, other: &Saturating<i8>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<isize>> for Saturating<isize>

source§

#### fn add_assign(&mut self, other: &Saturating<isize>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<u128>> for Saturating<u128>

source§

#### fn add_assign(&mut self, other: &Saturating<u128>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<u16>> for Saturating<u16>

source§

#### fn add_assign(&mut self, other: &Saturating<u16>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<u32>> for Saturating<u32>

source§

#### fn add_assign(&mut self, other: &Saturating<u32>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<u64>> for Saturating<u64>

source§

#### fn add_assign(&mut self, other: &Saturating<u64>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<u8>> for Saturating<u8>

source§

#### fn add_assign(&mut self, other: &Saturating<u8>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&Saturating<usize>> for Saturating<usize>

source§

#### fn add_assign(&mut self, other: &Saturating<usize>)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&i128> for Saturating<i128>

source§

#### fn add_assign(&mut self, other: &i128)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&i16> for Saturating<i16>

source§

#### fn add_assign(&mut self, other: &i16)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&i32> for Saturating<i32>

source§

#### fn add_assign(&mut self, other: &i32)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&i64> for Saturating<i64>

source§

#### fn add_assign(&mut self, other: &i64)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&i8> for Saturating<i8>

source§

#### fn add_assign(&mut self, other: &i8)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&isize> for Saturating<isize>

source§

#### fn add_assign(&mut self, other: &isize)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&u128> for Saturating<u128>

source§

#### fn add_assign(&mut self, other: &u128)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&u16> for Saturating<u16>

source§

#### fn add_assign(&mut self, other: &u16)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&u32> for Saturating<u32>

source§

#### fn add_assign(&mut self, other: &u32)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&u64> for Saturating<u64>

source§

#### fn add_assign(&mut self, other: &u64)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&u8> for Saturating<u8>

source§

#### fn add_assign(&mut self, other: &u8)

Performs the `+=` operation. Read more
1.22.0 · source§

### impl AddAssign<&usize> for Saturating<usize>

source§

#### fn add_assign(&mut self, other: &usize)

Performs the `+=` operation. Read more
source§

### impl AddAssign<i128> for Saturating<i128>

source§

#### fn add_assign(&mut self, other: i128)

Performs the `+=` operation. Read more
source§

### impl AddAssign<i16> for Saturating<i16>

source§

#### fn add_assign(&mut self, other: i16)

Performs the `+=` operation. Read more
source§

### impl AddAssign<i32> for Saturating<i32>

source§

#### fn add_assign(&mut self, other: i32)

Performs the `+=` operation. Read more
source§

### impl AddAssign<i64> for Saturating<i64>

source§

#### fn add_assign(&mut self, other: i64)

Performs the `+=` operation. Read more
source§

### impl AddAssign<i8> for Saturating<i8>

source§

#### fn add_assign(&mut self, other: i8)

Performs the `+=` operation. Read more
source§

### impl AddAssign<isize> for Saturating<isize>

source§

#### fn add_assign(&mut self, other: isize)

Performs the `+=` operation. Read more
source§

### impl AddAssign<u128> for Saturating<u128>

source§

#### fn add_assign(&mut self, other: u128)

Performs the `+=` operation. Read more
source§

### impl AddAssign<u16> for Saturating<u16>

source§

#### fn add_assign(&mut self, other: u16)

Performs the `+=` operation. Read more
source§

### impl AddAssign<u32> for Saturating<u32>

source§

#### fn add_assign(&mut self, other: u32)

Performs the `+=` operation. Read more
source§

### impl AddAssign<u64> for Saturating<u64>

source§

#### fn add_assign(&mut self, other: u64)

Performs the `+=` operation. Read more
source§

### impl AddAssign<u8> for Saturating<u8>

source§

#### fn add_assign(&mut self, other: u8)

Performs the `+=` operation. Read more
source§

### impl AddAssign<usize> for Saturating<usize>

source§

#### fn add_assign(&mut self, other: usize)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<i128>

source§

#### fn add_assign(&mut self, other: Saturating<i128>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<i16>

source§

#### fn add_assign(&mut self, other: Saturating<i16>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<i32>

source§

#### fn add_assign(&mut self, other: Saturating<i32>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<i64>

source§

#### fn add_assign(&mut self, other: Saturating<i64>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<i8>

source§

#### fn add_assign(&mut self, other: Saturating<i8>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<isize>

source§

#### fn add_assign(&mut self, other: Saturating<isize>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<u128>

source§

#### fn add_assign(&mut self, other: Saturating<u128>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<u16>

source§

#### fn add_assign(&mut self, other: Saturating<u16>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<u32>

source§

#### fn add_assign(&mut self, other: Saturating<u32>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<u64>

source§

#### fn add_assign(&mut self, other: Saturating<u64>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<u8>

source§

#### fn add_assign(&mut self, other: Saturating<u8>)

Performs the `+=` operation. Read more
source§

### impl AddAssign for Saturating<usize>

source§

#### fn add_assign(&mut self, other: Saturating<usize>)

Performs the `+=` operation. Read more
source§

### impl<T> Binary for Saturating<T>where T: Binary,

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.
source§

### impl BitAnd<&Saturating<i128>> for &Saturating<i128>

§

#### type Output = <Saturating<i128> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: &Saturating<i128> ) -> <Saturating<i128> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<i128>> for Saturating<i128>

§

#### type Output = <Saturating<i128> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: &Saturating<i128> ) -> <Saturating<i128> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<i16>> for &Saturating<i16>

§

#### type Output = <Saturating<i16> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<i16>) -> <Saturating<i16> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<i16>> for Saturating<i16>

§

#### type Output = <Saturating<i16> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<i16>) -> <Saturating<i16> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<i32>> for &Saturating<i32>

§

#### type Output = <Saturating<i32> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<i32>) -> <Saturating<i32> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<i32>> for Saturating<i32>

§

#### type Output = <Saturating<i32> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<i32>) -> <Saturating<i32> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<i64>> for &Saturating<i64>

§

#### type Output = <Saturating<i64> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<i64>) -> <Saturating<i64> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<i64>> for Saturating<i64>

§

#### type Output = <Saturating<i64> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<i64>) -> <Saturating<i64> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<i8>> for &Saturating<i8>

§

#### type Output = <Saturating<i8> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<i8>) -> <Saturating<i8> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<i8>> for Saturating<i8>

§

#### type Output = <Saturating<i8> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<i8>) -> <Saturating<i8> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<isize>> for &Saturating<isize>

§

#### type Output = <Saturating<isize> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: &Saturating<isize> ) -> <Saturating<isize> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<isize>> for Saturating<isize>

§

#### type Output = <Saturating<isize> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: &Saturating<isize> ) -> <Saturating<isize> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u128>> for &Saturating<u128>

§

#### type Output = <Saturating<u128> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: &Saturating<u128> ) -> <Saturating<u128> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u128>> for Saturating<u128>

§

#### type Output = <Saturating<u128> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: &Saturating<u128> ) -> <Saturating<u128> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u16>> for &Saturating<u16>

§

#### type Output = <Saturating<u16> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<u16>) -> <Saturating<u16> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u16>> for Saturating<u16>

§

#### type Output = <Saturating<u16> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<u16>) -> <Saturating<u16> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u32>> for &Saturating<u32>

§

#### type Output = <Saturating<u32> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<u32>) -> <Saturating<u32> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u32>> for Saturating<u32>

§

#### type Output = <Saturating<u32> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<u32>) -> <Saturating<u32> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u64>> for &Saturating<u64>

§

#### type Output = <Saturating<u64> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<u64>) -> <Saturating<u64> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u64>> for Saturating<u64>

§

#### type Output = <Saturating<u64> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<u64>) -> <Saturating<u64> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u8>> for &Saturating<u8>

§

#### type Output = <Saturating<u8> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<u8>) -> <Saturating<u8> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<u8>> for Saturating<u8>

§

#### type Output = <Saturating<u8> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: &Saturating<u8>) -> <Saturating<u8> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<usize>> for &Saturating<usize>

§

#### type Output = <Saturating<usize> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: &Saturating<usize> ) -> <Saturating<usize> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd<&Saturating<usize>> for Saturating<usize>

§

#### type Output = <Saturating<usize> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: &Saturating<usize> ) -> <Saturating<usize> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<i128>> for &'a Saturating<i128>

§

#### type Output = <Saturating<i128> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i128>) -> <Saturating<i128> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<i16>> for &'a Saturating<i16>

§

#### type Output = <Saturating<i16> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i16>) -> <Saturating<i16> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<i32>> for &'a Saturating<i32>

§

#### type Output = <Saturating<i32> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i32>) -> <Saturating<i32> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<i64>> for &'a Saturating<i64>

§

#### type Output = <Saturating<i64> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i64>) -> <Saturating<i64> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<i8>> for &'a Saturating<i8>

§

#### type Output = <Saturating<i8> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i8>) -> <Saturating<i8> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<isize>> for &'a Saturating<isize>

§

#### type Output = <Saturating<isize> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: Saturating<isize> ) -> <Saturating<isize> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<u128>> for &'a Saturating<u128>

§

#### type Output = <Saturating<u128> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u128>) -> <Saturating<u128> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<u16>> for &'a Saturating<u16>

§

#### type Output = <Saturating<u16> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u16>) -> <Saturating<u16> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<u32>> for &'a Saturating<u32>

§

#### type Output = <Saturating<u32> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u32>) -> <Saturating<u32> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<u64>> for &'a Saturating<u64>

§

#### type Output = <Saturating<u64> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u64>) -> <Saturating<u64> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<u8>> for &'a Saturating<u8>

§

#### type Output = <Saturating<u8> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u8>) -> <Saturating<u8> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl<'a> BitAnd<Saturating<usize>> for &'a Saturating<usize>

§

#### type Output = <Saturating<usize> as BitAnd>::Output

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, other: Saturating<usize> ) -> <Saturating<usize> as BitAnd>::Output

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<i128>

§

#### type Output = Saturating<i128>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i128>) -> Saturating<i128>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<i16>

§

#### type Output = Saturating<i16>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i16>) -> Saturating<i16>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<i32>

§

#### type Output = Saturating<i32>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i32>) -> Saturating<i32>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<i64>

§

#### type Output = Saturating<i64>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i64>) -> Saturating<i64>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<i8>

§

#### type Output = Saturating<i8>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<i8>) -> Saturating<i8>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<isize>

§

#### type Output = Saturating<isize>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<isize>) -> Saturating<isize>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<u128>

§

#### type Output = Saturating<u128>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u128>) -> Saturating<u128>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<u16>

§

#### type Output = Saturating<u16>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u16>) -> Saturating<u16>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<u32>

§

#### type Output = Saturating<u32>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u32>) -> Saturating<u32>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<u64>

§

#### type Output = Saturating<u64>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u64>) -> Saturating<u64>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<u8>

§

#### type Output = Saturating<u8>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<u8>) -> Saturating<u8>

Performs the `&` operation. Read more
source§

### impl BitAnd for Saturating<usize>

§

#### type Output = Saturating<usize>

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, other: Saturating<usize>) -> Saturating<usize>

Performs the `&` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<i128>> for Saturating<i128>

source§

#### fn bitand_assign(&mut self, other: &Saturating<i128>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<i16>> for Saturating<i16>

source§

#### fn bitand_assign(&mut self, other: &Saturating<i16>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<i32>> for Saturating<i32>

source§

#### fn bitand_assign(&mut self, other: &Saturating<i32>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<i64>> for Saturating<i64>

source§

#### fn bitand_assign(&mut self, other: &Saturating<i64>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<i8>> for Saturating<i8>

source§

#### fn bitand_assign(&mut self, other: &Saturating<i8>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<isize>> for Saturating<isize>

source§

#### fn bitand_assign(&mut self, other: &Saturating<isize>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<u128>> for Saturating<u128>

source§

#### fn bitand_assign(&mut self, other: &Saturating<u128>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<u16>> for Saturating<u16>

source§

#### fn bitand_assign(&mut self, other: &Saturating<u16>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<u32>> for Saturating<u32>

source§

#### fn bitand_assign(&mut self, other: &Saturating<u32>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<u64>> for Saturating<u64>

source§

#### fn bitand_assign(&mut self, other: &Saturating<u64>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<u8>> for Saturating<u8>

source§

#### fn bitand_assign(&mut self, other: &Saturating<u8>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&Saturating<usize>> for Saturating<usize>

source§

#### fn bitand_assign(&mut self, other: &Saturating<usize>)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&i128> for Saturating<i128>

source§

#### fn bitand_assign(&mut self, other: &i128)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&i16> for Saturating<i16>

source§

#### fn bitand_assign(&mut self, other: &i16)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&i32> for Saturating<i32>

source§

#### fn bitand_assign(&mut self, other: &i32)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&i64> for Saturating<i64>

source§

#### fn bitand_assign(&mut self, other: &i64)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&i8> for Saturating<i8>

source§

#### fn bitand_assign(&mut self, other: &i8)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&isize> for Saturating<isize>

source§

#### fn bitand_assign(&mut self, other: &isize)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&u128> for Saturating<u128>

source§

#### fn bitand_assign(&mut self, other: &u128)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&u16> for Saturating<u16>

source§

#### fn bitand_assign(&mut self, other: &u16)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&u32> for Saturating<u32>

source§

#### fn bitand_assign(&mut self, other: &u32)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&u64> for Saturating<u64>

source§

#### fn bitand_assign(&mut self, other: &u64)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&u8> for Saturating<u8>

source§

#### fn bitand_assign(&mut self, other: &u8)

Performs the `&=` operation. Read more
1.22.0 · source§

### impl BitAndAssign<&usize> for Saturating<usize>

source§

#### fn bitand_assign(&mut self, other: &usize)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<i128> for Saturating<i128>

source§

#### fn bitand_assign(&mut self, other: i128)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<i16> for Saturating<i16>

source§

#### fn bitand_assign(&mut self, other: i16)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<i32> for Saturating<i32>

source§

#### fn bitand_assign(&mut self, other: i32)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<i64> for Saturating<i64>

source§

#### fn bitand_assign(&mut self, other: i64)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<i8> for Saturating<i8>

source§

#### fn bitand_assign(&mut self, other: i8)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<isize> for Saturating<isize>

source§

#### fn bitand_assign(&mut self, other: isize)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<u128> for Saturating<u128>

source§

#### fn bitand_assign(&mut self, other: u128)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<u16> for Saturating<u16>

source§

#### fn bitand_assign(&mut self, other: u16)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<u32> for Saturating<u32>

source§

#### fn bitand_assign(&mut self, other: u32)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<u64> for Saturating<u64>

source§

#### fn bitand_assign(&mut self, other: u64)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<u8> for Saturating<u8>

source§

#### fn bitand_assign(&mut self, other: u8)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign<usize> for Saturating<usize>

source§

#### fn bitand_assign(&mut self, other: usize)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<i128>

source§

#### fn bitand_assign(&mut self, other: Saturating<i128>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<i16>

source§

#### fn bitand_assign(&mut self, other: Saturating<i16>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<i32>

source§

#### fn bitand_assign(&mut self, other: Saturating<i32>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<i64>

source§

#### fn bitand_assign(&mut self, other: Saturating<i64>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<i8>

source§

#### fn bitand_assign(&mut self, other: Saturating<i8>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<isize>

source§

#### fn bitand_assign(&mut self, other: Saturating<isize>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<u128>

source§

#### fn bitand_assign(&mut self, other: Saturating<u128>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<u16>

source§

#### fn bitand_assign(&mut self, other: Saturating<u16>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<u32>

source§

#### fn bitand_assign(&mut self, other: Saturating<u32>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<u64>

source§

#### fn bitand_assign(&mut self, other: Saturating<u64>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<u8>

source§

#### fn bitand_assign(&mut self, other: Saturating<u8>)

Performs the `&=` operation. Read more
source§

### impl BitAndAssign for Saturating<usize>

source§

#### fn bitand_assign(&mut self, other: Saturating<usize>)

Performs the `&=` operation. Read more
source§

### impl BitOr<&Saturating<i128>> for &Saturating<i128>

§

#### type Output = <Saturating<i128> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i128>) -> <Saturating<i128> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<i128>> for Saturating<i128>

§

#### type Output = <Saturating<i128> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i128>) -> <Saturating<i128> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<i16>> for &Saturating<i16>

§

#### type Output = <Saturating<i16> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i16>) -> <Saturating<i16> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<i16>> for Saturating<i16>

§

#### type Output = <Saturating<i16> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i16>) -> <Saturating<i16> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<i32>> for &Saturating<i32>

§

#### type Output = <Saturating<i32> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i32>) -> <Saturating<i32> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<i32>> for Saturating<i32>

§

#### type Output = <Saturating<i32> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i32>) -> <Saturating<i32> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<i64>> for &Saturating<i64>

§

#### type Output = <Saturating<i64> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i64>) -> <Saturating<i64> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<i64>> for Saturating<i64>

§

#### type Output = <Saturating<i64> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i64>) -> <Saturating<i64> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<i8>> for &Saturating<i8>

§

#### type Output = <Saturating<i8> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i8>) -> <Saturating<i8> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<i8>> for Saturating<i8>

§

#### type Output = <Saturating<i8> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<i8>) -> <Saturating<i8> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<isize>> for &Saturating<isize>

§

#### type Output = <Saturating<isize> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor( self, other: &Saturating<isize> ) -> <Saturating<isize> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<isize>> for Saturating<isize>

§

#### type Output = <Saturating<isize> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor( self, other: &Saturating<isize> ) -> <Saturating<isize> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u128>> for &Saturating<u128>

§

#### type Output = <Saturating<u128> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u128>) -> <Saturating<u128> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u128>> for Saturating<u128>

§

#### type Output = <Saturating<u128> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u128>) -> <Saturating<u128> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u16>> for &Saturating<u16>

§

#### type Output = <Saturating<u16> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u16>) -> <Saturating<u16> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u16>> for Saturating<u16>

§

#### type Output = <Saturating<u16> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u16>) -> <Saturating<u16> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u32>> for &Saturating<u32>

§

#### type Output = <Saturating<u32> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u32>) -> <Saturating<u32> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u32>> for Saturating<u32>

§

#### type Output = <Saturating<u32> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u32>) -> <Saturating<u32> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u64>> for &Saturating<u64>

§

#### type Output = <Saturating<u64> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u64>) -> <Saturating<u64> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u64>> for Saturating<u64>

§

#### type Output = <Saturating<u64> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u64>) -> <Saturating<u64> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u8>> for &Saturating<u8>

§

#### type Output = <Saturating<u8> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u8>) -> <Saturating<u8> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<u8>> for Saturating<u8>

§

#### type Output = <Saturating<u8> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: &Saturating<u8>) -> <Saturating<u8> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<usize>> for &Saturating<usize>

§

#### type Output = <Saturating<usize> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor( self, other: &Saturating<usize> ) -> <Saturating<usize> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr<&Saturating<usize>> for Saturating<usize>

§

#### type Output = <Saturating<usize> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor( self, other: &Saturating<usize> ) -> <Saturating<usize> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<i128>> for &'a Saturating<i128>

§

#### type Output = <Saturating<i128> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i128>) -> <Saturating<i128> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<i16>> for &'a Saturating<i16>

§

#### type Output = <Saturating<i16> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i16>) -> <Saturating<i16> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<i32>> for &'a Saturating<i32>

§

#### type Output = <Saturating<i32> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i32>) -> <Saturating<i32> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<i64>> for &'a Saturating<i64>

§

#### type Output = <Saturating<i64> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i64>) -> <Saturating<i64> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<i8>> for &'a Saturating<i8>

§

#### type Output = <Saturating<i8> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i8>) -> <Saturating<i8> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<isize>> for &'a Saturating<isize>

§

#### type Output = <Saturating<isize> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<isize>) -> <Saturating<isize> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<u128>> for &'a Saturating<u128>

§

#### type Output = <Saturating<u128> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u128>) -> <Saturating<u128> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<u16>> for &'a Saturating<u16>

§

#### type Output = <Saturating<u16> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u16>) -> <Saturating<u16> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<u32>> for &'a Saturating<u32>

§

#### type Output = <Saturating<u32> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u32>) -> <Saturating<u32> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<u64>> for &'a Saturating<u64>

§

#### type Output = <Saturating<u64> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u64>) -> <Saturating<u64> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<u8>> for &'a Saturating<u8>

§

#### type Output = <Saturating<u8> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u8>) -> <Saturating<u8> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl<'a> BitOr<Saturating<usize>> for &'a Saturating<usize>

§

#### type Output = <Saturating<usize> as BitOr>::Output

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<usize>) -> <Saturating<usize> as BitOr>::Output

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<i128>

§

#### type Output = Saturating<i128>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i128>) -> Saturating<i128>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<i16>

§

#### type Output = Saturating<i16>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i16>) -> Saturating<i16>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<i32>

§

#### type Output = Saturating<i32>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i32>) -> Saturating<i32>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<i64>

§

#### type Output = Saturating<i64>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i64>) -> Saturating<i64>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<i8>

§

#### type Output = Saturating<i8>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<i8>) -> Saturating<i8>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<isize>

§

#### type Output = Saturating<isize>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<isize>) -> Saturating<isize>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<u128>

§

#### type Output = Saturating<u128>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u128>) -> Saturating<u128>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<u16>

§

#### type Output = Saturating<u16>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u16>) -> Saturating<u16>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<u32>

§

#### type Output = Saturating<u32>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u32>) -> Saturating<u32>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<u64>

§

#### type Output = Saturating<u64>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u64>) -> Saturating<u64>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<u8>

§

#### type Output = Saturating<u8>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<u8>) -> Saturating<u8>

Performs the `|` operation. Read more
source§

### impl BitOr for Saturating<usize>

§

#### type Output = Saturating<usize>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, other: Saturating<usize>) -> Saturating<usize>

Performs the `|` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<i128>> for Saturating<i128>

source§

#### fn bitor_assign(&mut self, other: &Saturating<i128>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<i16>> for Saturating<i16>

source§

#### fn bitor_assign(&mut self, other: &Saturating<i16>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<i32>> for Saturating<i32>

source§

#### fn bitor_assign(&mut self, other: &Saturating<i32>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<i64>> for Saturating<i64>

source§

#### fn bitor_assign(&mut self, other: &Saturating<i64>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<i8>> for Saturating<i8>

source§

#### fn bitor_assign(&mut self, other: &Saturating<i8>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<isize>> for Saturating<isize>

source§

#### fn bitor_assign(&mut self, other: &Saturating<isize>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<u128>> for Saturating<u128>

source§

#### fn bitor_assign(&mut self, other: &Saturating<u128>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<u16>> for Saturating<u16>

source§

#### fn bitor_assign(&mut self, other: &Saturating<u16>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<u32>> for Saturating<u32>

source§

#### fn bitor_assign(&mut self, other: &Saturating<u32>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<u64>> for Saturating<u64>

source§

#### fn bitor_assign(&mut self, other: &Saturating<u64>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<u8>> for Saturating<u8>

source§

#### fn bitor_assign(&mut self, other: &Saturating<u8>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&Saturating<usize>> for Saturating<usize>

source§

#### fn bitor_assign(&mut self, other: &Saturating<usize>)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&i128> for Saturating<i128>

source§

#### fn bitor_assign(&mut self, other: &i128)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&i16> for Saturating<i16>

source§

#### fn bitor_assign(&mut self, other: &i16)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&i32> for Saturating<i32>

source§

#### fn bitor_assign(&mut self, other: &i32)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&i64> for Saturating<i64>

source§

#### fn bitor_assign(&mut self, other: &i64)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&i8> for Saturating<i8>

source§

#### fn bitor_assign(&mut self, other: &i8)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&isize> for Saturating<isize>

source§

#### fn bitor_assign(&mut self, other: &isize)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&u128> for Saturating<u128>

source§

#### fn bitor_assign(&mut self, other: &u128)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&u16> for Saturating<u16>

source§

#### fn bitor_assign(&mut self, other: &u16)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&u32> for Saturating<u32>

source§

#### fn bitor_assign(&mut self, other: &u32)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&u64> for Saturating<u64>

source§

#### fn bitor_assign(&mut self, other: &u64)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&u8> for Saturating<u8>

source§

#### fn bitor_assign(&mut self, other: &u8)

Performs the `|=` operation. Read more
1.22.0 · source§

### impl BitOrAssign<&usize> for Saturating<usize>

source§

#### fn bitor_assign(&mut self, other: &usize)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<i128> for Saturating<i128>

source§

#### fn bitor_assign(&mut self, other: i128)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<i16> for Saturating<i16>

source§

#### fn bitor_assign(&mut self, other: i16)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<i32> for Saturating<i32>

source§

#### fn bitor_assign(&mut self, other: i32)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<i64> for Saturating<i64>

source§

#### fn bitor_assign(&mut self, other: i64)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<i8> for Saturating<i8>

source§

#### fn bitor_assign(&mut self, other: i8)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<isize> for Saturating<isize>

source§

#### fn bitor_assign(&mut self, other: isize)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<u128> for Saturating<u128>

source§

#### fn bitor_assign(&mut self, other: u128)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<u16> for Saturating<u16>

source§

#### fn bitor_assign(&mut self, other: u16)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<u32> for Saturating<u32>

source§

#### fn bitor_assign(&mut self, other: u32)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<u64> for Saturating<u64>

source§

#### fn bitor_assign(&mut self, other: u64)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<u8> for Saturating<u8>

source§

#### fn bitor_assign(&mut self, other: u8)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign<usize> for Saturating<usize>

source§

#### fn bitor_assign(&mut self, other: usize)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<i128>

source§

#### fn bitor_assign(&mut self, other: Saturating<i128>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<i16>

source§

#### fn bitor_assign(&mut self, other: Saturating<i16>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<i32>

source§

#### fn bitor_assign(&mut self, other: Saturating<i32>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<i64>

source§

#### fn bitor_assign(&mut self, other: Saturating<i64>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<i8>

source§

#### fn bitor_assign(&mut self, other: Saturating<i8>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<isize>

source§

#### fn bitor_assign(&mut self, other: Saturating<isize>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<u128>

source§

#### fn bitor_assign(&mut self, other: Saturating<u128>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<u16>

source§

#### fn bitor_assign(&mut self, other: Saturating<u16>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<u32>

source§

#### fn bitor_assign(&mut self, other: Saturating<u32>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<u64>

source§

#### fn bitor_assign(&mut self, other: Saturating<u64>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<u8>

source§

#### fn bitor_assign(&mut self, other: Saturating<u8>)

Performs the `|=` operation. Read more
source§

### impl BitOrAssign for Saturating<usize>

source§

#### fn bitor_assign(&mut self, other: Saturating<usize>)

Performs the `|=` operation. Read more
source§

### impl BitXor<&Saturating<i128>> for &Saturating<i128>

§

#### type Output = <Saturating<i128> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: &Saturating<i128> ) -> <Saturating<i128> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<i128>> for Saturating<i128>

§

#### type Output = <Saturating<i128> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: &Saturating<i128> ) -> <Saturating<i128> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<i16>> for &Saturating<i16>

§

#### type Output = <Saturating<i16> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<i16>) -> <Saturating<i16> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<i16>> for Saturating<i16>

§

#### type Output = <Saturating<i16> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<i16>) -> <Saturating<i16> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<i32>> for &Saturating<i32>

§

#### type Output = <Saturating<i32> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<i32>) -> <Saturating<i32> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<i32>> for Saturating<i32>

§

#### type Output = <Saturating<i32> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<i32>) -> <Saturating<i32> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<i64>> for &Saturating<i64>

§

#### type Output = <Saturating<i64> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<i64>) -> <Saturating<i64> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<i64>> for Saturating<i64>

§

#### type Output = <Saturating<i64> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<i64>) -> <Saturating<i64> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<i8>> for &Saturating<i8>

§

#### type Output = <Saturating<i8> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<i8>) -> <Saturating<i8> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<i8>> for Saturating<i8>

§

#### type Output = <Saturating<i8> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<i8>) -> <Saturating<i8> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<isize>> for &Saturating<isize>

§

#### type Output = <Saturating<isize> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: &Saturating<isize> ) -> <Saturating<isize> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<isize>> for Saturating<isize>

§

#### type Output = <Saturating<isize> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: &Saturating<isize> ) -> <Saturating<isize> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u128>> for &Saturating<u128>

§

#### type Output = <Saturating<u128> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: &Saturating<u128> ) -> <Saturating<u128> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u128>> for Saturating<u128>

§

#### type Output = <Saturating<u128> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: &Saturating<u128> ) -> <Saturating<u128> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u16>> for &Saturating<u16>

§

#### type Output = <Saturating<u16> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<u16>) -> <Saturating<u16> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u16>> for Saturating<u16>

§

#### type Output = <Saturating<u16> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<u16>) -> <Saturating<u16> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u32>> for &Saturating<u32>

§

#### type Output = <Saturating<u32> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<u32>) -> <Saturating<u32> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u32>> for Saturating<u32>

§

#### type Output = <Saturating<u32> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<u32>) -> <Saturating<u32> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u64>> for &Saturating<u64>

§

#### type Output = <Saturating<u64> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<u64>) -> <Saturating<u64> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u64>> for Saturating<u64>

§

#### type Output = <Saturating<u64> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<u64>) -> <Saturating<u64> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u8>> for &Saturating<u8>

§

#### type Output = <Saturating<u8> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<u8>) -> <Saturating<u8> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<u8>> for Saturating<u8>

§

#### type Output = <Saturating<u8> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: &Saturating<u8>) -> <Saturating<u8> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<usize>> for &Saturating<usize>

§

#### type Output = <Saturating<usize> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: &Saturating<usize> ) -> <Saturating<usize> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor<&Saturating<usize>> for Saturating<usize>

§

#### type Output = <Saturating<usize> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: &Saturating<usize> ) -> <Saturating<usize> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<i128>> for &'a Saturating<i128>

§

#### type Output = <Saturating<i128> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i128>) -> <Saturating<i128> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<i16>> for &'a Saturating<i16>

§

#### type Output = <Saturating<i16> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i16>) -> <Saturating<i16> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<i32>> for &'a Saturating<i32>

§

#### type Output = <Saturating<i32> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i32>) -> <Saturating<i32> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<i64>> for &'a Saturating<i64>

§

#### type Output = <Saturating<i64> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i64>) -> <Saturating<i64> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<i8>> for &'a Saturating<i8>

§

#### type Output = <Saturating<i8> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i8>) -> <Saturating<i8> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<isize>> for &'a Saturating<isize>

§

#### type Output = <Saturating<isize> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: Saturating<isize> ) -> <Saturating<isize> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<u128>> for &'a Saturating<u128>

§

#### type Output = <Saturating<u128> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u128>) -> <Saturating<u128> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<u16>> for &'a Saturating<u16>

§

#### type Output = <Saturating<u16> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u16>) -> <Saturating<u16> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<u32>> for &'a Saturating<u32>

§

#### type Output = <Saturating<u32> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u32>) -> <Saturating<u32> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<u64>> for &'a Saturating<u64>

§

#### type Output = <Saturating<u64> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u64>) -> <Saturating<u64> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<u8>> for &'a Saturating<u8>

§

#### type Output = <Saturating<u8> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u8>) -> <Saturating<u8> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl<'a> BitXor<Saturating<usize>> for &'a Saturating<usize>

§

#### type Output = <Saturating<usize> as BitXor>::Output

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, other: Saturating<usize> ) -> <Saturating<usize> as BitXor>::Output

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<i128>

§

#### type Output = Saturating<i128>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i128>) -> Saturating<i128>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<i16>

§

#### type Output = Saturating<i16>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i16>) -> Saturating<i16>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<i32>

§

#### type Output = Saturating<i32>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i32>) -> Saturating<i32>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<i64>

§

#### type Output = Saturating<i64>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i64>) -> Saturating<i64>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<i8>

§

#### type Output = Saturating<i8>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<i8>) -> Saturating<i8>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<isize>

§

#### type Output = Saturating<isize>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<isize>) -> Saturating<isize>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<u128>

§

#### type Output = Saturating<u128>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u128>) -> Saturating<u128>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<u16>

§

#### type Output = Saturating<u16>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u16>) -> Saturating<u16>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<u32>

§

#### type Output = Saturating<u32>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u32>) -> Saturating<u32>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<u64>

§

#### type Output = Saturating<u64>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u64>) -> Saturating<u64>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<u8>

§

#### type Output = Saturating<u8>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<u8>) -> Saturating<u8>

Performs the `^` operation. Read more
source§

### impl BitXor for Saturating<usize>

§

#### type Output = Saturating<usize>

The resulting type after applying the `^` operator.
source§

#### fn bitxor(self, other: Saturating<usize>) -> Saturating<usize>

Performs the `^` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<i128>> for Saturating<i128>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<i128>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<i16>> for Saturating<i16>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<i16>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<i32>> for Saturating<i32>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<i32>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<i64>> for Saturating<i64>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<i64>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<i8>> for Saturating<i8>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<i8>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<isize>> for Saturating<isize>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<isize>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<u128>> for Saturating<u128>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<u128>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<u16>> for Saturating<u16>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<u16>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<u32>> for Saturating<u32>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<u32>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<u64>> for Saturating<u64>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<u64>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<u8>> for Saturating<u8>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<u8>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&Saturating<usize>> for Saturating<usize>

source§

#### fn bitxor_assign(&mut self, other: &Saturating<usize>)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&i128> for Saturating<i128>

source§

#### fn bitxor_assign(&mut self, other: &i128)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&i16> for Saturating<i16>

source§

#### fn bitxor_assign(&mut self, other: &i16)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&i32> for Saturating<i32>

source§

#### fn bitxor_assign(&mut self, other: &i32)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&i64> for Saturating<i64>

source§

#### fn bitxor_assign(&mut self, other: &i64)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&i8> for Saturating<i8>

source§

#### fn bitxor_assign(&mut self, other: &i8)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&isize> for Saturating<isize>

source§

#### fn bitxor_assign(&mut self, other: &isize)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&u128> for Saturating<u128>

source§

#### fn bitxor_assign(&mut self, other: &u128)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&u16> for Saturating<u16>

source§

#### fn bitxor_assign(&mut self, other: &u16)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&u32> for Saturating<u32>

source§

#### fn bitxor_assign(&mut self, other: &u32)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&u64> for Saturating<u64>

source§

#### fn bitxor_assign(&mut self, other: &u64)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&u8> for Saturating<u8>

source§

#### fn bitxor_assign(&mut self, other: &u8)

Performs the `^=` operation. Read more
1.22.0 · source§

### impl BitXorAssign<&usize> for Saturating<usize>

source§

#### fn bitxor_assign(&mut self, other: &usize)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<i128> for Saturating<i128>

source§

#### fn bitxor_assign(&mut self, other: i128)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<i16> for Saturating<i16>

source§

#### fn bitxor_assign(&mut self, other: i16)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<i32> for Saturating<i32>

source§

#### fn bitxor_assign(&mut self, other: i32)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<i64> for Saturating<i64>

source§

#### fn bitxor_assign(&mut self, other: i64)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<i8> for Saturating<i8>

source§

#### fn bitxor_assign(&mut self, other: i8)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<isize> for Saturating<isize>

source§

#### fn bitxor_assign(&mut self, other: isize)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<u128> for Saturating<u128>

source§

#### fn bitxor_assign(&mut self, other: u128)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<u16> for Saturating<u16>

source§

#### fn bitxor_assign(&mut self, other: u16)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<u32> for Saturating<u32>

source§

#### fn bitxor_assign(&mut self, other: u32)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<u64> for Saturating<u64>

source§

#### fn bitxor_assign(&mut self, other: u64)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<u8> for Saturating<u8>

source§

#### fn bitxor_assign(&mut self, other: u8)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign<usize> for Saturating<usize>

source§

#### fn bitxor_assign(&mut self, other: usize)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<i128>

source§

#### fn bitxor_assign(&mut self, other: Saturating<i128>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<i16>

source§

#### fn bitxor_assign(&mut self, other: Saturating<i16>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<i32>

source§

#### fn bitxor_assign(&mut self, other: Saturating<i32>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<i64>

source§

#### fn bitxor_assign(&mut self, other: Saturating<i64>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<i8>

source§

#### fn bitxor_assign(&mut self, other: Saturating<i8>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<isize>

source§

#### fn bitxor_assign(&mut self, other: Saturating<isize>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<u128>

source§

#### fn bitxor_assign(&mut self, other: Saturating<u128>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<u16>

source§

#### fn bitxor_assign(&mut self, other: Saturating<u16>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<u32>

source§

#### fn bitxor_assign(&mut self, other: Saturating<u32>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<u64>

source§

#### fn bitxor_assign(&mut self, other: Saturating<u64>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<u8>

source§

#### fn bitxor_assign(&mut self, other: Saturating<u8>)

Performs the `^=` operation. Read more
source§

### impl BitXorAssign for Saturating<usize>

source§

#### fn bitxor_assign(&mut self, other: Saturating<usize>)

Performs the `^=` operation. Read more
source§

### impl<T> Clone for Saturating<T>where T: Clone,

source§

#### fn clone(&self) -> Saturating<T>

Returns a copy of the value. Read more
1.0.0 · source§

#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`. Read more
source§

### impl<T> Debug for Saturating<T>where T: Debug,

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

### impl<T> Default for Saturating<T>where T: Default,

source§

#### fn default() -> Saturating<T>

Returns the “default value” for a type. Read more
source§

### impl<T> Display for Saturating<T>where T: Display,

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

### impl Div<&Saturating<i128>> for &Saturating<i128>

§

#### type Output = <Saturating<i128> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i128>) -> <Saturating<i128> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<i128>> for Saturating<i128>

§

#### type Output = <Saturating<i128> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i128>) -> <Saturating<i128> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<i16>> for &Saturating<i16>

§

#### type Output = <Saturating<i16> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i16>) -> <Saturating<i16> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<i16>> for Saturating<i16>

§

#### type Output = <Saturating<i16> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i16>) -> <Saturating<i16> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<i32>> for &Saturating<i32>

§

#### type Output = <Saturating<i32> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i32>) -> <Saturating<i32> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<i32>> for Saturating<i32>

§

#### type Output = <Saturating<i32> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i32>) -> <Saturating<i32> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<i64>> for &Saturating<i64>

§

#### type Output = <Saturating<i64> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i64>) -> <Saturating<i64> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<i64>> for Saturating<i64>

§

#### type Output = <Saturating<i64> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i64>) -> <Saturating<i64> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<i8>> for &Saturating<i8>

§

#### type Output = <Saturating<i8> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i8>) -> <Saturating<i8> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<i8>> for Saturating<i8>

§

#### type Output = <Saturating<i8> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<i8>) -> <Saturating<i8> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<isize>> for &Saturating<isize>

§

#### type Output = <Saturating<isize> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<isize>) -> <Saturating<isize> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<isize>> for Saturating<isize>

§

#### type Output = <Saturating<isize> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<isize>) -> <Saturating<isize> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u128>> for &Saturating<u128>

§

#### type Output = <Saturating<u128> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u128>) -> <Saturating<u128> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u128>> for Saturating<u128>

§

#### type Output = <Saturating<u128> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u128>) -> <Saturating<u128> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u16>> for &Saturating<u16>

§

#### type Output = <Saturating<u16> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u16>) -> <Saturating<u16> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u16>> for Saturating<u16>

§

#### type Output = <Saturating<u16> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u16>) -> <Saturating<u16> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u32>> for &Saturating<u32>

§

#### type Output = <Saturating<u32> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u32>) -> <Saturating<u32> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u32>> for Saturating<u32>

§

#### type Output = <Saturating<u32> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u32>) -> <Saturating<u32> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u64>> for &Saturating<u64>

§

#### type Output = <Saturating<u64> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u64>) -> <Saturating<u64> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u64>> for Saturating<u64>

§

#### type Output = <Saturating<u64> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u64>) -> <Saturating<u64> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u8>> for &Saturating<u8>

§

#### type Output = <Saturating<u8> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u8>) -> <Saturating<u8> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<u8>> for Saturating<u8>

§

#### type Output = <Saturating<u8> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<u8>) -> <Saturating<u8> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<usize>> for &Saturating<usize>

§

#### type Output = <Saturating<usize> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<usize>) -> <Saturating<usize> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div<&Saturating<usize>> for Saturating<usize>

§

#### type Output = <Saturating<usize> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: &Saturating<usize>) -> <Saturating<usize> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<i128>> for &'a Saturating<i128>

§

#### type Output = <Saturating<i128> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i128>) -> <Saturating<i128> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<i16>> for &'a Saturating<i16>

§

#### type Output = <Saturating<i16> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i16>) -> <Saturating<i16> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<i32>> for &'a Saturating<i32>

§

#### type Output = <Saturating<i32> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i32>) -> <Saturating<i32> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<i64>> for &'a Saturating<i64>

§

#### type Output = <Saturating<i64> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i64>) -> <Saturating<i64> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<i8>> for &'a Saturating<i8>

§

#### type Output = <Saturating<i8> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i8>) -> <Saturating<i8> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<isize>> for &'a Saturating<isize>

§

#### type Output = <Saturating<isize> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<isize>) -> <Saturating<isize> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<u128>> for &'a Saturating<u128>

§

#### type Output = <Saturating<u128> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u128>) -> <Saturating<u128> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<u16>> for &'a Saturating<u16>

§

#### type Output = <Saturating<u16> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u16>) -> <Saturating<u16> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<u32>> for &'a Saturating<u32>

§

#### type Output = <Saturating<u32> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u32>) -> <Saturating<u32> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<u64>> for &'a Saturating<u64>

§

#### type Output = <Saturating<u64> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u64>) -> <Saturating<u64> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<u8>> for &'a Saturating<u8>

§

#### type Output = <Saturating<u8> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u8>) -> <Saturating<u8> as Div>::Output

Performs the `/` operation. Read more
source§

### impl<'a> Div<Saturating<usize>> for &'a Saturating<usize>

§

#### type Output = <Saturating<usize> as Div>::Output

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<usize>) -> <Saturating<usize> as Div>::Output

Performs the `/` operation. Read more
source§

### impl Div for Saturating<i128>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2i128), Saturating(5i128) / Saturating(2));
    assert_eq!(Saturating(i128::MAX), Saturating(i128::MAX) / Saturating(1));
    assert_eq!(Saturating(i128::MIN), Saturating(i128::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0i128) / Saturating(0);

Run
§

#### type Output = Saturating<i128>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i128>) -> Saturating<i128>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<i16>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2i16), Saturating(5i16) / Saturating(2));
    assert_eq!(Saturating(i16::MAX), Saturating(i16::MAX) / Saturating(1));
    assert_eq!(Saturating(i16::MIN), Saturating(i16::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0i16) / Saturating(0);

Run
§

#### type Output = Saturating<i16>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i16>) -> Saturating<i16>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<i32>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2i32), Saturating(5i32) / Saturating(2));
    assert_eq!(Saturating(i32::MAX), Saturating(i32::MAX) / Saturating(1));
    assert_eq!(Saturating(i32::MIN), Saturating(i32::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0i32) / Saturating(0);

Run
§

#### type Output = Saturating<i32>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i32>) -> Saturating<i32>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<i64>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2i64), Saturating(5i64) / Saturating(2));
    assert_eq!(Saturating(i64::MAX), Saturating(i64::MAX) / Saturating(1));
    assert_eq!(Saturating(i64::MIN), Saturating(i64::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0i64) / Saturating(0);

Run
§

#### type Output = Saturating<i64>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i64>) -> Saturating<i64>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<i8>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2i8), Saturating(5i8) / Saturating(2));
    assert_eq!(Saturating(i8::MAX), Saturating(i8::MAX) / Saturating(1));
    assert_eq!(Saturating(i8::MIN), Saturating(i8::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0i8) / Saturating(0);

Run
§

#### type Output = Saturating<i8>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<i8>) -> Saturating<i8>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<isize>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2isize), Saturating(5isize) / Saturating(2));
    assert_eq!(Saturating(isize::MAX), Saturating(isize::MAX) / Saturating(1));
    assert_eq!(Saturating(isize::MIN), Saturating(isize::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0isize) / Saturating(0);

Run
§

#### type Output = Saturating<isize>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<isize>) -> Saturating<isize>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<u128>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2u128), Saturating(5u128) / Saturating(2));
    assert_eq!(Saturating(u128::MAX), Saturating(u128::MAX) / Saturating(1));
    assert_eq!(Saturating(u128::MIN), Saturating(u128::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0u128) / Saturating(0);

Run
§

#### type Output = Saturating<u128>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u128>) -> Saturating<u128>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<u16>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2u16), Saturating(5u16) / Saturating(2));
    assert_eq!(Saturating(u16::MAX), Saturating(u16::MAX) / Saturating(1));
    assert_eq!(Saturating(u16::MIN), Saturating(u16::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0u16) / Saturating(0);

Run
§

#### type Output = Saturating<u16>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u16>) -> Saturating<u16>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<u32>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2u32), Saturating(5u32) / Saturating(2));
    assert_eq!(Saturating(u32::MAX), Saturating(u32::MAX) / Saturating(1));
    assert_eq!(Saturating(u32::MIN), Saturating(u32::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0u32) / Saturating(0);

Run
§

#### type Output = Saturating<u32>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u32>) -> Saturating<u32>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<u64>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2u64), Saturating(5u64) / Saturating(2));
    assert_eq!(Saturating(u64::MAX), Saturating(u64::MAX) / Saturating(1));
    assert_eq!(Saturating(u64::MIN), Saturating(u64::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0u64) / Saturating(0);

Run
§

#### type Output = Saturating<u64>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u64>) -> Saturating<u64>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<u8>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2u8), Saturating(5u8) / Saturating(2));
    assert_eq!(Saturating(u8::MAX), Saturating(u8::MAX) / Saturating(1));
    assert_eq!(Saturating(u8::MIN), Saturating(u8::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0u8) / Saturating(0);

Run
§

#### type Output = Saturating<u8>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<u8>) -> Saturating<u8>

Performs the `/` operation. Read more
source§

### impl Div for Saturating<usize>

#### Examples

Basic usage:

    use std::num::Saturating;

    assert_eq!(Saturating(2usize), Saturating(5usize) / Saturating(2));
    assert_eq!(Saturating(usize::MAX), Saturating(usize::MAX) / Saturating(1));
    assert_eq!(Saturating(usize::MIN), Saturating(usize::MIN) / Saturating(1));

Run
ⓘ

    use std::num::Saturating;

    let _ = Saturating(0usize) / Saturating(0);

Run
§

#### type Output = Saturating<usize>

The resulting type after applying the `/` operator.
source§

#### fn div(self, other: Saturating<usize>) -> Saturating<usize>

Performs the `/` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<i128>> for Saturating<i128>

source§

#### fn div_assign(&mut self, other: &Saturating<i128>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<i16>> for Saturating<i16>

source§

#### fn div_assign(&mut self, other: &Saturating<i16>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<i32>> for Saturating<i32>

source§

#### fn div_assign(&mut self, other: &Saturating<i32>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<i64>> for Saturating<i64>

source§

#### fn div_assign(&mut self, other: &Saturating<i64>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<i8>> for Saturating<i8>

source§

#### fn div_assign(&mut self, other: &Saturating<i8>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<isize>> for Saturating<isize>

source§

#### fn div_assign(&mut self, other: &Saturating<isize>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<u128>> for Saturating<u128>

source§

#### fn div_assign(&mut self, other: &Saturating<u128>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<u16>> for Saturating<u16>

source§

#### fn div_assign(&mut self, other: &Saturating<u16>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<u32>> for Saturating<u32>

source§

#### fn div_assign(&mut self, other: &Saturating<u32>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<u64>> for Saturating<u64>

source§

#### fn div_assign(&mut self, other: &Saturating<u64>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<u8>> for Saturating<u8>

source§

#### fn div_assign(&mut self, other: &Saturating<u8>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&Saturating<usize>> for Saturating<usize>

source§

#### fn div_assign(&mut self, other: &Saturating<usize>)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&i128> for Saturating<i128>

source§

#### fn div_assign(&mut self, other: &i128)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&i16> for Saturating<i16>

source§

#### fn div_assign(&mut self, other: &i16)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&i32> for Saturating<i32>

source§

#### fn div_assign(&mut self, other: &i32)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&i64> for Saturating<i64>

source§

#### fn div_assign(&mut self, other: &i64)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&i8> for Saturating<i8>

source§

#### fn div_assign(&mut self, other: &i8)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&isize> for Saturating<isize>

source§

#### fn div_assign(&mut self, other: &isize)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&u128> for Saturating<u128>

source§

#### fn div_assign(&mut self, other: &u128)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&u16> for Saturating<u16>

source§

#### fn div_assign(&mut self, other: &u16)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&u32> for Saturating<u32>

source§

#### fn div_assign(&mut self, other: &u32)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&u64> for Saturating<u64>

source§

#### fn div_assign(&mut self, other: &u64)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&u8> for Saturating<u8>

source§

#### fn div_assign(&mut self, other: &u8)

Performs the `/=` operation. Read more
1.22.0 · source§

### impl DivAssign<&usize> for Saturating<usize>

source§

#### fn div_assign(&mut self, other: &usize)

Performs the `/=` operation. Read more
source§

### impl DivAssign<i128> for Saturating<i128>

source§

#### fn div_assign(&mut self, other: i128)

Performs the `/=` operation. Read more
source§

### impl DivAssign<i16> for Saturating<i16>

source§

#### fn div_assign(&mut self, other: i16)

Performs the `/=` operation. Read more
source§

### impl DivAssign<i32> for Saturating<i32>

source§

#### fn div_assign(&mut self, other: i32)

Performs the `/=` operation. Read more
source§

### impl DivAssign<i64> for Saturating<i64>

source§

#### fn div_assign(&mut self, other: i64)

Performs the `/=` operation. Read more
source§

### impl DivAssign<i8> for Saturating<i8>

source§

#### fn div_assign(&mut self, other: i8)

Performs the `/=` operation. Read more
source§

### impl DivAssign<isize> for Saturating<isize>

source§

#### fn div_assign(&mut self, other: isize)

Performs the `/=` operation. Read more
source§

### impl DivAssign<u128> for Saturating<u128>

source§

#### fn div_assign(&mut self, other: u128)

Performs the `/=` operation. Read more
source§

### impl DivAssign<u16> for Saturating<u16>

source§

#### fn div_assign(&mut self, other: u16)

Performs the `/=` operation. Read more
source§

### impl DivAssign<u32> for Saturating<u32>

source§

#### fn div_assign(&mut self, other: u32)

Performs the `/=` operation. Read more
source§

### impl DivAssign<u64> for Saturating<u64>

source§

#### fn div_assign(&mut self, other: u64)

Performs the `/=` operation. Read more
source§

### impl DivAssign<u8> for Saturating<u8>

source§

#### fn div_assign(&mut self, other: u8)

Performs the `/=` operation. Read more
source§

### impl DivAssign<usize> for Saturating<usize>

source§

#### fn div_assign(&mut self, other: usize)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<i128>

source§

#### fn div_assign(&mut self, other: Saturating<i128>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<i16>

source§

#### fn div_assign(&mut self, other: Saturating<i16>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<i32>

source§

#### fn div_assign(&mut self, other: Saturating<i32>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<i64>

source§

#### fn div_assign(&mut self, other: Saturating<i64>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<i8>

source§

#### fn div_assign(&mut self, other: Saturating<i8>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<isize>

source§

#### fn div_assign(&mut self, other: Saturating<isize>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<u128>

source§

#### fn div_assign(&mut self, other: Saturating<u128>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<u16>

source§

#### fn div_assign(&mut self, other: Saturating<u16>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<u32>

source§

#### fn div_assign(&mut self, other: Saturating<u32>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<u64>

source§

#### fn div_assign(&mut self, other: Saturating<u64>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<u8>

source§

#### fn div_assign(&mut self, other: Saturating<u8>)

Performs the `/=` operation. Read more
source§

### impl DivAssign for Saturating<usize>

source§

#### fn div_assign(&mut self, other: Saturating<usize>)

Performs the `/=` operation. Read more
source§

### impl<T> Hash for Saturating<T>where T: Hash,

source§

#### fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

#### fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl<T> LowerHex for Saturating<T>where T: LowerHex,

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.
source§

### impl Mul<&Saturating<i128>> for &Saturating<i128>

§

#### type Output = <Saturating<i128> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i128>) -> <Saturating<i128> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<i128>> for Saturating<i128>

§

#### type Output = <Saturating<i128> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i128>) -> <Saturating<i128> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<i16>> for &Saturating<i16>

§

#### type Output = <Saturating<i16> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i16>) -> <Saturating<i16> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<i16>> for Saturating<i16>

§

#### type Output = <Saturating<i16> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i16>) -> <Saturating<i16> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<i32>> for &Saturating<i32>

§

#### type Output = <Saturating<i32> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i32>) -> <Saturating<i32> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<i32>> for Saturating<i32>

§

#### type Output = <Saturating<i32> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i32>) -> <Saturating<i32> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<i64>> for &Saturating<i64>

§

#### type Output = <Saturating<i64> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i64>) -> <Saturating<i64> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<i64>> for Saturating<i64>

§

#### type Output = <Saturating<i64> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i64>) -> <Saturating<i64> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<i8>> for &Saturating<i8>

§

#### type Output = <Saturating<i8> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i8>) -> <Saturating<i8> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<i8>> for Saturating<i8>

§

#### type Output = <Saturating<i8> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<i8>) -> <Saturating<i8> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<isize>> for &Saturating<isize>

§

#### type Output = <Saturating<isize> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<isize>) -> <Saturating<isize> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<isize>> for Saturating<isize>

§

#### type Output = <Saturating<isize> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<isize>) -> <Saturating<isize> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u128>> for &Saturating<u128>

§

#### type Output = <Saturating<u128> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u128>) -> <Saturating<u128> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u128>> for Saturating<u128>

§

#### type Output = <Saturating<u128> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u128>) -> <Saturating<u128> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u16>> for &Saturating<u16>

§

#### type Output = <Saturating<u16> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u16>) -> <Saturating<u16> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u16>> for Saturating<u16>

§

#### type Output = <Saturating<u16> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u16>) -> <Saturating<u16> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u32>> for &Saturating<u32>

§

#### type Output = <Saturating<u32> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u32>) -> <Saturating<u32> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u32>> for Saturating<u32>

§

#### type Output = <Saturating<u32> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u32>) -> <Saturating<u32> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u64>> for &Saturating<u64>

§

#### type Output = <Saturating<u64> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u64>) -> <Saturating<u64> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u64>> for Saturating<u64>

§

#### type Output = <Saturating<u64> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u64>) -> <Saturating<u64> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u8>> for &Saturating<u8>

§

#### type Output = <Saturating<u8> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u8>) -> <Saturating<u8> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<u8>> for Saturating<u8>

§

#### type Output = <Saturating<u8> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<u8>) -> <Saturating<u8> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<usize>> for &Saturating<usize>

§

#### type Output = <Saturating<usize> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<usize>) -> <Saturating<usize> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul<&Saturating<usize>> for Saturating<usize>

§

#### type Output = <Saturating<usize> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: &Saturating<usize>) -> <Saturating<usize> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<i128>> for &'a Saturating<i128>

§

#### type Output = <Saturating<i128> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i128>) -> <Saturating<i128> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<i16>> for &'a Saturating<i16>

§

#### type Output = <Saturating<i16> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i16>) -> <Saturating<i16> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<i32>> for &'a Saturating<i32>

§

#### type Output = <Saturating<i32> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i32>) -> <Saturating<i32> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<i64>> for &'a Saturating<i64>

§

#### type Output = <Saturating<i64> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i64>) -> <Saturating<i64> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<i8>> for &'a Saturating<i8>

§

#### type Output = <Saturating<i8> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i8>) -> <Saturating<i8> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<isize>> for &'a Saturating<isize>

§

#### type Output = <Saturating<isize> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<isize>) -> <Saturating<isize> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<u128>> for &'a Saturating<u128>

§

#### type Output = <Saturating<u128> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u128>) -> <Saturating<u128> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<u16>> for &'a Saturating<u16>

§

#### type Output = <Saturating<u16> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u16>) -> <Saturating<u16> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<u32>> for &'a Saturating<u32>

§

#### type Output = <Saturating<u32> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u32>) -> <Saturating<u32> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<u64>> for &'a Saturating<u64>

§

#### type Output = <Saturating<u64> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u64>) -> <Saturating<u64> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<u8>> for &'a Saturating<u8>

§

#### type Output = <Saturating<u8> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u8>) -> <Saturating<u8> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl<'a> Mul<Saturating<usize>> for &'a Saturating<usize>

§

#### type Output = <Saturating<usize> as Mul>::Output

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<usize>) -> <Saturating<usize> as Mul>::Output

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<i128>

§

#### type Output = Saturating<i128>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i128>) -> Saturating<i128>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<i16>

§

#### type Output = Saturating<i16>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i16>) -> Saturating<i16>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<i32>

§

#### type Output = Saturating<i32>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i32>) -> Saturating<i32>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<i64>

§

#### type Output = Saturating<i64>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i64>) -> Saturating<i64>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<i8>

§

#### type Output = Saturating<i8>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<i8>) -> Saturating<i8>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<isize>

§

#### type Output = Saturating<isize>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<isize>) -> Saturating<isize>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<u128>

§

#### type Output = Saturating<u128>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u128>) -> Saturating<u128>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<u16>

§

#### type Output = Saturating<u16>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u16>) -> Saturating<u16>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<u32>

§

#### type Output = Saturating<u32>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u32>) -> Saturating<u32>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<u64>

§

#### type Output = Saturating<u64>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u64>) -> Saturating<u64>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<u8>

§

#### type Output = Saturating<u8>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<u8>) -> Saturating<u8>

Performs the `*` operation. Read more
source§

### impl Mul for Saturating<usize>

§

#### type Output = Saturating<usize>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, other: Saturating<usize>) -> Saturating<usize>

Performs the `*` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<i128>> for Saturating<i128>

source§

#### fn mul_assign(&mut self, other: &Saturating<i128>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<i16>> for Saturating<i16>

source§

#### fn mul_assign(&mut self, other: &Saturating<i16>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<i32>> for Saturating<i32>

source§

#### fn mul_assign(&mut self, other: &Saturating<i32>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<i64>> for Saturating<i64>

source§

#### fn mul_assign(&mut self, other: &Saturating<i64>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<i8>> for Saturating<i8>

source§

#### fn mul_assign(&mut self, other: &Saturating<i8>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<isize>> for Saturating<isize>

source§

#### fn mul_assign(&mut self, other: &Saturating<isize>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<u128>> for Saturating<u128>

source§

#### fn mul_assign(&mut self, other: &Saturating<u128>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<u16>> for Saturating<u16>

source§

#### fn mul_assign(&mut self, other: &Saturating<u16>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<u32>> for Saturating<u32>

source§

#### fn mul_assign(&mut self, other: &Saturating<u32>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<u64>> for Saturating<u64>

source§

#### fn mul_assign(&mut self, other: &Saturating<u64>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<u8>> for Saturating<u8>

source§

#### fn mul_assign(&mut self, other: &Saturating<u8>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&Saturating<usize>> for Saturating<usize>

source§

#### fn mul_assign(&mut self, other: &Saturating<usize>)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&i128> for Saturating<i128>

source§

#### fn mul_assign(&mut self, other: &i128)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&i16> for Saturating<i16>

source§

#### fn mul_assign(&mut self, other: &i16)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&i32> for Saturating<i32>

source§

#### fn mul_assign(&mut self, other: &i32)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&i64> for Saturating<i64>

source§

#### fn mul_assign(&mut self, other: &i64)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&i8> for Saturating<i8>

source§

#### fn mul_assign(&mut self, other: &i8)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&isize> for Saturating<isize>

source§

#### fn mul_assign(&mut self, other: &isize)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&u128> for Saturating<u128>

source§

#### fn mul_assign(&mut self, other: &u128)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&u16> for Saturating<u16>

source§

#### fn mul_assign(&mut self, other: &u16)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&u32> for Saturating<u32>

source§

#### fn mul_assign(&mut self, other: &u32)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&u64> for Saturating<u64>

source§

#### fn mul_assign(&mut self, other: &u64)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&u8> for Saturating<u8>

source§

#### fn mul_assign(&mut self, other: &u8)

Performs the `*=` operation. Read more
1.22.0 · source§

### impl MulAssign<&usize> for Saturating<usize>

source§

#### fn mul_assign(&mut self, other: &usize)

Performs the `*=` operation. Read more
source§

### impl MulAssign<i128> for Saturating<i128>

source§

#### fn mul_assign(&mut self, other: i128)

Performs the `*=` operation. Read more
source§

### impl MulAssign<i16> for Saturating<i16>

source§

#### fn mul_assign(&mut self, other: i16)

Performs the `*=` operation. Read more
source§

### impl MulAssign<i32> for Saturating<i32>

source§

#### fn mul_assign(&mut self, other: i32)

Performs the `*=` operation. Read more
source§

### impl MulAssign<i64> for Saturating<i64>

source§

#### fn mul_assign(&mut self, other: i64)

Performs the `*=` operation. Read more
source§

### impl MulAssign<i8> for Saturating<i8>

source§

#### fn mul_assign(&mut self, other: i8)

Performs the `*=` operation. Read more
source§

### impl MulAssign<isize> for Saturating<isize>

source§

#### fn mul_assign(&mut self, other: isize)

Performs the `*=` operation. Read more
source§

### impl MulAssign<u128> for Saturating<u128>

source§

#### fn mul_assign(&mut self, other: u128)

Performs the `*=` operation. Read more
source§

### impl MulAssign<u16> for Saturating<u16>

source§

#### fn mul_assign(&mut self, other: u16)

Performs the `*=` operation. Read more
source§

### impl MulAssign<u32> for Saturating<u32>

source§

#### fn mul_assign(&mut self, other: u32)

Performs the `*=` operation. Read more
source§

### impl MulAssign<u64> for Saturating<u64>

source§

#### fn mul_assign(&mut self, other: u64)

Performs the `*=` operation. Read more
source§

### impl MulAssign<u8> for Saturating<u8>

source§

#### fn mul_assign(&mut self, other: u8)

Performs the `*=` operation. Read more
source§

### impl MulAssign<usize> for Saturating<usize>

source§

#### fn mul_assign(&mut self, other: usize)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<i128>

source§

#### fn mul_assign(&mut self, other: Saturating<i128>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<i16>

source§

#### fn mul_assign(&mut self, other: Saturating<i16>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<i32>

source§

#### fn mul_assign(&mut self, other: Saturating<i32>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<i64>

source§

#### fn mul_assign(&mut self, other: Saturating<i64>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<i8>

source§

#### fn mul_assign(&mut self, other: Saturating<i8>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<isize>

source§

#### fn mul_assign(&mut self, other: Saturating<isize>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<u128>

source§

#### fn mul_assign(&mut self, other: Saturating<u128>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<u16>

source§

#### fn mul_assign(&mut self, other: Saturating<u16>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<u32>

source§

#### fn mul_assign(&mut self, other: Saturating<u32>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<u64>

source§

#### fn mul_assign(&mut self, other: Saturating<u64>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<u8>

source§

#### fn mul_assign(&mut self, other: Saturating<u8>)

Performs the `*=` operation. Read more
source§

### impl MulAssign for Saturating<usize>

source§

#### fn mul_assign(&mut self, other: Saturating<usize>)

Performs the `*=` operation. Read more
source§

### impl Neg for &Saturating<i128>

§

#### type Output = <Saturating<i128> as Neg>::Output

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> <Saturating<i128> as Neg>::Output

Performs the unary `-` operation. Read more
source§

### impl Neg for &Saturating<i16>

§

#### type Output = <Saturating<i16> as Neg>::Output

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> <Saturating<i16> as Neg>::Output

Performs the unary `-` operation. Read more
source§

### impl Neg for &Saturating<i32>

§

#### type Output = <Saturating<i32> as Neg>::Output

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> <Saturating<i32> as Neg>::Output

Performs the unary `-` operation. Read more
source§

### impl Neg for &Saturating<i64>

§

#### type Output = <Saturating<i64> as Neg>::Output

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> <Saturating<i64> as Neg>::Output

Performs the unary `-` operation. Read more
source§

### impl Neg for &Saturating<i8>

§

#### type Output = <Saturating<i8> as Neg>::Output

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> <Saturating<i8> as Neg>::Output

Performs the unary `-` operation. Read more
source§

### impl Neg for &Saturating<isize>

§

#### type Output = <Saturating<isize> as Neg>::Output

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> <Saturating<isize> as Neg>::Output

Performs the unary `-` operation. Read more
source§

### impl Neg for Saturating<i128>

§

#### type Output = Saturating<i128>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Saturating<i128>

Performs the unary `-` operation. Read more
source§

### impl Neg for Saturating<i16>

§

#### type Output = Saturating<i16>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Saturating<i16>

Performs the unary `-` operation. Read more
source§

### impl Neg for Saturating<i32>

§

#### type Output = Saturating<i32>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Saturating<i32>

Performs the unary `-` operation. Read more
source§

### impl Neg for Saturating<i64>

§

#### type Output = Saturating<i64>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Saturating<i64>

Performs the unary `-` operation. Read more
source§

### impl Neg for Saturating<i8>

§

#### type Output = Saturating<i8>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Saturating<i8>

Performs the unary `-` operation. Read more
source§

### impl Neg for Saturating<isize>

§

#### type Output = Saturating<isize>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Saturating<isize>

Performs the unary `-` operation. Read more
source§

### impl Not for &Saturating<i128>

§

#### type Output = <Saturating<i128> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<i128> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<i16>

§

#### type Output = <Saturating<i16> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<i16> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<i32>

§

#### type Output = <Saturating<i32> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<i32> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<i64>

§

#### type Output = <Saturating<i64> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<i64> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<i8>

§

#### type Output = <Saturating<i8> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<i8> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<isize>

§

#### type Output = <Saturating<isize> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<isize> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<u128>

§

#### type Output = <Saturating<u128> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<u128> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<u16>

§

#### type Output = <Saturating<u16> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<u16> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<u32>

§

#### type Output = <Saturating<u32> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<u32> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<u64>

§

#### type Output = <Saturating<u64> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<u64> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<u8>

§

#### type Output = <Saturating<u8> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<u8> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for &Saturating<usize>

§

#### type Output = <Saturating<usize> as Not>::Output

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Saturating<usize> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<i128>

§

#### type Output = Saturating<i128>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<i128>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<i16>

§

#### type Output = Saturating<i16>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<i16>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<i32>

§

#### type Output = Saturating<i32>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<i32>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<i64>

§

#### type Output = Saturating<i64>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<i64>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<i8>

§

#### type Output = Saturating<i8>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<i8>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<isize>

§

#### type Output = Saturating<isize>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<isize>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<u128>

§

#### type Output = Saturating<u128>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<u128>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<u16>

§

#### type Output = Saturating<u16>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<u16>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<u32>

§

#### type Output = Saturating<u32>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<u32>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<u64>

§

#### type Output = Saturating<u64>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<u64>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<u8>

§

#### type Output = Saturating<u8>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<u8>

Performs the unary `!` operation. Read more
source§

### impl Not for Saturating<usize>

§

#### type Output = Saturating<usize>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Saturating<usize>

Performs the unary `!` operation. Read more
source§

### impl<T> Octal for Saturating<T>where T: Octal,

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.
source§

### impl<T> Ord for Saturating<T>where T: Ord,

source§

#### fn cmp(&self, other: &Saturating<T>) -> Ordering

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · source§

#### fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

#### fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

#### fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

### impl<T> PartialEq for Saturating<T>where T: PartialEq,

source§

#### fn eq(&self, other: &Saturating<T>) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl<T> PartialOrd for Saturating<T>where T: PartialOrd,

source§

#### fn partial_cmp(&self, other: &Saturating<T>) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists. Read more
1.0.0 · source§

#### fn lt(&self, other: &Rhs) -> bool

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
1.0.0 · source§

#### fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
1.0.0 · source§

#### fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
1.0.0 · source§

#### fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
source§

### impl Rem<&Saturating<i128>> for &Saturating<i128>

§

#### type Output = <Saturating<i128> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i128>) -> <Saturating<i128> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<i128>> for Saturating<i128>

§

#### type Output = <Saturating<i128> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i128>) -> <Saturating<i128> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<i16>> for &Saturating<i16>

§

#### type Output = <Saturating<i16> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i16>) -> <Saturating<i16> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<i16>> for Saturating<i16>

§

#### type Output = <Saturating<i16> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i16>) -> <Saturating<i16> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<i32>> for &Saturating<i32>

§

#### type Output = <Saturating<i32> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i32>) -> <Saturating<i32> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<i32>> for Saturating<i32>

§

#### type Output = <Saturating<i32> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i32>) -> <Saturating<i32> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<i64>> for &Saturating<i64>

§

#### type Output = <Saturating<i64> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i64>) -> <Saturating<i64> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<i64>> for Saturating<i64>

§

#### type Output = <Saturating<i64> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i64>) -> <Saturating<i64> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<i8>> for &Saturating<i8>

§

#### type Output = <Saturating<i8> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i8>) -> <Saturating<i8> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<i8>> for Saturating<i8>

§

#### type Output = <Saturating<i8> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<i8>) -> <Saturating<i8> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<isize>> for &Saturating<isize>

§

#### type Output = <Saturating<isize> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<isize>) -> <Saturating<isize> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<isize>> for Saturating<isize>

§

#### type Output = <Saturating<isize> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<isize>) -> <Saturating<isize> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u128>> for &Saturating<u128>

§

#### type Output = <Saturating<u128> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u128>) -> <Saturating<u128> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u128>> for Saturating<u128>

§

#### type Output = <Saturating<u128> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u128>) -> <Saturating<u128> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u16>> for &Saturating<u16>

§

#### type Output = <Saturating<u16> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u16>) -> <Saturating<u16> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u16>> for Saturating<u16>

§

#### type Output = <Saturating<u16> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u16>) -> <Saturating<u16> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u32>> for &Saturating<u32>

§

#### type Output = <Saturating<u32> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u32>) -> <Saturating<u32> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u32>> for Saturating<u32>

§

#### type Output = <Saturating<u32> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u32>) -> <Saturating<u32> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u64>> for &Saturating<u64>

§

#### type Output = <Saturating<u64> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u64>) -> <Saturating<u64> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u64>> for Saturating<u64>

§

#### type Output = <Saturating<u64> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u64>) -> <Saturating<u64> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u8>> for &Saturating<u8>

§

#### type Output = <Saturating<u8> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u8>) -> <Saturating<u8> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<u8>> for Saturating<u8>

§

#### type Output = <Saturating<u8> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<u8>) -> <Saturating<u8> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<usize>> for &Saturating<usize>

§

#### type Output = <Saturating<usize> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<usize>) -> <Saturating<usize> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem<&Saturating<usize>> for Saturating<usize>

§

#### type Output = <Saturating<usize> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: &Saturating<usize>) -> <Saturating<usize> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<i128>> for &'a Saturating<i128>

§

#### type Output = <Saturating<i128> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i128>) -> <Saturating<i128> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<i16>> for &'a Saturating<i16>

§

#### type Output = <Saturating<i16> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i16>) -> <Saturating<i16> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<i32>> for &'a Saturating<i32>

§

#### type Output = <Saturating<i32> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i32>) -> <Saturating<i32> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<i64>> for &'a Saturating<i64>

§

#### type Output = <Saturating<i64> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i64>) -> <Saturating<i64> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<i8>> for &'a Saturating<i8>

§

#### type Output = <Saturating<i8> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i8>) -> <Saturating<i8> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<isize>> for &'a Saturating<isize>

§

#### type Output = <Saturating<isize> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<isize>) -> <Saturating<isize> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<u128>> for &'a Saturating<u128>

§

#### type Output = <Saturating<u128> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u128>) -> <Saturating<u128> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<u16>> for &'a Saturating<u16>

§

#### type Output = <Saturating<u16> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u16>) -> <Saturating<u16> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<u32>> for &'a Saturating<u32>

§

#### type Output = <Saturating<u32> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u32>) -> <Saturating<u32> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<u64>> for &'a Saturating<u64>

§

#### type Output = <Saturating<u64> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u64>) -> <Saturating<u64> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<u8>> for &'a Saturating<u8>

§

#### type Output = <Saturating<u8> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u8>) -> <Saturating<u8> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl<'a> Rem<Saturating<usize>> for &'a Saturating<usize>

§

#### type Output = <Saturating<usize> as Rem>::Output

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<usize>) -> <Saturating<usize> as Rem>::Output

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<i128>

§

#### type Output = Saturating<i128>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i128>) -> Saturating<i128>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<i16>

§

#### type Output = Saturating<i16>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i16>) -> Saturating<i16>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<i32>

§

#### type Output = Saturating<i32>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i32>) -> Saturating<i32>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<i64>

§

#### type Output = Saturating<i64>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i64>) -> Saturating<i64>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<i8>

§

#### type Output = Saturating<i8>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<i8>) -> Saturating<i8>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<isize>

§

#### type Output = Saturating<isize>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<isize>) -> Saturating<isize>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<u128>

§

#### type Output = Saturating<u128>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u128>) -> Saturating<u128>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<u16>

§

#### type Output = Saturating<u16>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u16>) -> Saturating<u16>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<u32>

§

#### type Output = Saturating<u32>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u32>) -> Saturating<u32>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<u64>

§

#### type Output = Saturating<u64>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u64>) -> Saturating<u64>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<u8>

§

#### type Output = Saturating<u8>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<u8>) -> Saturating<u8>

Performs the `%` operation. Read more
source§

### impl Rem for Saturating<usize>

§

#### type Output = Saturating<usize>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, other: Saturating<usize>) -> Saturating<usize>

Performs the `%` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<i128>> for Saturating<i128>

source§

#### fn rem_assign(&mut self, other: &Saturating<i128>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<i16>> for Saturating<i16>

source§

#### fn rem_assign(&mut self, other: &Saturating<i16>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<i32>> for Saturating<i32>

source§

#### fn rem_assign(&mut self, other: &Saturating<i32>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<i64>> for Saturating<i64>

source§

#### fn rem_assign(&mut self, other: &Saturating<i64>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<i8>> for Saturating<i8>

source§

#### fn rem_assign(&mut self, other: &Saturating<i8>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<isize>> for Saturating<isize>

source§

#### fn rem_assign(&mut self, other: &Saturating<isize>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<u128>> for Saturating<u128>

source§

#### fn rem_assign(&mut self, other: &Saturating<u128>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<u16>> for Saturating<u16>

source§

#### fn rem_assign(&mut self, other: &Saturating<u16>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<u32>> for Saturating<u32>

source§

#### fn rem_assign(&mut self, other: &Saturating<u32>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<u64>> for Saturating<u64>

source§

#### fn rem_assign(&mut self, other: &Saturating<u64>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<u8>> for Saturating<u8>

source§

#### fn rem_assign(&mut self, other: &Saturating<u8>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&Saturating<usize>> for Saturating<usize>

source§

#### fn rem_assign(&mut self, other: &Saturating<usize>)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&i128> for Saturating<i128>

source§

#### fn rem_assign(&mut self, other: &i128)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&i16> for Saturating<i16>

source§

#### fn rem_assign(&mut self, other: &i16)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&i32> for Saturating<i32>

source§

#### fn rem_assign(&mut self, other: &i32)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&i64> for Saturating<i64>

source§

#### fn rem_assign(&mut self, other: &i64)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&i8> for Saturating<i8>

source§

#### fn rem_assign(&mut self, other: &i8)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&isize> for Saturating<isize>

source§

#### fn rem_assign(&mut self, other: &isize)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&u128> for Saturating<u128>

source§

#### fn rem_assign(&mut self, other: &u128)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&u16> for Saturating<u16>

source§

#### fn rem_assign(&mut self, other: &u16)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&u32> for Saturating<u32>

source§

#### fn rem_assign(&mut self, other: &u32)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&u64> for Saturating<u64>

source§

#### fn rem_assign(&mut self, other: &u64)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&u8> for Saturating<u8>

source§

#### fn rem_assign(&mut self, other: &u8)

Performs the `%=` operation. Read more
1.22.0 · source§

### impl RemAssign<&usize> for Saturating<usize>

source§

#### fn rem_assign(&mut self, other: &usize)

Performs the `%=` operation. Read more
source§

### impl RemAssign<i128> for Saturating<i128>

source§

#### fn rem_assign(&mut self, other: i128)

Performs the `%=` operation. Read more
source§

### impl RemAssign<i16> for Saturating<i16>

source§

#### fn rem_assign(&mut self, other: i16)

Performs the `%=` operation. Read more
source§

### impl RemAssign<i32> for Saturating<i32>

source§

#### fn rem_assign(&mut self, other: i32)

Performs the `%=` operation. Read more
source§

### impl RemAssign<i64> for Saturating<i64>

source§

#### fn rem_assign(&mut self, other: i64)

Performs the `%=` operation. Read more
source§

### impl RemAssign<i8> for Saturating<i8>

source§

#### fn rem_assign(&mut self, other: i8)

Performs the `%=` operation. Read more
source§

### impl RemAssign<isize> for Saturating<isize>

source§

#### fn rem_assign(&mut self, other: isize)

Performs the `%=` operation. Read more
source§

### impl RemAssign<u128> for Saturating<u128>

source§

#### fn rem_assign(&mut self, other: u128)

Performs the `%=` operation. Read more
source§

### impl RemAssign<u16> for Saturating<u16>

source§

#### fn rem_assign(&mut self, other: u16)

Performs the `%=` operation. Read more
source§

### impl RemAssign<u32> for Saturating<u32>

source§

#### fn rem_assign(&mut self, other: u32)

Performs the `%=` operation. Read more
source§

### impl RemAssign<u64> for Saturating<u64>

source§

#### fn rem_assign(&mut self, other: u64)

Performs the `%=` operation. Read more
source§

### impl RemAssign<u8> for Saturating<u8>

source§

#### fn rem_assign(&mut self, other: u8)

Performs the `%=` operation. Read more
source§

### impl RemAssign<usize> for Saturating<usize>

source§

#### fn rem_assign(&mut self, other: usize)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<i128>

source§

#### fn rem_assign(&mut self, other: Saturating<i128>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<i16>

source§

#### fn rem_assign(&mut self, other: Saturating<i16>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<i32>

source§

#### fn rem_assign(&mut self, other: Saturating<i32>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<i64>

source§

#### fn rem_assign(&mut self, other: Saturating<i64>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<i8>

source§

#### fn rem_assign(&mut self, other: Saturating<i8>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<isize>

source§

#### fn rem_assign(&mut self, other: Saturating<isize>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<u128>

source§

#### fn rem_assign(&mut self, other: Saturating<u128>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<u16>

source§

#### fn rem_assign(&mut self, other: Saturating<u16>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<u32>

source§

#### fn rem_assign(&mut self, other: Saturating<u32>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<u64>

source§

#### fn rem_assign(&mut self, other: Saturating<u64>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<u8>

source§

#### fn rem_assign(&mut self, other: Saturating<u8>)

Performs the `%=` operation. Read more
source§

### impl RemAssign for Saturating<usize>

source§

#### fn rem_assign(&mut self, other: Saturating<usize>)

Performs the `%=` operation. Read more
source§

### impl Sub<&Saturating<i128>> for &Saturating<i128>

§

#### type Output = <Saturating<i128> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i128>) -> <Saturating<i128> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<i128>> for Saturating<i128>

§

#### type Output = <Saturating<i128> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i128>) -> <Saturating<i128> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<i16>> for &Saturating<i16>

§

#### type Output = <Saturating<i16> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i16>) -> <Saturating<i16> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<i16>> for Saturating<i16>

§

#### type Output = <Saturating<i16> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i16>) -> <Saturating<i16> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<i32>> for &Saturating<i32>

§

#### type Output = <Saturating<i32> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i32>) -> <Saturating<i32> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<i32>> for Saturating<i32>

§

#### type Output = <Saturating<i32> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i32>) -> <Saturating<i32> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<i64>> for &Saturating<i64>

§

#### type Output = <Saturating<i64> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i64>) -> <Saturating<i64> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<i64>> for Saturating<i64>

§

#### type Output = <Saturating<i64> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i64>) -> <Saturating<i64> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<i8>> for &Saturating<i8>

§

#### type Output = <Saturating<i8> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i8>) -> <Saturating<i8> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<i8>> for Saturating<i8>

§

#### type Output = <Saturating<i8> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<i8>) -> <Saturating<i8> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<isize>> for &Saturating<isize>

§

#### type Output = <Saturating<isize> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<isize>) -> <Saturating<isize> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<isize>> for Saturating<isize>

§

#### type Output = <Saturating<isize> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<isize>) -> <Saturating<isize> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u128>> for &Saturating<u128>

§

#### type Output = <Saturating<u128> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u128>) -> <Saturating<u128> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u128>> for Saturating<u128>

§

#### type Output = <Saturating<u128> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u128>) -> <Saturating<u128> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u16>> for &Saturating<u16>

§

#### type Output = <Saturating<u16> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u16>) -> <Saturating<u16> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u16>> for Saturating<u16>

§

#### type Output = <Saturating<u16> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u16>) -> <Saturating<u16> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u32>> for &Saturating<u32>

§

#### type Output = <Saturating<u32> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u32>) -> <Saturating<u32> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u32>> for Saturating<u32>

§

#### type Output = <Saturating<u32> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u32>) -> <Saturating<u32> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u64>> for &Saturating<u64>

§

#### type Output = <Saturating<u64> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u64>) -> <Saturating<u64> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u64>> for Saturating<u64>

§

#### type Output = <Saturating<u64> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u64>) -> <Saturating<u64> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u8>> for &Saturating<u8>

§

#### type Output = <Saturating<u8> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u8>) -> <Saturating<u8> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<u8>> for Saturating<u8>

§

#### type Output = <Saturating<u8> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<u8>) -> <Saturating<u8> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<usize>> for &Saturating<usize>

§

#### type Output = <Saturating<usize> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<usize>) -> <Saturating<usize> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub<&Saturating<usize>> for Saturating<usize>

§

#### type Output = <Saturating<usize> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: &Saturating<usize>) -> <Saturating<usize> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<i128>> for &'a Saturating<i128>

§

#### type Output = <Saturating<i128> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i128>) -> <Saturating<i128> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<i16>> for &'a Saturating<i16>

§

#### type Output = <Saturating<i16> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i16>) -> <Saturating<i16> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<i32>> for &'a Saturating<i32>

§

#### type Output = <Saturating<i32> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i32>) -> <Saturating<i32> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<i64>> for &'a Saturating<i64>

§

#### type Output = <Saturating<i64> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i64>) -> <Saturating<i64> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<i8>> for &'a Saturating<i8>

§

#### type Output = <Saturating<i8> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i8>) -> <Saturating<i8> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<isize>> for &'a Saturating<isize>

§

#### type Output = <Saturating<isize> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<isize>) -> <Saturating<isize> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<u128>> for &'a Saturating<u128>

§

#### type Output = <Saturating<u128> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u128>) -> <Saturating<u128> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<u16>> for &'a Saturating<u16>

§

#### type Output = <Saturating<u16> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u16>) -> <Saturating<u16> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<u32>> for &'a Saturating<u32>

§

#### type Output = <Saturating<u32> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u32>) -> <Saturating<u32> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<u64>> for &'a Saturating<u64>

§

#### type Output = <Saturating<u64> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u64>) -> <Saturating<u64> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<u8>> for &'a Saturating<u8>

§

#### type Output = <Saturating<u8> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u8>) -> <Saturating<u8> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl<'a> Sub<Saturating<usize>> for &'a Saturating<usize>

§

#### type Output = <Saturating<usize> as Sub>::Output

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<usize>) -> <Saturating<usize> as Sub>::Output

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<i128>

§

#### type Output = Saturating<i128>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i128>) -> Saturating<i128>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<i16>

§

#### type Output = Saturating<i16>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i16>) -> Saturating<i16>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<i32>

§

#### type Output = Saturating<i32>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i32>) -> Saturating<i32>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<i64>

§

#### type Output = Saturating<i64>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i64>) -> Saturating<i64>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<i8>

§

#### type Output = Saturating<i8>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<i8>) -> Saturating<i8>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<isize>

§

#### type Output = Saturating<isize>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<isize>) -> Saturating<isize>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<u128>

§

#### type Output = Saturating<u128>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u128>) -> Saturating<u128>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<u16>

§

#### type Output = Saturating<u16>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u16>) -> Saturating<u16>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<u32>

§

#### type Output = Saturating<u32>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u32>) -> Saturating<u32>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<u64>

§

#### type Output = Saturating<u64>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u64>) -> Saturating<u64>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<u8>

§

#### type Output = Saturating<u8>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<u8>) -> Saturating<u8>

Performs the `-` operation. Read more
source§

### impl Sub for Saturating<usize>

§

#### type Output = Saturating<usize>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Saturating<usize>) -> Saturating<usize>

Performs the `-` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<i128>> for Saturating<i128>

source§

#### fn sub_assign(&mut self, other: &Saturating<i128>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<i16>> for Saturating<i16>

source§

#### fn sub_assign(&mut self, other: &Saturating<i16>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<i32>> for Saturating<i32>

source§

#### fn sub_assign(&mut self, other: &Saturating<i32>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<i64>> for Saturating<i64>

source§

#### fn sub_assign(&mut self, other: &Saturating<i64>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<i8>> for Saturating<i8>

source§

#### fn sub_assign(&mut self, other: &Saturating<i8>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<isize>> for Saturating<isize>

source§

#### fn sub_assign(&mut self, other: &Saturating<isize>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<u128>> for Saturating<u128>

source§

#### fn sub_assign(&mut self, other: &Saturating<u128>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<u16>> for Saturating<u16>

source§

#### fn sub_assign(&mut self, other: &Saturating<u16>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<u32>> for Saturating<u32>

source§

#### fn sub_assign(&mut self, other: &Saturating<u32>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<u64>> for Saturating<u64>

source§

#### fn sub_assign(&mut self, other: &Saturating<u64>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<u8>> for Saturating<u8>

source§

#### fn sub_assign(&mut self, other: &Saturating<u8>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&Saturating<usize>> for Saturating<usize>

source§

#### fn sub_assign(&mut self, other: &Saturating<usize>)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&i128> for Saturating<i128>

source§

#### fn sub_assign(&mut self, other: &i128)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&i16> for Saturating<i16>

source§

#### fn sub_assign(&mut self, other: &i16)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&i32> for Saturating<i32>

source§

#### fn sub_assign(&mut self, other: &i32)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&i64> for Saturating<i64>

source§

#### fn sub_assign(&mut self, other: &i64)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&i8> for Saturating<i8>

source§

#### fn sub_assign(&mut self, other: &i8)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&isize> for Saturating<isize>

source§

#### fn sub_assign(&mut self, other: &isize)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&u128> for Saturating<u128>

source§

#### fn sub_assign(&mut self, other: &u128)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&u16> for Saturating<u16>

source§

#### fn sub_assign(&mut self, other: &u16)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&u32> for Saturating<u32>

source§

#### fn sub_assign(&mut self, other: &u32)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&u64> for Saturating<u64>

source§

#### fn sub_assign(&mut self, other: &u64)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&u8> for Saturating<u8>

source§

#### fn sub_assign(&mut self, other: &u8)

Performs the `-=` operation. Read more
1.22.0 · source§

### impl SubAssign<&usize> for Saturating<usize>

source§

#### fn sub_assign(&mut self, other: &usize)

Performs the `-=` operation. Read more
source§

### impl SubAssign<i128> for Saturating<i128>

source§

#### fn sub_assign(&mut self, other: i128)

Performs the `-=` operation. Read more
source§

### impl SubAssign<i16> for Saturating<i16>

source§

#### fn sub_assign(&mut self, other: i16)

Performs the `-=` operation. Read more
source§

### impl SubAssign<i32> for Saturating<i32>

source§

#### fn sub_assign(&mut self, other: i32)

Performs the `-=` operation. Read more
source§

### impl SubAssign<i64> for Saturating<i64>

source§

#### fn sub_assign(&mut self, other: i64)

Performs the `-=` operation. Read more
source§

### impl SubAssign<i8> for Saturating<i8>

source§

#### fn sub_assign(&mut self, other: i8)

Performs the `-=` operation. Read more
source§

### impl SubAssign<isize> for Saturating<isize>

source§

#### fn sub_assign(&mut self, other: isize)

Performs the `-=` operation. Read more
source§

### impl SubAssign<u128> for Saturating<u128>

source§

#### fn sub_assign(&mut self, other: u128)

Performs the `-=` operation. Read more
source§

### impl SubAssign<u16> for Saturating<u16>

source§

#### fn sub_assign(&mut self, other: u16)

Performs the `-=` operation. Read more
source§

### impl SubAssign<u32> for Saturating<u32>

source§

#### fn sub_assign(&mut self, other: u32)

Performs the `-=` operation. Read more
source§

### impl SubAssign<u64> for Saturating<u64>

source§

#### fn sub_assign(&mut self, other: u64)

Performs the `-=` operation. Read more
source§

### impl SubAssign<u8> for Saturating<u8>

source§

#### fn sub_assign(&mut self, other: u8)

Performs the `-=` operation. Read more
source§

### impl SubAssign<usize> for Saturating<usize>

source§

#### fn sub_assign(&mut self, other: usize)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<i128>

source§

#### fn sub_assign(&mut self, other: Saturating<i128>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<i16>

source§

#### fn sub_assign(&mut self, other: Saturating<i16>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<i32>

source§

#### fn sub_assign(&mut self, other: Saturating<i32>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<i64>

source§

#### fn sub_assign(&mut self, other: Saturating<i64>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<i8>

source§

#### fn sub_assign(&mut self, other: Saturating<i8>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<isize>

source§

#### fn sub_assign(&mut self, other: Saturating<isize>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<u128>

source§

#### fn sub_assign(&mut self, other: Saturating<u128>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<u16>

source§

#### fn sub_assign(&mut self, other: Saturating<u16>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<u32>

source§

#### fn sub_assign(&mut self, other: Saturating<u32>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<u64>

source§

#### fn sub_assign(&mut self, other: Saturating<u64>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<u8>

source§

#### fn sub_assign(&mut self, other: Saturating<u8>)

Performs the `-=` operation. Read more
source§

### impl SubAssign for Saturating<usize>

source§

#### fn sub_assign(&mut self, other: Saturating<usize>)

Performs the `-=` operation. Read more
source§

### impl<T> UpperHex for Saturating<T>where T: UpperHex,

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.
source§

### impl<T> Copy for Saturating<T>where T: Copy,

source§

### impl<T> Eq for Saturating<T>where T: Eq,

source§

### impl<T> StructuralEq for Saturating<T>

source§

### impl<T> StructuralPartialEq for Saturating<T>

## Auto Trait Implementations§

§

### impl<T> RefUnwindSafe for Saturating<T>where T: RefUnwindSafe,

§

### impl<T> Send for Saturating<T>where T: Send,

§

### impl<T> Sync for Saturating<T>where T: Sync,

§

### impl<T> Unpin for Saturating<T>where T: Unpin,

§

### impl<T> UnwindSafe for Saturating<T>where T: UnwindSafe,

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T> ToString for Twhere T: Display + ?Sized,

source§

#### default fn to_string(&self) -> String

Converts the given value to a `String`. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.