Primitive Type isize
Operations and constants for pointer-sized signed integers (isize type)
This type was recently added to replace int. 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 isize
fn min_value() -> isize
Returns the smallest value that can be represented by this integer type.
fn max_value() -> isize
Returns the largest value that can be represented by this integer type.
fn from_str_radix(src: &str, radix: u32) -> Result<isize, 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) -> isize
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) -> isize
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) -> isize
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: isize) -> 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
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: isize) -> 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
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) -> 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
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) -> 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
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: isize) -> Option<isize>
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: isize) -> Option<isize>
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: isize) -> Option<isize>
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: isize) -> Option<isize>
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: isize) -> isize
Saturating integer addition. Computes self + other, saturating at
the numeric bounds instead of overflowing.
fn saturating_sub(self, other: isize) -> isize
Saturating integer subtraction. Computes self - other, saturating
at the numeric bounds instead of overflowing.
fn wrapping_add(self, rhs: isize) -> isize
Wrapping (modular) addition. Computes self + other,
wrapping around at the boundary of the type.
fn wrapping_sub(self, rhs: isize) -> isize
Wrapping (modular) subtraction. Computes self - other,
wrapping around at the boundary of the type.
fn wrapping_mul(self, rhs: isize) -> isize
Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.
fn pow(self, exp: u32) -> isize
Raises self to the power of exp, using exponentiation by squaring.
Examples
fn main() { let x: i32 = 2; // or any other integer type assert_eq!(x.pow(4), 16); }let x: i32 = 2; // or any other integer type assert_eq!(x.pow(4), 16);
fn abs(self) -> isize
Computes the absolute value of self. Int::min_value() will be
returned if the number is Int::min_value().
fn signum(self) -> isize
Returns a number representing sign of self.
0if the number is zero1if the number is positive-1if the number is negative
fn is_positive(self) -> bool
Returns true if self is positive and false if the number
is zero or negative.
fn is_negative(self) -> bool
Returns true if self is negative and false if the number
is zero or positive.