Primitive Type usize []

Operations and constants for pointer-sized unsigned integers (usize type)

This type was recently added to replace uint. The rollout of the new type will gradually take place over the alpha cycle along with the development of clearer conventions around integer types.

Methods

impl usize

fn min_value() -> usize

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

fn max_value() -> usize

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

fn from_str_radix(src: &str, radix: u32) -> Result<usize, ParseIntError>

Converts a string slice in a given base to an integer.

Leading and trailing whitespace represent an error.

Arguments

  • src - A string slice
  • radix - The base to use. Must lie in the range [2 .. 36]

Return value

Err(ParseIntError) if the string did not represent a valid number. Otherwise, Ok(n) where n is the integer represented by src.

fn count_ones(self) -> u32

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

Examples

fn main() { let n = 0b01001100u8; assert_eq!(n.count_ones(), 3); }
let n = 0b01001100u8;

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

fn count_zeros(self) -> u32

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

Examples

fn main() { let n = 0b01001100u8; assert_eq!(n.count_zeros(), 5); }
let n = 0b01001100u8;

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

fn leading_zeros(self) -> u32

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

Examples

fn main() { let n = 0b0101000u16; assert_eq!(n.leading_zeros(), 10); }
let n = 0b0101000u16;

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

fn trailing_zeros(self) -> u32

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

Examples

fn main() { let n = 0b0101000u16; assert_eq!(n.trailing_zeros(), 3); }
let n = 0b0101000u16;

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

fn rotate_left(self, n: u32) -> usize

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

Examples

fn main() { let n = 0x0123456789ABCDEFu64; let m = 0x3456789ABCDEF012u64; assert_eq!(n.rotate_left(12), m); }
let n = 0x0123456789ABCDEFu64;
let m = 0x3456789ABCDEF012u64;

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

fn rotate_right(self, n: u32) -> usize

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

Examples

fn main() { let n = 0x0123456789ABCDEFu64; let m = 0xDEF0123456789ABCu64; assert_eq!(n.rotate_right(12), m); }
let n = 0x0123456789ABCDEFu64;
let m = 0xDEF0123456789ABCu64;

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

fn swap_bytes(self) -> usize

Reverses the byte order of the integer.

Examples

fn main() { let n = 0x0123456789ABCDEFu64; let m = 0xEFCDAB8967452301u64; assert_eq!(n.swap_bytes(), m); }
let n = 0x0123456789ABCDEFu64;
let m = 0xEFCDAB8967452301u64;

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

fn from_be(x: usize) -> 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

fn main() { let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "big") { assert_eq!(u64::from_be(n), n) } else { assert_eq!(u64::from_be(n), n.swap_bytes()) } }
let n = 0x0123456789ABCDEFu64;

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

fn from_le(x: usize) -> 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

fn main() { let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "little") { assert_eq!(u64::from_le(n), n) } else { assert_eq!(u64::from_le(n), n.swap_bytes()) } }
let n = 0x0123456789ABCDEFu64;

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

fn to_be(self) -> 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

fn main() { let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) } }
let n = 0x0123456789ABCDEFu64;

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

fn to_le(self) -> 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

fn main() { let n = 0x0123456789ABCDEFu64; if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) } }
let n = 0x0123456789ABCDEFu64;

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

fn checked_add(self, other: usize) -> Option<usize>

Checked integer addition. Computes self + other, returning None if overflow occurred.

Examples

fn main() { assert_eq!(5u16.checked_add(65530), Some(65535)); assert_eq!(6u16.checked_add(65530), None); }
assert_eq!(5u16.checked_add(65530), Some(65535));
assert_eq!(6u16.checked_add(65530), None);

fn checked_sub(self, other: usize) -> Option<usize>

Checked integer subtraction. Computes self - other, returning None if underflow occurred.

Examples

fn main() { assert_eq!((-127i8).checked_sub(1), Some(-128)); assert_eq!((-128i8).checked_sub(1), None); }
assert_eq!((-127i8).checked_sub(1), Some(-128));
assert_eq!((-128i8).checked_sub(1), None);

fn checked_mul(self, other: usize) -> Option<usize>

Checked integer multiplication. Computes self * other, returning None if underflow or overflow occurred.

Examples

fn main() { assert_eq!(5u8.checked_mul(51), Some(255)); assert_eq!(5u8.checked_mul(52), None); }
assert_eq!(5u8.checked_mul(51), Some(255));
assert_eq!(5u8.checked_mul(52), None);

fn checked_div(self, v: usize) -> Option<usize>

Checked integer division. Computes self / other, returning None if other == 0 or the operation results in underflow or overflow.

