The smallest value that can be represented by this integer type(−2⁷).

§Examples

assert_eq!(i8::MIN, -128);

The largest value that can be represented by this integer type(2⁷ − 1).

§Examples

assert_eq!(i8::MAX,127);

The size of this integer type in bits.

§Examples

assert_eq!(i8::BITS,8);

Returns the number of ones in the binary representation ofself.

§Examples

letn =0b100_0000i8;assert_eq!(n.count_ones(),1);

Returns the number of zeros in the binary representation ofself.

§Examples

assert_eq!(i8::MAX.count_zeros(),1);

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

Depending on what you’re doing with the value, you might also be interested in theilog2 function which returns a consistent number, even if the type widens.

§Examples

letn = -1i8;assert_eq!(n.leading_zeros(),0);

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

§Examples

letn = -4i8;assert_eq!(n.trailing_zeros(),2);

Returns the number of leading ones in the binary representation ofself.

§Examples

letn = -1i8;assert_eq!(n.leading_ones(),8);

Returns the number of trailing ones in the binary representation ofself.

§Examples

letn =3i8;assert_eq!(n.trailing_ones(),2);

Returnsself with only the most significant bit set, or0 ifthe input is0.

§Examples

#![feature(isolate_most_least_significant_one)]letn: i8 =0b_01100100;assert_eq!(n.isolate_highest_one(),0b_01000000);assert_eq!(0_i8.isolate_highest_one(),0);

Returnsself with only the least significant bit set, or0 ifthe input is0.

§Examples

#![feature(isolate_most_least_significant_one)]letn: i8 =0b_01100100;assert_eq!(n.isolate_lowest_one(),0b_00000100);assert_eq!(0_i8.isolate_lowest_one(),0);

Returns the index of the highest bit set to one inself, orNoneifself is0.

§Examples

#![feature(int_lowest_highest_one)]assert_eq!(0b0_i8.highest_one(),None);assert_eq!(0b1_i8.highest_one(),Some(0));assert_eq!(0b1_0000_i8.highest_one(),Some(4));assert_eq!(0b1_1111_i8.highest_one(),Some(4));

Returns the index of the lowest bit set to one inself, orNoneifself is0.

§Examples

#![feature(int_lowest_highest_one)]assert_eq!(0b0_i8.lowest_one(),None);assert_eq!(0b1_i8.lowest_one(),Some(0));assert_eq!(0b1_0000_i8.lowest_one(),Some(4));assert_eq!(0b1_1111_i8.lowest_one(),Some(0));

Returns the bit pattern ofself reinterpreted as an unsigned integer of the same size.

This produces the same result as anas cast, but ensures that the bit-width remainsthe same.

§Examples

letn = -1i8;assert_eq!(n.cast_unsigned(), u8::MAX);

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

rotate_left(n) is equivalent to applyingrotate_left(1) a total ofn times. Inparticular, a rotation by the number of bits inself returns the input valueunchanged.

Please note this isn’t the same operation as the<< shifting operator!

§Examples

letn = -0x7ei8;letm =0xa;assert_eq!(n.rotate_left(2), m);assert_eq!(n.rotate_left(1024), n);

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

rotate_right(n) is equivalent to applyingrotate_right(1) a total ofn times. Inparticular, a rotation by the number of bits inself returns the input valueunchanged.

Please note this isn’t the same operation as the>> shifting operator!

§Examples

letn =0xai8;letm = -0x7e;assert_eq!(n.rotate_right(2), m);assert_eq!(n.rotate_right(1024), n);

Reverses the byte order of the integer.

§Examples

letn =0x12i8;letm = n.swap_bytes();assert_eq!(m,0x12);

Reverses the order of bits in the integer. The least significant bit becomes the most significant bit,second least-significant bit becomes second most-significant bit, etc.

§Examples

letn =0x12i8;letm = n.reverse_bits();assert_eq!(m,0x48);assert_eq!(0,0i8.reverse_bits());

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.

See alsofrom_be_bytes().

§Examples

letn =0x1Ai8;ifcfg!(target_endian ="big") {assert_eq!(i8::from_be(n), n)}else{assert_eq!(i8::from_be(n), n.swap_bytes())}

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.

See alsofrom_le_bytes().

§Examples

letn =0x1Ai8;ifcfg!(target_endian ="little") {assert_eq!(i8::from_le(n), n)}else{assert_eq!(i8::from_le(n), n.swap_bytes())}

Swaps bytes ofself on little endian targets.

On big endian this is a no-op.

The returned value has the same type asself, and will be interpretedas (a potentially different) value of a native-endiani8.

Seeto_be_bytes() for a type-safe alternative.

§Examples

letn =0x1Ai8;ifcfg!(target_endian ="big") {assert_eq!(n.to_be(), n)}else{assert_eq!(n.to_be(), n.swap_bytes())}

Swaps bytes ofself on big endian targets.

On little endian this is a no-op.

The returned value has the same type asself, and will be interpretedas (a potentially different) value of a native-endiani8.

Seeto_le_bytes() for a type-safe alternative.

§Examples

letn =0x1Ai8;ifcfg!(target_endian ="little") {assert_eq!(n.to_le(), n)}else{assert_eq!(n.to_le(), n.swap_bytes())}

Checked integer addition. Computesself + rhs, returningNoneif overflow occurred.

§Examples

assert_eq!((i8::MAX -2).checked_add(1),Some(i8::MAX -1));assert_eq!((i8::MAX -2).checked_add(3),None);

Strict integer addition. Computesself + rhs, panickingif overflow occurred.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!((i8::MAX -2).strict_add(1), i8::MAX -1);

The following panics because of overflow:

let _= (i8::MAX -2).strict_add(3);

Unchecked integer addition. Computesself + rhs, assuming overflowcannot occur.

Callingx.unchecked_add(y) is semantically equivalent to callingx.checked_add(y).unwrap_unchecked().

If you’re just trying to avoid the panic in debug mode, thendo notuse this. Instead, you’re looking forwrapping_add.

§Safety

This results in undefined behavior whenself + rhs > i8::MAX orself + rhs < i8::MIN,i.e. whenchecked_add would returnNone.

Checked addition with an unsigned integer. Computesself + rhs,returningNone if overflow occurred.

§Examples

assert_eq!(1i8.checked_add_unsigned(2),Some(3));assert_eq!((i8::MAX -2).checked_add_unsigned(3),None);

Strict addition with an unsigned integer. Computesself + rhs,panicking if overflow occurred.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!(1i8.strict_add_unsigned(2),3);

The following panics because of overflow:

let _= (i8::MAX -2).strict_add_unsigned(3);

Checked integer subtraction. Computesself - rhs, returningNone ifoverflow occurred.

§Examples

assert_eq!((i8::MIN +2).checked_sub(1),Some(i8::MIN +1));assert_eq!((i8::MIN +2).checked_sub(3),None);

