Primitive Type i32 []

The 32-bit signed integer type.

See also the std::i32 module.

Methods

impl i32

const fn min_value() -> i32

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

const fn max_value() -> i32

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

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

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

Leading and trailing whitespace represent an error.

Examples

Basic usage:

fn main() { assert_eq!(u32::from_str_radix("A", 16), Ok(10)); }
assert_eq!(u32::from_str_radix("A", 16), Ok(10));

fn count_ones(self) -> u32

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

Examples

Basic usage:

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

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

fn count_zeros(self) -> u32

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

Examples

Basic usage:

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

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

fn leading_zeros(self) -> u32

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

Examples

Basic usage:

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

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

fn trailing_zeros(self) -> u32

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

Examples

Basic usage:

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

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

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

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

Examples

Basic usage:

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

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

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

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

Examples

Basic usage:

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

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

fn swap_bytes(self) -> i32

Reverses the byte order of the integer.

Examples

Basic usage:

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

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

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

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: i32) -> 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:

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) -> 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:

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) -> 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:

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: i32) -> Option<i32>

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

Examples

Basic usage:

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

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

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

Examples

Basic usage:

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

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

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

Examples

Basic usage:

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

fn checked_div(self, other: i32) -> Option<i32>

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

Examples

Basic usage:

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

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

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

Examples

Basic usage:

fn main() { assert_eq!(100i8.saturating_add(1), 101); assert_eq!(100i8.saturating_add(127), 127); }
assert_eq!(100i8.saturating_add(1), 101);
assert_eq!(100i8.saturating_add(127), 127);

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

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

Examples

Basic usage:

fn main() { assert_eq!(100i8.saturating_sub(127), -27); assert_eq!((-100i8).saturating_sub(127), -128); }
assert_eq!(100i8.saturating_sub(127), -27);
assert_eq!((-100i8).saturating_sub(127), -128);

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

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

Examples

Basic usage:

fn main() { assert_eq!(100i8.wrapping_add(27), 127); assert_eq!(100i8.wrapping_add(127), -29); }
assert_eq!(100i8.wrapping_add(27), 127);
assert_eq!(100i8.wrapping_add(127), -29);

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

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

Examples

Basic usage:

fn main() { assert_eq!(0i8.wrapping_sub(127), -127); assert_eq!((-2i8).wrapping_sub(127), 127); }
assert_eq!(0i8.wrapping_sub(127), -127);
assert_eq!((-2i8).wrapping_sub(127), 127);

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

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

Examples

Basic usage:

fn main() { assert_eq!(10i8.wrapping_mul(12), 120); assert_eq!(11i8.wrapping_mul(12), -124); }
assert_eq!(10i8.wrapping_mul(12), 120);
assert_eq!(11i8.wrapping_mul(12), -124);

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

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

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

Examples

Basic usage:

fn main() { assert_eq!(100u8.wrapping_div(10), 10); assert_eq!((-128i8).wrapping_div(-1), -128); }
assert_eq!(100u8.wrapping_div(10), 10);
assert_eq!((-128i8).wrapping_div(-1), -128);

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

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

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

Examples

Basic usage:

fn main() { assert_eq!(100i8.wrapping_rem(10), 0); assert_eq!((-128i8).wrapping_rem(-1), 0); }
assert_eq!(100i8.wrapping_rem(10), 0);
assert_eq!((-128i8).wrapping_rem(-1), 0);

fn wrapping_neg(self) -> i32

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

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

Examples

Basic usage:

fn main() { assert_eq!(100i8.wrapping_neg(), -100); assert_eq!((-128i8).wrapping_neg(), -128); }
assert_eq!(100i8.wrapping_neg(), -100);
assert_eq!((-128i8).wrapping_neg(), -128);

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

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

Examples

Basic usage:

fn main() { assert_eq!(1u8.wrapping_shl(7), 128); assert_eq!(1u8.wrapping_shl(8), 1); }
assert_eq!(1u8.wrapping_shl(7), 128);
assert_eq!(1u8.wrapping_shl(8), 1);

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

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

Examples

Basic usage:

fn main() { assert_eq!(128u8.wrapping_shr(7), 1); assert_eq!(128u8.wrapping_shr(8), 128); }
assert_eq!(128u8.wrapping_shr(7), 1);
assert_eq!(128u8.wrapping_shr(8), 128);

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

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

Examples

Basic usage:

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) -> i32

Computes the absolute value of self.

Overflow behavior

The absolute value of i32::min_value() cannot be represented as an i32, and attempting to calculate it will cause an overflow. This means that code in debug mode will trigger a panic on this case and optimized code will return i32::min_value() without a panic.

Examples

Basic usage:

fn main() { assert_eq!(10i8.abs(), 10); assert_eq!((-10i8).abs(), 10); }
assert_eq!(10i8.abs(), 10);
assert_eq!((-10i8).abs(), 10);

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

fn main() { assert_eq!(10i8.signum(), 1); assert_eq!(0i8.signum(), 0); assert_eq!((-10i8).signum(), -1); }
assert_eq!(10i8.signum(), 1);
assert_eq!(0i8.signum(), 0);
assert_eq!((-10i8).signum(), -1);