Examples

fn main() { assert_eq!((-127i8).checked_div(-1), Some(127)); assert_eq!((-128i8).checked_div(-1), None); assert_eq!((1i8).checked_div(0), None); }
assert_eq!((-127i8).checked_div(-1), Some(127));
assert_eq!((-128i8).checked_div(-1), None);
assert_eq!((1i8).checked_div(0), None);

fn saturating_add(self, other: usize) -> usize

Saturating integer addition. Computes self + other, saturating at the numeric bounds instead of overflowing.

fn saturating_sub(self, other: usize) -> usize

Saturating integer subtraction. Computes self - other, saturating at the numeric bounds instead of overflowing.

fn wrapping_add(self, rhs: usize) -> usize

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

fn wrapping_sub(self, rhs: usize) -> usize

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

fn wrapping_mul(self, rhs: usize) -> usize

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

fn wrapping_div(self, rhs: usize) -> usize

Unstable

Wrapping (modular) division. Computes floor(self / other), wrapping around at the boundary of the type.

The only case where such wrapping can occur is when one divides MIN / -1 on a signed type (where MIN is the negative minimal value for the type); this is equivalent to -MIN, a positive value that is too large to represent in the type. In such a case, this function returns MIN itself..

fn wrapping_rem(self, rhs: usize) -> usize

Unstable

Wrapping (modular) remainder. Computes self % other, wrapping around at the boundary of the type.

Such wrap-around never actually occurs mathematically; implementation artifacts make x % y illegal for MIN / -1 on a signed type illegal (where MIN is the negative minimal value). In such a case, this function returns 0.

fn wrapping_neg(self) -> usize

Unstable

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.

The only case where such wrapping can occur is when one negates MIN on a signed type (where MIN is the negative minimal value for the type); this is a positive value that is too large to represent in the type. In such a case, this function returns MIN itself.

fn wrapping_shl(self, rhs: u32) -> usize

Unstable

Panic-free bitwise shift-left; yields self << mask(rhs), where mask removes any high-order bits of rhs that would cause the shift to exceed the bitwidth of the type.

fn wrapping_shr(self, rhs: u32) -> usize

Unstable

Panic-free bitwise shift-left; yields self >> mask(rhs), where mask removes any high-order bits of rhs that would cause the shift to exceed the bitwidth of the type.

fn pow(self, exp: u32) -> usize

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

Examples

fn main() { assert_eq!(2i32.pow(4), 16); }
assert_eq!(2i32.pow(4), 16);

fn is_power_of_two(self) -> bool

Returns true iff self == 2^k for some k.

fn next_power_of_two(self) -> usize

Returns the smallest power of two greater than or equal to self. Unspecified behavior on overflow.

fn checked_next_power_of_two(self) -> Option<usize>

Returns the smallest power of two greater than or equal to n. If the next power of two is greater than the type's maximum value, None is returned, otherwise the power of two is wrapped in Some.

Trait Implementations

impl OverflowingOps for usize

fn overflowing_add(self, rhs: usize) -> (usize, bool)

fn overflowing_sub(self, rhs: usize) -> (usize, bool)

fn overflowing_mul(self, rhs: usize) -> (usize, bool)

fn overflowing_div(self, rhs: usize) -> (usize, bool)

fn overflowing_rem(self, rhs: usize) -> (usize, bool)

fn overflowing_neg(self) -> (usize, bool)

fn overflowing_shl(self, rhs: u32) -> (usize, bool)

fn overflowing_shr(self, rhs: u32) -> (usize, bool)

impl Zero for usize

fn zero() -> usize

impl One for usize

fn one() -> usize

impl FromStr for usize

type Err = ParseIntError

fn from_str(src: &str) -> Result<usize, ParseIntError>

impl Zeroable for usize

impl Add<usize> for usize

type Output = usize

fn add(self, other: usize) -> usize

impl<'a> Add<usize> for &'a usize

type Output = usize::Output

fn add(self, other: usize) -> usize::Output

impl<'a> Add<&'a usize> for usize

type Output = usize::Output