Strict integer subtraction. Computesself - rhs, panicking ifoverflow occurred.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!((i8::MIN +2).strict_sub(1), i8::MIN +1);

The following panics because of overflow:

let _= (i8::MIN +2).strict_sub(3);

Unchecked integer subtraction. Computesself - rhs, assuming overflowcannot occur.

Callingx.unchecked_sub(y) is semantically equivalent to callingx.checked_sub(y).unwrap_unchecked().

If you’re just trying to avoid the panic in debug mode, thendo notuse this. Instead, you’re looking forwrapping_sub.

§Safety

This results in undefined behavior whenself - rhs > i8::MAX orself - rhs < i8::MIN,i.e. whenchecked_sub would returnNone.

Checked subtraction with an unsigned integer. Computesself - rhs,returningNone if overflow occurred.

§Examples

assert_eq!(1i8.checked_sub_unsigned(2),Some(-1));assert_eq!((i8::MIN +2).checked_sub_unsigned(3),None);

Strict subtraction with an unsigned integer. Computesself - rhs,panicking if overflow occurred.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!(1i8.strict_sub_unsigned(2), -1);

The following panics because of overflow:

let _= (i8::MIN +2).strict_sub_unsigned(3);

Checked integer multiplication. Computesself * rhs, returningNone ifoverflow occurred.

§Examples

assert_eq!(i8::MAX.checked_mul(1),Some(i8::MAX));assert_eq!(i8::MAX.checked_mul(2),None);

Strict integer multiplication. Computesself * rhs, panicking ifoverflow occurred.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!(i8::MAX.strict_mul(1), i8::MAX);

The following panics because of overflow:

let _= i8::MAX.strict_mul(2);

Unchecked integer multiplication. Computesself * rhs, assuming overflowcannot occur.

Callingx.unchecked_mul(y) is semantically equivalent to callingx.checked_mul(y).unwrap_unchecked().

If you’re just trying to avoid the panic in debug mode, thendo notuse this. Instead, you’re looking forwrapping_mul.

§Safety

This results in undefined behavior whenself * rhs > i8::MAX orself * rhs < i8::MIN,i.e. whenchecked_mul would returnNone.

Checked integer division. Computesself / rhs, returningNone ifrhs == 0or the division results in overflow.

§Examples

assert_eq!((i8::MIN +1).checked_div(-1),Some(127));assert_eq!(i8::MIN.checked_div(-1),None);assert_eq!((1i8).checked_div(0),None);

Strict integer division. Computesself / rhs, panickingif overflow occurred.

§Panics

This function will panic ifrhs is zero.

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

The only case where such an overflow can occur is when one dividesMIN / -1 on a signed type (whereMIN is the negative minimal value for the type); this is equivalent to-MIN, a positive valuethat is too large to represent in the type.

§Examples

assert_eq!((i8::MIN +1).strict_div(-1),127);

The following panics because of overflow:

let _= i8::MIN.strict_div(-1);

The following panics because of division by zero:

let _= (1i8).strict_div(0);

Checked Euclidean division. Computesself.div_euclid(rhs),returningNone ifrhs == 0 or the division results in overflow.

§Examples

assert_eq!((i8::MIN +1).checked_div_euclid(-1),Some(127));assert_eq!(i8::MIN.checked_div_euclid(-1),None);assert_eq!((1i8).checked_div_euclid(0),None);

Strict Euclidean division. Computesself.div_euclid(rhs), panickingif overflow occurred.

§Panics

This function will panic ifrhs is zero.

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

The only case where such an overflow can occur is when one dividesMIN / -1 on a signed type (whereMIN is the negative minimal value for the type); this is equivalent to-MIN, a positive valuethat is too large to represent in the type.

§Examples

assert_eq!((i8::MIN +1).strict_div_euclid(-1),127);

The following panics because of overflow:

let _= i8::MIN.strict_div_euclid(-1);

The following panics because of division by zero:

let _= (1i8).strict_div_euclid(0);

Checked integer division without remainder. Computesself / rhs,returningNone ifrhs == 0, the division results in overflow,orself % rhs != 0.

§Examples

#![feature(exact_div)]assert_eq!((i8::MIN +1).checked_div_exact(-1),Some(127));assert_eq!((-5i8).checked_div_exact(2),None);assert_eq!(i8::MIN.checked_div_exact(-1),None);assert_eq!((1i8).checked_div_exact(0),None);

Integer division without remainder. Computesself / rhs, returningNone ifself % rhs != 0.

§Panics

This function will panic ifrhs == 0.

§Overflow behavior

On overflow, this function will panic if overflow checks are enabled (default in debugmode) and wrap if overflow checks are disabled (default in release mode).

§Examples

#![feature(exact_div)]assert_eq!(64i8.div_exact(2),Some(32));assert_eq!(64i8.div_exact(32),Some(2));assert_eq!((i8::MIN +1).div_exact(-1),Some(127));assert_eq!(65i8.div_exact(2),None);

#![feature(exact_div)]let _=64i8.div_exact(0);

#![feature(exact_div)]let _= i8::MIN.div_exact(-1);

Unchecked integer division without remainder. Computesself / rhs.

§Safety

This results in undefined behavior whenrhs == 0,self % rhs != 0, orself == i8::MIN && rhs == -1,i.e. whenchecked_div_exact would returnNone.

Checked integer remainder. Computesself % rhs, returningNone ifrhs == 0 or the division results in overflow.

§Examples

assert_eq!(5i8.checked_rem(2),Some(1));assert_eq!(5i8.checked_rem(0),None);assert_eq!(i8::MIN.checked_rem(-1),None);

Strict integer remainder. Computesself % rhs, panicking ifthe division results in overflow.

§Panics

This function will panic ifrhs is zero.

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

The only case where such an overflow can occur isx % y forMIN / -1 on asigned type (whereMIN is the negative minimal value), which is invalid due to implementation artifacts.

§Examples

assert_eq!(5i8.strict_rem(2),1);

The following panics because of division by zero:

let _=5i8.strict_rem(0);

The following panics because of overflow:

let _= i8::MIN.strict_rem(-1);

Checked Euclidean remainder. Computesself.rem_euclid(rhs), returningNoneifrhs == 0 or the division results in overflow.

§Examples

assert_eq!(5i8.checked_rem_euclid(2),Some(1));assert_eq!(5i8.checked_rem_euclid(0),None);assert_eq!(i8::MIN.checked_rem_euclid(-1),None);

Strict Euclidean remainder. Computesself.rem_euclid(rhs), panicking ifthe division results in overflow.

§Panics

This function will panic ifrhs is zero.

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

The only case where such an overflow can occur isx % y forMIN / -1 on asigned type (whereMIN is the negative minimal value), which is invalid due to implementation artifacts.

§Examples

assert_eq!(5i8.strict_rem_euclid(2),1);

The following panics because of division by zero:

