# Primitive Type i8 [−]

Operations and constants for signed 8-bits integers (i8 type)

## Methods

### impl i8

#### fn min_value() -> i8

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

#### fn max_value() -> i8

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

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

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;

#### 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) -> i8

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

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

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

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

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

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

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

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

# Examples

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

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

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

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

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

#### fn saturating_sub(self, other: i8) -> i8

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

#### fn wrapping_add(self, rhs: i8) -> i8

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

#### fn wrapping_sub(self, rhs: i8) -> i8

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

#### fn wrapping_mul(self, rhs: i8) -> i8

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

#### fn wrapping_div(self, rhs: i8) -> i8

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

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

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

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

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

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

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.

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

#### 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.