fn is_positive(self) -> bool

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

Examples

Basic usage:

fn main() { assert!(10i8.is_positive()); assert!(!(-10i8).is_positive()); }
assert!(10i8.is_positive());
assert!(!(-10i8).is_positive());

fn is_negative(self) -> bool

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

Examples

Basic usage:

fn main() { assert!((-10i8).is_negative()); assert!(!10i8.is_negative()); }
assert!((-10i8).is_negative());
assert!(!10i8.is_negative());

Trait Implementations

impl OverflowingOps for i32

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

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

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

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

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

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

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

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

impl Zero for i32

fn zero() -> i32

impl One for i32

fn one() -> i32

impl FromStr for i32

type Err = ParseIntError

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

impl From<i8> for i32

fn from(small: i8) -> i32

impl From<i16> for i32

fn from(small: i16) -> i32

impl From<u8> for i32

fn from(small: u8) -> i32

impl From<u16> for i32

fn from(small: u16) -> i32

impl Zeroable for i32

impl Add<i32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Sub<i32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Mul<i32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Div<i32> for i32

This operation rounds towards zero, truncating any fractional part of the exact result.

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Rem<i32> for i32

This operation satisfies n % d == n - (n / d) * d. The result has the same sign as the left operand.

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Neg for i32

type Output = i32

fn neg(self) -> i32

impl<'a> Neg for &'a i32

type Output = i32::Output

fn neg(self) -> i32::Output

impl Not for i32

type Output = i32

fn not(self) -> i32

impl<'a> Not for &'a i32

type Output = i32::Output

fn not(self) -> i32::Output

impl BitAnd<i32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl BitOr<i32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl BitXor<i32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<u8> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<u16> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<u32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<u64> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<usize> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<i8> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<i16> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<i32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<i64> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shl<isize> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<u8> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<u16> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<u32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<u64> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<usize> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<i8> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<i16> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<i32> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<i64> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl Shr<isize> for i32

type Output = i32

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

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

type Output = i32::Output

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

impl AddAssign<i32> for i32

fn add_assign(&mut self, other: i32)

impl SubAssign<i32> for i32

fn sub_assign(&mut self, other: i32)

impl MulAssign<i32> for i32

fn mul_assign(&mut self, other: i32)

impl DivAssign<i32> for i32

fn div_assign(&mut self, other: i32)

impl RemAssign<i32> for i32

fn rem_assign(&mut self, other: i32)

impl BitAndAssign<i32> for i32

fn bitand_assign(&mut self, other: i32)

impl BitOrAssign<i32> for i32

fn bitor_assign(&mut self, other: i32)

impl BitXorAssign<i32> for i32

fn bitxor_assign(&mut self, other: i32)

impl ShlAssign<u8> for i32

fn shl_assign(&mut self, other: u8)

impl ShlAssign<u16> for i32

fn shl_assign(&mut self, other: u16)

impl ShlAssign<u32> for i32

fn shl_assign(&mut self, other: u32)

impl ShlAssign<u64> for i32

fn shl_assign(&mut self, other: u64)

impl ShlAssign<usize> for i32

fn shl_assign(&mut self, other: usize)

impl ShlAssign<i8> for i32

fn shl_assign(&mut self, other: i8)

impl ShlAssign<i16> for i32

fn shl_assign(&mut self, other: i16)

impl ShlAssign<i32> for i32

fn shl_assign(&mut self, other: i32)

impl ShlAssign<i64> for i32

fn shl_assign(&mut self, other: i64)

impl ShlAssign<isize> for i32

fn shl_assign(&mut self, other: isize)

impl ShrAssign<u8> for i32

fn shr_assign(&mut self, other: u8)

impl ShrAssign<u16> for i32

fn shr_assign(&mut self, other: u16)

impl ShrAssign<u32> for i32

fn shr_assign(&mut self, other: u32)

impl ShrAssign<u64> for i32

fn shr_assign(&mut self, other: u64)

impl ShrAssign<usize> for i32

fn shr_assign(&mut self, other: usize)

impl ShrAssign<i8> for i32

fn shr_assign(&mut self, other: i8)

impl ShrAssign<i16> for i32

fn shr_assign(&mut self, other: i16)

impl ShrAssign<i32> for i32

fn shr_assign(&mut self, other: i32)

impl ShrAssign<i64> for i32

fn shr_assign(&mut self, other: i64)

impl ShrAssign<isize> for i32

fn shr_assign(&mut self, other: isize)

impl PartialEq<i32> for i32

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

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

impl Eq for i32

impl PartialOrd<i32> for i32

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

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

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

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

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

impl Ord for i32

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

impl Clone for i32

fn clone(&self) -> i32

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

impl Default for i32

fn default() -> i32

impl Step for i32

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

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

impl Hash for i32

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

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

impl Binary for i32

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

impl Octal for i32

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

impl LowerHex for i32

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

impl UpperHex for i32

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

impl Debug for i32

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

impl Display for i32

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