let _=5i8.strict_rem_euclid(0);

The following panics because of overflow:

let _= i8::MIN.strict_rem_euclid(-1);

Checked negation. Computes-self, returningNone ifself == MIN.

§Examples

assert_eq!(5i8.checked_neg(),Some(-5));assert_eq!(i8::MIN.checked_neg(),None);

Unchecked negation. Computes-self, assuming overflow cannot occur.

§Safety

This results in undefined behavior whenself == i8::MIN,i.e. whenchecked_neg would returnNone.

Strict negation. Computes-self, panicking ifself == MIN.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!(5i8.strict_neg(), -5);

The following panics because of overflow:

let _= i8::MIN.strict_neg();

Checked shift left. Computesself << rhs, returningNone ifrhs is largerthan or equal to the number of bits inself.

§Examples

assert_eq!(0x1i8.checked_shl(4),Some(0x10));assert_eq!(0x1i8.checked_shl(129),None);assert_eq!(0x10i8.checked_shl(7),Some(0));

Strict shift left. Computesself << rhs, panicking ifrhs is largerthan or equal to the number of bits inself.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!(0x1i8.strict_shl(4),0x10);

The following panics because of overflow:

let _=0x1i8.strict_shl(129);

Unchecked shift left. Computesself << rhs, assuming thatrhs is less than the number of bits inself.

§Safety

This results in undefined behavior ifrhs is larger thanor equal to the number of bits inself,i.e. whenchecked_shl would returnNone.

Unbounded shift left. Computesself << rhs, without bounding the value ofrhs.

Ifrhs is larger or equal to the number of bits inself,the entire value is shifted out, and0 is returned.

§Examples

assert_eq!(0x1i8.unbounded_shl(4),0x10);assert_eq!(0x1i8.unbounded_shl(129),0);

Exact shift left. Computesself << rhs as long as it can be reversed losslessly.

ReturnsNone if any bits that would be shifted out differ from the resulting sign bitor ifrhs >=i8::BITS.Otherwise, returnsSome(self << rhs).

§Examples

#![feature(exact_bitshifts)]assert_eq!(0x1i8.shl_exact(4),Some(0x10));assert_eq!(0x1i8.shl_exact(i8::BITS -2),Some(1<< i8::BITS -2));assert_eq!(0x1i8.shl_exact(i8::BITS -1),None);assert_eq!((-0x2i8).shl_exact(i8::BITS -2),Some(-0x2<< i8::BITS -2));assert_eq!((-0x2i8).shl_exact(i8::BITS -1),None);

Unchecked exact shift left. Computesself << rhs, assuming the operation can belosslessly reversed andrhs cannot be larger thani8::BITS.

§Safety

This results in undefined behavior whenrhs >= self.leading_zeros() && rhs >= self.leading_ones() i.e. wheni8::shl_exactwould returnNone.

Checked shift right. Computesself >> rhs, returningNone ifrhs islarger than or equal to the number of bits inself.

§Examples

assert_eq!(0x10i8.checked_shr(4),Some(0x1));assert_eq!(0x10i8.checked_shr(128),None);

Strict shift right. Computesself >> rhs, panicking ifrhs islarger than or equal to the number of bits inself.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!(0x10i8.strict_shr(4),0x1);

The following panics because of overflow:

let _=0x10i8.strict_shr(128);

Unchecked shift right. Computesself >> rhs, assuming thatrhs is less than the number of bits inself.

§Safety

This results in undefined behavior ifrhs is larger thanor equal to the number of bits inself,i.e. whenchecked_shr would returnNone.

Unbounded shift right. Computesself >> rhs, without bounding the value ofrhs.

Ifrhs is larger or equal to the number of bits inself,the entire value is shifted out, which yields0 for a positive number,and-1 for a negative number.

§Examples

assert_eq!(0x10i8.unbounded_shr(4),0x1);assert_eq!(0x10i8.unbounded_shr(129),0);assert_eq!(i8::MIN.unbounded_shr(129), -1);

Exact shift right. Computesself >> rhs as long as it can be reversed losslessly.

ReturnsNone if any non-zero bits would be shifted out or ifrhs >=i8::BITS.Otherwise, returnsSome(self >> rhs).

§Examples

#![feature(exact_bitshifts)]assert_eq!(0x10i8.shr_exact(4),Some(0x1));assert_eq!(0x10i8.shr_exact(5),None);

Unchecked exact shift right. Computesself >> rhs, assuming the operation can belosslessly reversed andrhs cannot be larger thani8::BITS.

§Safety

This results in undefined behavior whenrhs > self.trailing_zeros() || rhs >= i8::BITSi.e. wheni8::shr_exactwould returnNone.

Checked absolute value. Computesself.abs(), returningNone ifself == MIN.

§Examples

assert_eq!((-5i8).checked_abs(),Some(5));assert_eq!(i8::MIN.checked_abs(),None);

Strict absolute value. Computesself.abs(), panicking ifself == MIN.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!((-5i8).strict_abs(),5);

The following panics because of overflow:

let _= i8::MIN.strict_abs();

Checked exponentiation. Computesself.pow(exp), returningNone ifoverflow occurred.

§Examples

assert_eq!(8i8.checked_pow(2),Some(64));assert_eq!(0_i8.checked_pow(0),Some(1));assert_eq!(i8::MAX.checked_pow(2),None);

Strict exponentiation. Computesself.pow(exp), panicking ifoverflow occurred.

§Panics

§Overflow behavior

This function will always panic on overflow, regardless of whether overflow checks are enabled.

§Examples

assert_eq!(8i8.strict_pow(2),64);assert_eq!(0_i8.strict_pow(0),1);

The following panics because of overflow:

let _= i8::MAX.strict_pow(2);

Returns the square root of the number, rounded down.

ReturnsNone ifself is negative.

§Examples

assert_eq!(10i8.checked_isqrt(),Some(3));

Saturating integer addition. Computesself + rhs, saturating at the numericbounds instead of overflowing.

§Examples

assert_eq!(100i8.saturating_add(1),101);assert_eq!(i8::MAX.saturating_add(100), i8::MAX);assert_eq!(i8::MIN.saturating_add(-1), i8::MIN);

Saturating addition with an unsigned integer. Computesself + rhs,saturating at the numeric bounds instead of overflowing.

§Examples

assert_eq!(1i8.saturating_add_unsigned(2),3);assert_eq!(i8::MAX.saturating_add_unsigned(100), i8::MAX);

Saturating integer subtraction. Computesself - rhs, saturating at thenumeric bounds instead of overflowing.

§Examples

assert_eq!(100i8.saturating_sub(127), -27);assert_eq!(i8::MIN.saturating_sub(100), i8::MIN);assert_eq!(i8::MAX.saturating_sub(-1), i8::MAX);

Saturating subtraction with an unsigned integer. Computesself - rhs,saturating at the numeric bounds instead of overflowing.