fn add(self, other: &'a usize) -> usize::Output

impl<'a, 'b> Add<&'a usize> for &'b usize

type Output = usize::Output

fn add(self, other: &'a usize) -> usize::Output

impl Sub<usize> for usize

type Output = usize

fn sub(self, other: usize) -> usize

impl<'a> Sub<usize> for &'a usize

type Output = usize::Output

fn sub(self, other: usize) -> usize::Output

impl<'a> Sub<&'a usize> for usize

type Output = usize::Output

fn sub(self, other: &'a usize) -> usize::Output

impl<'a, 'b> Sub<&'a usize> for &'b usize

type Output = usize::Output

fn sub(self, other: &'a usize) -> usize::Output

impl Mul<usize> for usize

type Output = usize

fn mul(self, other: usize) -> usize

impl<'a> Mul<usize> for &'a usize

type Output = usize::Output

fn mul(self, other: usize) -> usize::Output

impl<'a> Mul<&'a usize> for usize

type Output = usize::Output

fn mul(self, other: &'a usize) -> usize::Output

impl<'a, 'b> Mul<&'a usize> for &'b usize

type Output = usize::Output

fn mul(self, other: &'a usize) -> usize::Output

impl Div<usize> for usize

type Output = usize

fn div(self, other: usize) -> usize

impl<'a> Div<usize> for &'a usize

type Output = usize::Output

fn div(self, other: usize) -> usize::Output

impl<'a> Div<&'a usize> for usize

type Output = usize::Output

fn div(self, other: &'a usize) -> usize::Output

impl<'a, 'b> Div<&'a usize> for &'b usize

type Output = usize::Output

fn div(self, other: &'a usize) -> usize::Output

impl Rem<usize> for usize

type Output = usize

fn rem(self, other: usize) -> usize

impl<'a> Rem<usize> for &'a usize

type Output = usize::Output

fn rem(self, other: usize) -> usize::Output

impl<'a> Rem<&'a usize> for usize

type Output = usize::Output

fn rem(self, other: &'a usize) -> usize::Output

impl<'a, 'b> Rem<&'a usize> for &'b usize

type Output = usize::Output

fn rem(self, other: &'a usize) -> usize::Output

impl Not for usize

type Output = usize

fn not(self) -> usize

impl<'a> Not for &'a usize

type Output = usize::Output

fn not(self) -> usize::Output

impl BitAnd<usize> for usize

type Output = usize

fn bitand(self, rhs: usize) -> usize

impl<'a> BitAnd<usize> for &'a usize

type Output = usize::Output

fn bitand(self, other: usize) -> usize::Output

impl<'a> BitAnd<&'a usize> for usize

type Output = usize::Output

fn bitand(self, other: &'a usize) -> usize::Output

impl<'a, 'b> BitAnd<&'a usize> for &'b usize

type Output = usize::Output

fn bitand(self, other: &'a usize) -> usize::Output

impl BitOr<usize> for usize

type Output = usize

fn bitor(self, rhs: usize) -> usize

impl<'a> BitOr<usize> for &'a usize

type Output = usize::Output

fn bitor(self, other: usize) -> usize::Output

impl<'a> BitOr<&'a usize> for usize

type Output = usize::Output

fn bitor(self, other: &'a usize) -> usize::Output

impl<'a, 'b> BitOr<&'a usize> for &'b usize

type Output = usize::Output

fn bitor(self, other: &'a usize) -> usize::Output

impl BitXor<usize> for usize

type Output = usize

fn bitxor(self, other: usize) -> usize

impl<'a> BitXor<usize> for &'a usize

type Output = usize::Output

fn bitxor(self, other: usize) -> usize::Output

impl<'a> BitXor<&'a usize> for usize

type Output = usize::Output

fn bitxor(self, other: &'a usize) -> usize::Output

impl<'a, 'b> BitXor<&'a usize> for &'b usize

type Output = usize::Output

fn bitxor(self, other: &'a usize) -> usize::Output

impl Shl<u8> for usize

type Output = usize

fn shl(self, other: u8) -> usize

impl<'a> Shl<u8> for &'a usize

type Output = usize::Output

fn shl(self, other: u8) -> usize::Output

impl<'a> Shl<&'a u8> for usize

type Output = usize::Output

fn shl(self, other: &'a u8) -> usize::Output

impl<'a, 'b> Shl<&'a u8> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a u8) -> usize::Output

impl Shl<u16> for usize

type Output = usize

fn shl(self, other: u16) -> usize

impl<'a> Shl<u16> for &'a usize

type Output = usize::Output

fn shl(self, other: u16) -> usize::Output

impl<'a> Shl<&'a u16> for usize

type Output = usize::Output

fn shl(self, other: &'a u16) -> usize::Output

impl<'a, 'b> Shl<&'a u16> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a u16) -> usize::Output

impl Shl<u32> for usize

type Output = usize

fn shl(self, other: u32) -> usize

impl<'a> Shl<u32> for &'a usize

type Output = usize::Output

fn shl(self, other: u32) -> usize::Output

impl<'a> Shl<&'a u32> for usize

type Output = usize::Output

fn shl(self, other: &'a u32) -> usize::Output

impl<'a, 'b> Shl<&'a u32> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a u32) -> usize::Output

impl Shl<u64> for usize

type Output = usize

fn shl(self, other: u64) -> usize

impl<'a> Shl<u64> for &'a usize

type Output = usize::Output

fn shl(self, other: u64) -> usize::Output

impl<'a> Shl<&'a u64> for usize

type Output = usize::Output

fn shl(self, other: &'a u64) -> usize::Output

impl<'a, 'b> Shl<&'a u64> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a u64) -> usize::Output

impl Shl<usize> for usize

type Output = usize

fn shl(self, other: usize) -> usize

impl<'a> Shl<usize> for &'a usize

type Output = usize::Output

fn shl(self, other: usize) -> usize::Output

impl<'a> Shl<&'a usize> for usize

type Output = usize::Output

fn shl(self, other: &'a usize) -> usize::Output

impl<'a, 'b> Shl<&'a usize> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a usize) -> usize::Output

impl Shl<i8> for usize

type Output = usize

fn shl(self, other: i8) -> usize

impl<'a> Shl<i8> for &'a usize

type Output = usize::Output

fn shl(self, other: i8) -> usize::Output

impl<'a> Shl<&'a i8> for usize

type Output = usize::Output

fn shl(self, other: &'a i8) -> usize::Output

impl<'a, 'b> Shl<&'a i8> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a i8) -> usize::Output

impl Shl<i16> for usize

type Output = usize

fn shl(self, other: i16) -> usize

impl<'a> Shl<i16> for &'a usize

type Output = usize::Output

fn shl(self, other: i16) -> usize::Output

impl<'a> Shl<&'a i16> for usize

type Output = usize::Output

fn shl(self, other: &'a i16) -> usize::Output

impl<'a, 'b> Shl<&'a i16> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a i16) -> usize::Output

impl Shl<i32> for usize

type Output = usize

fn shl(self, other: i32) -> usize

impl<'a> Shl<i32> for &'a usize

type Output = usize::Output

fn shl(self, other: i32) -> usize::Output

impl<'a> Shl<&'a i32> for usize

type Output = usize::Output

fn shl(self, other: &'a i32) -> usize::Output

impl<'a, 'b> Shl<&'a i32> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a i32) -> usize::Output

impl Shl<i64> for usize

type Output = usize

fn shl(self, other: i64) -> usize

impl<'a> Shl<i64> for &'a usize

type Output = usize::Output

fn shl(self, other: i64) -> usize::Output

impl<'a> Shl<&'a i64> for usize

type Output = usize::Output

fn shl(self, other: &'a i64) -> usize::Output

impl<'a, 'b> Shl<&'a i64> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a i64) -> usize::Output

impl Shl<isize> for usize

type Output = usize

fn shl(self, other: isize) -> usize

impl<'a> Shl<isize> for &'a usize

type Output = usize::Output

fn shl(self, other: isize) -> usize::Output

impl<'a> Shl<&'a isize> for usize

type Output = usize::Output

fn shl(self, other: &'a isize) -> usize::Output

impl<'a, 'b> Shl<&'a isize> for &'b usize

type Output = usize::Output

fn shl(self, other: &'a isize) -> usize::Output

impl Shr<u8> for usize

type Output = usize

fn shr(self, other: u8) -> usize

impl<'a> Shr<u8> for &'a usize

type Output = usize::Output

fn shr(self, other: u8) -> usize::Output

impl<'a> Shr<&'a u8> for usize

type Output = usize::Output

fn shr(self, other: &'a u8) -> usize::Output

impl<'a, 'b> Shr<&'a u8> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a u8) -> usize::Output

impl Shr<u16> for usize

type Output = usize

fn shr(self, other: u16) -> usize

impl<'a> Shr<u16> for &'a usize

type Output = usize::Output

fn shr(self, other: u16) -> usize::Output

impl<'a> Shr<&'a u16> for usize

type Output = usize::Output

fn shr(self, other: &'a u16) -> usize::Output

impl<'a, 'b> Shr<&'a u16> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a u16) -> usize::Output

impl Shr<u32> for usize

type Output = usize

fn shr(self, other: u32) -> usize

impl<'a> Shr<u32> for &'a usize

type Output = usize::Output

fn shr(self, other: u32) -> usize::Output

impl<'a> Shr<&'a u32> for usize

type Output = usize::Output

fn shr(self, other: &'a u32) -> usize::Output

impl<'a, 'b> Shr<&'a u32> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a u32) -> usize::Output

impl Shr<u64> for usize

type Output = usize

fn shr(self, other: u64) -> usize

impl<'a> Shr<u64> for &'a usize

type Output = usize::Output

fn shr(self, other: u64) -> usize::Output

impl<'a> Shr<&'a u64> for usize

type Output = usize::Output

fn shr(self, other: &'a u64) -> usize::Output

impl<'a, 'b> Shr<&'a u64> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a u64) -> usize::Output

impl Shr<usize> for usize

type Output = usize

fn shr(self, other: usize) -> usize

impl<'a> Shr<usize> for &'a usize

type Output = usize::Output

fn shr(self, other: usize) -> usize::Output

impl<'a> Shr<&'a usize> for usize

type Output = usize::Output

fn shr(self, other: &'a usize) -> usize::Output

impl<'a, 'b> Shr<&'a usize> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a usize) -> usize::Output

impl Shr<i8> for usize

type Output = usize

fn shr(self, other: i8) -> usize

impl<'a> Shr<i8> for &'a usize

type Output = usize::Output

fn shr(self, other: i8) -> usize::Output

impl<'a> Shr<&'a i8> for usize

type Output = usize::Output

fn shr(self, other: &'a i8) -> usize::Output

impl<'a, 'b> Shr<&'a i8> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a i8) -> usize::Output

impl Shr<i16> for usize

type Output = usize

fn shr(self, other: i16) -> usize

impl<'a> Shr<i16> for &'a usize

type Output = usize::Output

fn shr(self, other: i16) -> usize::Output

impl<'a> Shr<&'a i16> for usize

type Output = usize::Output

fn shr(self, other: &'a i16) -> usize::Output

impl<'a, 'b> Shr<&'a i16> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a i16) -> usize::Output

impl Shr<i32> for usize

type Output = usize

fn shr(self, other: i32) -> usize

impl<'a> Shr<i32> for &'a usize

type Output = usize::Output

fn shr(self, other: i32) -> usize::Output

impl<'a> Shr<&'a i32> for usize

type Output = usize::Output

fn shr(self, other: &'a i32) -> usize::Output

impl<'a, 'b> Shr<&'a i32> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a i32) -> usize::Output

impl Shr<i64> for usize

type Output = usize

fn shr(self, other: i64) -> usize

impl<'a> Shr<i64> for &'a usize

type Output = usize::Output

fn shr(self, other: i64) -> usize::Output

impl<'a> Shr<&'a i64> for usize

type Output = usize::Output

fn shr(self, other: &'a i64) -> usize::Output

impl<'a, 'b> Shr<&'a i64> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a i64) -> usize::Output

impl Shr<isize> for usize

type Output = usize

fn shr(self, other: isize) -> usize

impl<'a> Shr<isize> for &'a usize

type Output = usize::Output

fn shr(self, other: isize) -> usize::Output

impl<'a> Shr<&'a isize> for usize

type Output = usize::Output

fn shr(self, other: &'a isize) -> usize::Output

impl<'a, 'b> Shr<&'a isize> for &'b usize

type Output = usize::Output

fn shr(self, other: &'a isize) -> usize::Output

impl PartialEq<usize> for usize

fn eq(&self, other: &usize) -> bool

fn ne(&self, other: &usize) -> bool

impl Eq for usize

impl PartialOrd<usize> for usize

fn partial_cmp(&self, other: &usize) -> Option<Ordering>

fn lt(&self, other: &usize) -> bool

fn le(&self, other: &usize) -> bool

fn ge(&self, other: &usize) -> bool

fn gt(&self, other: &usize) -> bool

impl Ord for usize

fn cmp(&self, other: &usize) -> Ordering

impl Clone for usize

fn clone(&self) -> usize

fn clone_from(&mut self, source: &Self)

impl Default for usize

fn default() -> usize

impl Step for usize

fn step(&self, by: &usize) -> Option<usize>

fn steps_between(start: &usize, end: &usize, by: &usize) -> Option<usize>

impl Hash for usize

fn hash<H>(&self, state: &mut H) where H: Hasher

fn hash_slice<H>(data: &[usize], state: &mut H) where H: Hasher

impl Display for usize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Binary for usize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Octal for usize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl LowerHex for usize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl UpperHex for usize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for usize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl SampleRange for usize

fn construct_range(low: usize, high: usize) -> Range<usize>

fn sample_range<R>(r: &Range<usize>, rng: &mut R) -> usize where R: Rng

impl Rand for usize

fn rand<R>(rng: &mut R) -> usize where R: Rng