§Examples

assert_eq!(100i8.saturating_sub_unsigned(127), -27);assert_eq!(i8::MIN.saturating_sub_unsigned(100), i8::MIN);

Saturating integer negation. Computes-self, returningMAX ifself == MINinstead of overflowing.

§Examples

assert_eq!(100i8.saturating_neg(), -100);assert_eq!((-100i8).saturating_neg(),100);assert_eq!(i8::MIN.saturating_neg(), i8::MAX);assert_eq!(i8::MAX.saturating_neg(), i8::MIN +1);

Saturating absolute value. Computesself.abs(), returningMAX ifself == MIN instead of overflowing.

§Examples

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

Saturating integer multiplication. Computesself * rhs, saturating at thenumeric bounds instead of overflowing.

§Examples

assert_eq!(10i8.saturating_mul(12),120);assert_eq!(i8::MAX.saturating_mul(10), i8::MAX);assert_eq!(i8::MIN.saturating_mul(10), i8::MIN);

Saturating integer division. Computesself / rhs, saturating at thenumeric bounds instead of overflowing.

§Panics

This function will panic ifrhs is zero.

§Examples

assert_eq!(5i8.saturating_div(2),2);assert_eq!(i8::MAX.saturating_div(-1), i8::MIN +1);assert_eq!(i8::MIN.saturating_div(-1), i8::MAX);

Saturating integer exponentiation. Computesself.pow(exp),saturating at the numeric bounds instead of overflowing.

§Examples

assert_eq!((-4i8).saturating_pow(3), -64);assert_eq!(0_i8.saturating_pow(0),1);assert_eq!(i8::MIN.saturating_pow(2), i8::MAX);assert_eq!(i8::MIN.saturating_pow(3), i8::MIN);

Wrapping (modular) addition. Computesself + rhs, wrapping around at theboundary of the type.

§Examples

assert_eq!(100i8.wrapping_add(27),127);assert_eq!(i8::MAX.wrapping_add(2), i8::MIN +1);

Wrapping (modular) addition with an unsigned integer. Computesself + rhs, wrapping around at the boundary of the type.

§Examples

assert_eq!(100i8.wrapping_add_unsigned(27),127);assert_eq!(i8::MAX.wrapping_add_unsigned(2), i8::MIN +1);

Wrapping (modular) subtraction. Computesself - rhs, wrapping around at theboundary of the type.

§Examples

assert_eq!(0i8.wrapping_sub(127), -127);assert_eq!((-2i8).wrapping_sub(i8::MAX), i8::MAX);

Wrapping (modular) subtraction with an unsigned integer. Computesself - rhs, wrapping around at the boundary of the type.

§Examples

assert_eq!(0i8.wrapping_sub_unsigned(127), -127);assert_eq!((-2i8).wrapping_sub_unsigned(u8::MAX), -1);

Wrapping (modular) multiplication. Computesself * rhs, wrapping around atthe boundary of the type.

§Examples

assert_eq!(10i8.wrapping_mul(12),120);assert_eq!(11i8.wrapping_mul(12), -124);

Wrapping (modular) division. Computesself / rhs, wrapping around at theboundary of the type.

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

§Panics

This function will panic ifrhs is zero.

§Examples

assert_eq!(100i8.wrapping_div(10),10);assert_eq!((-128i8).wrapping_div(-1), -128);

Wrapping Euclidean division. Computesself.div_euclid(rhs),wrapping around at the boundary of the type.

Wrapping will only occur inMIN / -1 on a signed type (whereMIN is the negative minimal valuefor the type). This is equivalent to-MIN, a positive value that is too large to represent in thetype. In this case, this method returnsMIN itself.

§Panics

This function will panic ifrhs is zero.

§Examples

assert_eq!(100i8.wrapping_div_euclid(10),10);assert_eq!((-128i8).wrapping_div_euclid(-1), -128);

Wrapping (modular) remainder. Computesself % rhs, wrapping around at theboundary of the type.

Such wrap-around never actually occurs mathematically; implementation artifacts makex % yinvalid forMIN / -1 on a signed type (whereMIN is the negative minimal value). In such a case,this function returns0.

§Panics

This function will panic ifrhs is zero.

§Examples

assert_eq!(100i8.wrapping_rem(10),0);assert_eq!((-128i8).wrapping_rem(-1),0);

Wrapping Euclidean remainder. Computesself.rem_euclid(rhs), wrapping aroundat the boundary of the type.

Wrapping will only occur inMIN % -1 on a signed type (whereMIN is the negative minimal valuefor the type). In this case, this method returns 0.

§Panics

This function will panic ifrhs is zero.

§Examples

assert_eq!(100i8.wrapping_rem_euclid(10),0);assert_eq!((-128i8).wrapping_rem_euclid(-1),0);

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

The only case where such wrapping can occur is when one negatesMIN on a signed type (whereMINis the negative minimal value for the type); this is a positive value that is too large to representin the type. In such a case, this function returnsMIN itself.

§Examples

assert_eq!(100i8.wrapping_neg(), -100);assert_eq!((-100i8).wrapping_neg(),100);assert_eq!(i8::MIN.wrapping_neg(), i8::MIN);

Panic-free bitwise shift-left; yieldsself << mask(rhs), wheremask removesany high-order bits ofrhs that would cause the shift to exceed the bitwidth of the type.

Note that this isnot the same as a rotate-left; the RHS of a wrapping shift-left is restricted tothe range of the type, rather than the bits shifted out of the LHS being returned to the other end.The primitive integer types all implement arotate_left function,which may be what you want instead.

§Examples

assert_eq!((-1i8).wrapping_shl(7), -128);assert_eq!((-1i8).wrapping_shl(128), -1);

Panic-free bitwise shift-right; yieldsself >> mask(rhs), wheremaskremoves any high-order bits ofrhs that would cause the shift to exceed the bitwidth of the type.

Note that this isnot the same as a rotate-right; the RHS of a wrapping shift-right is restrictedto the range of the type, rather than the bits shifted out of the LHS being returned to the otherend. The primitive integer types all implement arotate_right function,which may be what you want instead.

§Examples

assert_eq!((-128i8).wrapping_shr(7), -1);assert_eq!((-128i16).wrapping_shr(64), -128);

Wrapping (modular) absolute value. Computesself.abs(), wrapping around atthe boundary of the type.

The only case where such wrapping can occur is when one takes the absolute value of the negativeminimal value for the type; this is a positive value that is too large to represent in the type. Insuch a case, this function returnsMIN itself.

§Examples

assert_eq!(100i8.wrapping_abs(),100);assert_eq!((-100i8).wrapping_abs(),100);assert_eq!(i8::MIN.wrapping_abs(), i8::MIN);assert_eq!((-128i8).wrapping_abs()asu8,128);

Computes the absolute value ofself without any wrappingor panicking.

§Examples

assert_eq!(100i8.unsigned_abs(),100u8);assert_eq!((-100i8).unsigned_abs(),100u8);assert_eq!((-128i8).unsigned_abs(),128u8);

Wrapping (modular) exponentiation. Computesself.pow(exp),wrapping around at the boundary of the type.

§Examples

assert_eq!(3i8.wrapping_pow(4),81);assert_eq!(3i8.wrapping_pow(5), -13);assert_eq!(3i8.wrapping_pow(6), -39);assert_eq!(0_i8.wrapping_pow(0),1);

Calculatesself +rhs.

Returns a tuple of the addition along with a boolean indicatingwhether an arithmetic overflow would occur. If an overflow would haveoccurred then the wrapped value is returned.

§Examples

assert_eq!(5i8.overflowing_add(2), (7,false));assert_eq!(i8::MAX.overflowing_add(1), (i8::MIN,true));

Calculatesself +rhs +carry and checks for overflow.

Performs “ternary addition” of two integer operands and a carry-inbit, and returns a tuple of the sum along with a boolean indicatingwhether an arithmetic overflow would occur. On overflow, the wrappedvalue is returned.

This allows chaining together multiple additions to create a wideraddition, and can be useful for bignum addition. This method shouldonly be used for the most significant word; for the less significantwords the unsigned methodu8::carrying_addshould be used.

The output boolean returned by this method isnot a carry flag,and shouldnot be added to a more significant word.

If the input carry is false, this method is equivalent tooverflowing_add.

§Examples

#![feature(bigint_helper_methods)]// Only the most significant word is signed.////   10  MAX    (a = 10 × 2^8 + 2^8 - 1)// + -5    9    (b = -5 × 2^8 + 9)// ---------//    6    8    (sum = 6 × 2^8 + 8)let(a1, a0): (i8, u8) = (10, u8::MAX);let(b1, b0): (i8, u8) = (-5,9);letcarry0 =false;// u8::carrying_add for the less significant wordslet(sum0, carry1) = a0.carrying_add(b0, carry0);assert_eq!(carry1,true);// i8::carrying_add for the most significant wordlet(sum1, overflow) = a1.carrying_add(b1, carry1);assert_eq!(overflow,false);assert_eq!((sum1, sum0), (6,8));

Calculatesself +rhs with an unsignedrhs.

Returns a tuple of the addition along with a boolean indicatingwhether an arithmetic overflow would occur. If an overflow wouldhave occurred then the wrapped value is returned.

§Examples

assert_eq!(1i8.overflowing_add_unsigned(2), (3,false));assert_eq!((i8::MIN).overflowing_add_unsigned(u8::MAX), (i8::MAX,false));assert_eq!((i8::MAX -2).overflowing_add_unsigned(3), (i8::MIN,true));

Calculatesself -rhs.

Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflowwould occur. If an overflow would have occurred then the wrapped value is returned.

§Examples

assert_eq!(5i8.overflowing_sub(2), (3,false));assert_eq!(i8::MIN.overflowing_sub(1), (i8::MAX,true));

Calculatesself −rhs −borrow and checks foroverflow.

Performs “ternary subtraction” by subtracting both an integeroperand and a borrow-in bit fromself, and returns a tuple of thedifference along with a boolean indicating whether an arithmeticoverflow would occur. On overflow, the wrapped value is returned.

This allows chaining together multiple subtractions to create awider subtraction, and can be useful for bignum subtraction. Thismethod should only be used for the most significant word; for theless significant words the unsigned methodu8::borrowing_subshould be used.

The output boolean returned by this method isnot a borrow flag,and shouldnot be subtracted from a more significant word.

If the input borrow is false, this method is equivalent tooverflowing_sub.

§Examples

#![feature(bigint_helper_methods)]// Only the most significant word is signed.////    6    8    (a = 6 × 2^8 + 8)// - -5    9    (b = -5 × 2^8 + 9)// ---------//   10  MAX    (diff = 10 × 2^8 + 2^8 - 1)let(a1, a0): (i8, u8) = (6,8);let(b1, b0): (i8, u8) = (-5,9);letborrow0 =false;// u8::borrowing_sub for the less significant wordslet(diff0, borrow1) = a0.borrowing_sub(b0, borrow0);assert_eq!(borrow1,true);// i8::borrowing_sub for the most significant wordlet(diff1, overflow) = a1.borrowing_sub(b1, borrow1);assert_eq!(overflow,false);assert_eq!((diff1, diff0), (10, u8::MAX));

Calculatesself -rhs with an unsignedrhs.

Returns a tuple of the subtraction along with a boolean indicatingwhether an arithmetic overflow would occur. If an overflow wouldhave occurred then the wrapped value is returned.

§Examples

assert_eq!(1i8.overflowing_sub_unsigned(2), (-1,false));assert_eq!((i8::MAX).overflowing_sub_unsigned(u8::MAX), (i8::MIN,false));assert_eq!((i8::MIN +2).overflowing_sub_unsigned(3), (i8::MAX,true));

Calculates the multiplication ofself andrhs.

Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflowwould occur. If an overflow would have occurred then the wrapped value is returned.

§Examples

assert_eq!(5i8.overflowing_mul(2), (10,false));assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408,true));

Calculates the complete productself * rhs without the possibility to overflow.

This returns the low-order (wrapping) bits and the high-order (overflow) bitsof the result as two separate values, in that order.

If you also need to add a carry to the wide result, then you wantSelf::carrying_mul instead.

§Examples

Please note that this example is shared among integer types, which is whyi32 is used.

#![feature(bigint_helper_methods)]assert_eq!(5i32.widening_mul(-2), (4294967286, -1));assert_eq!(1_000_000_000i32.widening_mul(-10), (2884901888, -3));

Calculates the “full multiplication”self * rhs + carrywithout the possibility to overflow.

This returns the low-order (wrapping) bits and the high-order (overflow) bitsof the result as two separate values, in that order.

Performs “long multiplication” which takes in an extra amount to add, and may return anadditional amount of overflow. This allows for chaining together multiplemultiplications to create “big integers” which represent larger values.

If you don’t need thecarry, then you can useSelf::widening_mul instead.

§Examples

Please note that this example is shared among integer types, which is whyi32 is used.

#![feature(bigint_helper_methods)]assert_eq!(5i32.carrying_mul(-2,0), (4294967286, -1));assert_eq!(5i32.carrying_mul(-2,10), (0,0));assert_eq!(1_000_000_000i32.carrying_mul(-10,0), (2884901888, -3));assert_eq!(1_000_000_000i32.carrying_mul(-10,10), (2884901898, -3));assert_eq!(i8::MAX.carrying_mul(i8::MAX, i8::MAX), (i8::MAX.unsigned_abs() +1, i8::MAX /2));

Calculates the “full multiplication”self * rhs + carry + addwithout the possibility to overflow.

This returns the low-order (wrapping) bits and the high-order (overflow) bitsof the result as two separate values, in that order.

Performs “long multiplication” which takes in an extra amount to add, and may return anadditional amount of overflow. This allows for chaining together multiplemultiplications to create “big integers” which represent larger values.

If you don’t need eithercarry, then you can useSelf::widening_mul instead,and if you only need onecarry, then you can useSelf::carrying_mul instead.

§Examples

Please note that this example is shared among integer types, which is whyi32 is used.

#![feature(bigint_helper_methods)]assert_eq!(5i32.carrying_mul_add(-2,0,0), (4294967286, -1));assert_eq!(5i32.carrying_mul_add(-2,10,10), (10,0));assert_eq!(1_000_000_000i32.carrying_mul_add(-10,0,0), (2884901888, -3));assert_eq!(1_000_000_000i32.carrying_mul_add(-10,10,10), (2884901908, -3));assert_eq!(i8::MAX.carrying_mul_add(i8::MAX, i8::MAX, i8::MAX), (u8::MAX, i8::MAX /2));

Calculates the divisor whenself is divided byrhs.

Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow wouldoccur. If an overflow would occur then self is returned.

§Panics

This function will panic ifrhs is zero.

§Examples

assert_eq!(5i8.overflowing_div(2), (2,false));assert_eq!(i8::MIN.overflowing_div(-1), (i8::MIN,true));

Calculates the quotient of Euclidean divisionself.div_euclid(rhs).

Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow wouldoccur. If an overflow would occur thenself is returned.

§Panics

This function will panic ifrhs is zero.

§Examples

assert_eq!(5i8.overflowing_div_euclid(2), (2,false));assert_eq!(i8::MIN.overflowing_div_euclid(-1), (i8::MIN,true));

Calculates the remainder whenself is divided byrhs.

Returns a tuple of the remainder after dividing along with a boolean indicating whether anarithmetic overflow would occur. If an overflow would occur then 0 is returned.

§Panics

This function will panic ifrhs is zero.

§Examples

assert_eq!(5i8.overflowing_rem(2), (1,false));assert_eq!(i8::MIN.overflowing_rem(-1), (0,true));

Overflowing Euclidean remainder. Calculatesself.rem_euclid(rhs).

Returns a tuple of the remainder after dividing along with a boolean indicating whether anarithmetic overflow would occur. If an overflow would occur then 0 is returned.

§Panics

This function will panic ifrhs is zero.

§Examples

assert_eq!(5i8.overflowing_rem_euclid(2), (1,false));assert_eq!(i8::MIN.overflowing_rem_euclid(-1), (0,true));

Negates self, overflowing if this is equal to the minimum value.

Returns a tuple of the negated version of self along with a boolean indicating whether an overflowhappened. Ifself is the minimum value (e.g.,i32::MIN for values of typei32), then theminimum value will be returned again andtrue will be returned for an overflow happening.

§Examples

assert_eq!(2i8.overflowing_neg(), (-2,false));assert_eq!(i8::MIN.overflowing_neg(), (i8::MIN,true));

Shifts self left byrhs bits.

Returns a tuple of the shifted version of self along with a boolean indicating whether the shiftvalue was larger than or equal to the number of bits. If the shift value is too large, then value ismasked (N-1) where N is the number of bits, and this value is then used to perform the shift.

§Examples

assert_eq!(0x1i8.overflowing_shl(4), (0x10,false));assert_eq!(0x1i32.overflowing_shl(36), (0x10,true));assert_eq!(0x10i8.overflowing_shl(7), (0,false));

Shifts self right byrhs bits.

Returns a tuple of the shifted version of self along with a boolean indicating whether the shiftvalue was larger than or equal to the number of bits. If the shift value is too large, then value ismasked (N-1) where N is the number of bits, and this value is then used to perform the shift.

§Examples

assert_eq!(0x10i8.overflowing_shr(4), (0x1,false));assert_eq!(0x10i32.overflowing_shr(36), (0x1,true));

Computes the absolute value ofself.

Returns a tuple of the absolute version of self along with a boolean indicating whether an overflowhappened. If self is the minimum value(e.g., i8::MIN for values of type i8),then the minimum value will be returned again and true will be returnedfor an overflow happening.

§Examples

assert_eq!(10i8.overflowing_abs(), (10,false));assert_eq!((-10i8).overflowing_abs(), (10,false));assert_eq!((i8::MIN).overflowing_abs(), (i8::MIN,true));

Raises self to the power ofexp, using exponentiation by squaring.

Returns a tuple of the exponentiation along with a bool indicatingwhether an overflow happened.

§Examples

assert_eq!(3i8.overflowing_pow(4), (81,false));assert_eq!(0_i8.overflowing_pow(0), (1,false));assert_eq!(3i8.overflowing_pow(5), (-13,true));

Raises self to the power ofexp, using exponentiation by squaring.

§Examples

letx: i8 =2;// or any other integer typeassert_eq!(x.pow(5),32);assert_eq!(0_i8.pow(0),1);

Returns the square root of the number, rounded down.

§Panics

This function will panic ifself is negative.

§Examples

assert_eq!(10i8.isqrt(),3);

Calculates the quotient of Euclidean division ofself byrhs.

This computes the integerq such thatself = q * rhs + r, withr = self.rem_euclid(rhs) and0 <= r < abs(rhs).

In other words, the result isself / rhs rounded to the integerqsuch thatself >= q * rhs.Ifself > 0, this is equal to rounding towards zero (the default in Rust);ifself < 0, this is equal to rounding away from zero (towards +/- infinity).Ifrhs > 0, this is equal to rounding towards -infinity;ifrhs < 0, this is equal to rounding towards +infinity.

§Panics

This function will panic ifrhs is zero or ifself isSelf::MINandrhs is -1. This behavior is not affected by theoverflow-checks flag.

§Examples

leta: i8 =7;// or any other integer typeletb =4;assert_eq!(a.div_euclid(b),1);// 7 >= 4 * 1assert_eq!(a.div_euclid(-b), -1);// 7 >= -4 * -1assert_eq!((-a).div_euclid(b), -2);// -7 >= 4 * -2assert_eq!((-a).div_euclid(-b),2);// -7 >= -4 * 2

Calculates the least nonnegative remainder ofself (mod rhs).

This is done as if by the Euclidean division algorithm – givenr = self.rem_euclid(rhs), the result satisfiesself = rhs * self.div_euclid(rhs) + r and0 <= r < abs(rhs).

§Panics

This function will panic ifrhs is zero or ifself isSelf::MIN andrhs is -1. This behavior is not affected by theoverflow-checks flag.

§Examples

leta: i8 =7;// or any other integer typeletb =4;assert_eq!(a.rem_euclid(b),3);assert_eq!((-a).rem_euclid(b),1);assert_eq!(a.rem_euclid(-b),3);assert_eq!((-a).rem_euclid(-b),1);

This will panic:

let _= i8::MIN.rem_euclid(-1);

Calculates the quotient ofself andrhs, rounding the result towards negative infinity.

§Panics

This function will panic ifrhs is zero or ifself isSelf::MINandrhs is -1. This behavior is not affected by theoverflow-checks flag.

§Examples

#![feature(int_roundings)]leta: i8 =8;letb =3;assert_eq!(a.div_floor(b),2);assert_eq!(a.div_floor(-b), -3);assert_eq!((-a).div_floor(b), -3);assert_eq!((-a).div_floor(-b),2);

Calculates the quotient ofself andrhs, rounding the result towards positive infinity.

§Panics

This function will panic ifrhs is zero or ifself isSelf::MINandrhs is -1. This behavior is not affected by theoverflow-checks flag.

§Examples

#![feature(int_roundings)]leta: i8 =8;letb =3;assert_eq!(a.div_ceil(b),3);assert_eq!(a.div_ceil(-b), -2);assert_eq!((-a).div_ceil(b), -2);assert_eq!((-a).div_ceil(-b),3);

Ifrhs is positive, calculates the smallest value greater than orequal toself that is a multiple ofrhs. Ifrhs is negative,calculates the largest value less than or equal toself that is amultiple ofrhs.

§Panics

This function will panic ifrhs is zero.

§Overflow behavior

On overflow, this function will panic if overflow checks are enabled (default in debugmode) and wrap if overflow checks are disabled (default in release mode).

§Examples

#![feature(int_roundings)]assert_eq!(16_i8.next_multiple_of(8),16);assert_eq!(23_i8.next_multiple_of(8),24);assert_eq!(16_i8.next_multiple_of(-8),16);assert_eq!(23_i8.next_multiple_of(-8),16);assert_eq!((-16_i8).next_multiple_of(8), -16);assert_eq!((-23_i8).next_multiple_of(8), -16);assert_eq!((-16_i8).next_multiple_of(-8), -16);assert_eq!((-23_i8).next_multiple_of(-8), -24);

Ifrhs is positive, calculates the smallest value greater than orequal toself that is a multiple ofrhs. Ifrhs is negative,calculates the largest value less than or equal toself that is amultiple ofrhs. ReturnsNone ifrhs is zero or the operationwould result in overflow.

§Examples

#![feature(int_roundings)]assert_eq!(16_i8.checked_next_multiple_of(8),Some(16));assert_eq!(23_i8.checked_next_multiple_of(8),Some(24));assert_eq!(16_i8.checked_next_multiple_of(-8),Some(16));assert_eq!(23_i8.checked_next_multiple_of(-8),Some(16));assert_eq!((-16_i8).checked_next_multiple_of(8),Some(-16));assert_eq!((-23_i8).checked_next_multiple_of(8),Some(-16));assert_eq!((-16_i8).checked_next_multiple_of(-8),Some(-16));assert_eq!((-23_i8).checked_next_multiple_of(-8),Some(-24));assert_eq!(1_i8.checked_next_multiple_of(0),None);assert_eq!(i8::MAX.checked_next_multiple_of(2),None);

Returns the logarithm of the number with respect to an arbitrary base,rounded down.

This method might not be optimized owing to implementation details;ilog2 can produce results more efficiently for base 2, andilog10can produce results more efficiently for base 10.

§Panics

This function will panic ifself is less than or equal to zero,or ifbase is less than 2.

§Examples

assert_eq!(5i8.ilog(5),1);

Returns the base 2 logarithm of the number, rounded down.

§Panics

This function will panic ifself is less than or equal to zero.

§Examples

assert_eq!(2i8.ilog2(),1);

Returns the base 10 logarithm of the number, rounded down.

§Panics

This function will panic ifself is less than or equal to zero.

§Example

assert_eq!(10i8.ilog10(),1);

Returns the logarithm of the number with respect to an arbitrary base,rounded down.

ReturnsNone if the number is negative or zero, or if the base is not at least 2.

This method might not be optimized owing to implementation details;checked_ilog2 can produce results more efficiently for base 2, andchecked_ilog10 can produce results more efficiently for base 10.

§Examples

assert_eq!(5i8.checked_ilog(5),Some(1));

Returns the base 2 logarithm of the number, rounded down.

ReturnsNone if the number is negative or zero.

§Examples

assert_eq!(2i8.checked_ilog2(),Some(1));

Returns the base 10 logarithm of the number, rounded down.

ReturnsNone if the number is negative or zero.

§Example

assert_eq!(10i8.checked_ilog10(),Some(1));

Computes the absolute value ofself.

§Overflow behavior

The absolute value ofi8::MINcannot be represented as ani8,and attempting to calculate it will cause an overflow. This meansthat code in debug mode will trigger a panic on this case andoptimized code will returni8::MINwithout a panic. If you do not want this behavior, considerusingunsigned_abs instead.

§Examples

assert_eq!(10i8.abs(),10);assert_eq!((-10i8).abs(),10);

Computes the absolute difference betweenself andother.

This function always returns the correct answer without overflow orpanics by returning an unsigned integer.

§Examples

assert_eq!(100i8.abs_diff(80),20u8);assert_eq!(100i8.abs_diff(110),10u8);assert_eq!((-100i8).abs_diff(80),180u8);assert_eq!((-100i8).abs_diff(-120),20u8);assert_eq!(i8::MIN.abs_diff(i8::MAX), u8::MAX);

Returns a number representing sign ofself.

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

§Examples

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

Returnstrue ifself is positive andfalse if the number is zero ornegative.

§Examples

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

Returnstrue ifself is negative andfalse if the number is zero orpositive.

§Examples

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

Returns the memory representation of this integer as a byte array inbig-endian (network) byte order.

Note: This function is meaningless oni8. Byte order does not exist as aconcept for byte-sized integers. This function is only provided in symmetrywith larger integer types. You can cast from and tou8 usingcast_signed andcast_unsigned.

§Examples

letbytes =0x12i8.to_be_bytes();assert_eq!(bytes, [0x12]);

Returns the memory representation of this integer as a byte array inlittle-endian byte order.

Note: This function is meaningless oni8. Byte order does not exist as aconcept for byte-sized integers. This function is only provided in symmetrywith larger integer types. You can cast from and tou8 usingcast_signed andcast_unsigned.

§Examples

letbytes =0x12i8.to_le_bytes();assert_eq!(bytes, [0x12]);

Returns the memory representation of this integer as a byte array innative byte order.

As the target platform’s native endianness is used, portable codeshould useto_be_bytes orto_le_bytes, as appropriate,instead.

Note: This function is meaningless oni8. Byte order does not exist as aconcept for byte-sized integers. This function is only provided in symmetrywith larger integer types. You can cast from and tou8 usingcast_signed andcast_unsigned.

§Examples

letbytes =0x12i8.to_ne_bytes();assert_eq!(    bytes,ifcfg!(target_endian ="big") {        [0x12]    }else{        [0x12]    });

Creates an integer value from its representation as a byte array inbig endian.

Note: This function is meaningless oni8. Byte order does not exist as aconcept for byte-sized integers. This function is only provided in symmetrywith larger integer types. You can cast from and tou8 usingcast_signed andcast_unsigned.

§Examples

letvalue = i8::from_be_bytes([0x12]);assert_eq!(value,0x12);

When starting from a slice rather than an array, fallible conversion APIs can be used:

fnread_be_i8(input:&mut &[u8]) -> i8 {let(int_bytes, rest) = input.split_at(size_of::<i8>());*input = rest;    i8::from_be_bytes(int_bytes.try_into().unwrap())}

Creates an integer value from its representation as a byte array inlittle endian.

Note: This function is meaningless oni8. Byte order does not exist as aconcept for byte-sized integers. This function is only provided in symmetrywith larger integer types. You can cast from and tou8 usingcast_signed andcast_unsigned.

§Examples

letvalue = i8::from_le_bytes([0x12]);assert_eq!(value,0x12);

When starting from a slice rather than an array, fallible conversion APIs can be used:

fnread_le_i8(input:&mut &[u8]) -> i8 {let(int_bytes, rest) = input.split_at(size_of::<i8>());*input = rest;    i8::from_le_bytes(int_bytes.try_into().unwrap())}

Creates an integer value from its memory representation as a bytearray in native endianness.

As the target platform’s native endianness is used, portable codelikely wants to usefrom_be_bytes orfrom_le_bytes, asappropriate instead.

Note: This function is meaningless oni8. Byte order does not exist as aconcept for byte-sized integers. This function is only provided in symmetrywith larger integer types. You can cast from and tou8 usingcast_signed andcast_unsigned.

§Examples

letvalue = i8::from_ne_bytes(ifcfg!(target_endian ="big") {    [0x12]}else{    [0x12]});assert_eq!(value,0x12);

When starting from a slice rather than an array, fallible conversion APIs can be used:

fnread_ne_i8(input:&mut &[u8]) -> i8 {let(int_bytes, rest) = input.split_at(size_of::<i8>());*input = rest;    i8::from_ne_bytes(int_bytes.try_into().unwrap())}

New code should prefer to usei8::MIN instead.

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

New code should prefer to usei8::MAX instead.

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

Clamps this number to a symmetric range centred around zero.

The method clamps the number’s magnitude (absolute value) to be at mostlimit.

This is functionally equivalent toself.clamp(-limit, limit), but is moreexplicit about the intent.

§Examples

#![feature(clamp_magnitude)]assert_eq!(120i8.clamp_magnitude(100),100);assert_eq!(-120i8.clamp_magnitude(100), -100);assert_eq!(80i8.clamp_magnitude(100),80);assert_eq!(-80i8.clamp_magnitude(100), -80);

Calculates the midpoint (average) betweenself andrhs.

midpoint(a, b) is(a + b) / 2 as if it were performed in asufficiently-large signed integral type. This implies that the result isalways rounded towards zero and that no overflow will ever occur.

§Examples

assert_eq!(0i8.midpoint(4),2);assert_eq!((-1i8).midpoint(2),0);assert_eq!((-7i8).midpoint(0), -3);assert_eq!(0i8.midpoint(-7), -3);assert_eq!(0i8.midpoint(7),3);

Parses an integer from a string slice with digits in a given base.

The string is expected to be an optional+ or-sign followed by only digits. Leading and trailing non-digit characters (includingwhitespace) represent an error. Underscores (which are accepted in Rust literals)also represent an error.

Digits are a subset of these characters, depending onradix:

• 0-9
• a-z
• A-Z

§Panics

This function panics ifradix is not in the range from 2 to 36.

§See also

If the string to be parsed is in base 10 (decimal),from_str orstr::parse can also be used.

§Examples

assert_eq!(i8::from_str_radix("A",16),Ok(10));

Trailing space returns error:

assert!(i8::from_str_radix("1 ",10).is_err());

Parses an integer from an ASCII-byte slice with decimal digits.

The characters are expected to be an optional+ or-sign followed by only digits. Leading and trailing non-digit characters (includingwhitespace) represent an error. Underscores (which are accepted in Rust literals)also represent an error.

§Examples

#![feature(int_from_ascii)]assert_eq!(i8::from_ascii(b"+10"),Ok(10));

Trailing space returns error:

assert!(i8::from_ascii(b"1 ").is_err());

Parses an integer from an ASCII-byte slice with digits in a given base.

The characters are expected to be an optional+ or-sign followed by only digits. Leading and trailing non-digit characters (includingwhitespace) represent an error. Underscores (which are accepted in Rust literals)also represent an error.

Digits are a subset of these characters, depending onradix:

• 0-9
• a-z
• A-Z

§Panics

This function panics ifradix is not in the range from 2 to 36.

§Examples

#![feature(int_from_ascii)]assert_eq!(i8::from_ascii_radix(b"A",16),Ok(10));

Trailing space returns error:

assert!(i8::from_ascii_radix(b"1 ",10).is_err());

Allows users to write an integer (in signed decimal format) into a variablebuf oftypeNumBuffer that is passed by the caller by mutable reference.

§Examples

#![feature(int_format_into)]usecore::fmt::NumBuffer;letn =0i8;letmutbuf = NumBuffer::new();assert_eq!(n.format_into(&mutbuf),"0");letn1 =32i8;assert_eq!(n1.format_into(&mutbuf),"32");letn2 = i8 :: MAX;assert_eq!(n2.format_into(&mutbuf), i8 :: MAX.to_string());

Format signed integers in the two’s-complement form.

Returns the default value of0

Converts abool toi8 losslessly.The resulting value is0 forfalse and1 fortrue values.

§Examples

assert_eq!(i8::from(true),1);assert_eq!(i8::from(false),0);

Converts ani8 into anAtomicI8.

Convertsi8 tof128 losslessly.

Convertsi8 tof16 losslessly.

Convertsi8 tof32 losslessly.

Convertsi8 tof64 losslessly.

Convertsi8 toi128 losslessly.

Convertsi8 toi16 losslessly.

Convertsi8 toi32 losslessly.

Convertsi8 toi64 losslessly.

Convertsi8 toisize losslessly.

Parses an integer from a string slice with decimal digits.

The characters are expected to be an optional+ or-sign followed by only digits. Leading and trailing non-digit characters (includingwhitespace) represent an error. Underscores (which are accepted in Rust literals)also represent an error.

§See also

For parsing numbers in other bases, such as binary or hexadecimal,seefrom_str_radix.

§Examples

usestd::str::FromStr;assert_eq!(i8::from_str("+10"),Ok(10));

Trailing space returns error:

assert!(i8::from_str("1 ").is_err());

Format signed integers in the two’s-complement form.

Format signed integers in the two’s-complement form.