Primitive Type i16 [−]
Operations and constants for signed 16-bits integers (i16
`i16` type)
Methods
impl i16
fn min_value() -> i16
Returns the smallest value that can be represented by this integer type.
fn max_value() -> i16
Returns the largest value that can be represented by this integer type.
fn from_str_radix(src: &str, radix: u32) -> Result<i16, 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)
`Err(ParseIntError)if the string did not represent a valid number. Otherwise,
` if the string did not represent a valid number.
Otherwise, Ok(n)
`Ok(n)where
` where n
`nis the integer represented by
` is the integer represented by src
`src`.
fn count_ones(self) -> u32
Returns the number of ones in the binary representation of self
`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
`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
`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
`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) -> i16
Shifts the bits to the left by a specified amount, n
`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) -> i16
Shifts the bits to the right by a specified amount, n
`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) -> i16
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: i16) -> i16
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: i16) -> i16
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) -> i16
Converts self
`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) -> i16
Converts self
`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: i16) -> Option<i16>
Checked integer addition. Computes self + other
`self + other, returning
`, returning None
`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: i16) -> Option<i16>
Checked integer subtraction. Computes self - other
`self - other, returning
`, returning
None
`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: i16) -> Option<i16>
Checked integer multiplication. Computes self * other
`self * other, returning
`, returning
None
`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: i16) -> Option<i16>
Checked integer division. Computes self / other
`self / other, returning
`, returning None
`Noneif
`
if other == 0
`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: i16) -> i16
Saturating integer addition. Computes self + other
`self + other`, saturating at
the numeric bounds instead of overflowing.
fn saturating_sub(self, other: i16) -> i16
Saturating integer subtraction. Computes self - other
`self - other`, saturating
at the numeric bounds instead of overflowing.
fn wrapping_add(self, rhs: i16) -> i16
Wrapping (modular) addition. Computes self + other
`self + other`,
wrapping around at the boundary of the type.
fn wrapping_sub(self, rhs: i16) -> i16
Wrapping (modular) subtraction. Computes self - other
`self - other`,
wrapping around at the boundary of the type.
fn wrapping_mul(self, rhs: i16) -> i16
Wrapping (modular) multiplication. Computes self * other
`self *
other`, wrapping around at the boundary of the type.
fn wrapping_div(self, rhs: i16) -> i16
Wrapping (modular) division. Computes floor(self / other)
`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
`MIN / -1on a signed type (where
` on a signed type (where MIN
`MINis the negative minimal value for the type); this is equivalent to
` is the
negative minimal value for the type); this is equivalent
to -MIN
`-MIN, a positive value that is too large to represent in the type. In such a case, this function returns
`, a positive value that is too large to represent
in the type. In such a case, this function returns MIN
`MIN`
itself..
fn wrapping_rem(self, rhs: i16) -> i16
Wrapping (modular) remainder. Computes self % other
`self % other`,
wrapping around at the boundary of the type.
Such wrap-around never actually occurs mathematically;
implementation artifacts make x % y
`x % yillegal for
` illegal for MIN / -1
`MIN /
-1on a signed type illegal (where
` on a signed type illegal (where MIN
`MINis the negative minimal value). In such a case, this function returns
` is the negative
minimal value). In such a case, this function returns 0
`0`.
fn wrapping_neg(self) -> i16
Wrapping (modular) negation. Computes -self
`-self`,
wrapping around at the boundary of the type.
The only case where such wrapping can occur is when one
negates MIN
`MINon a signed type (where
` on a signed type (where MIN
`MINis 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
` 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
`MIN` itself.
fn wrapping_shl(self, rhs: u32) -> i16
Panic-free bitwise shift-left; yields self << mask(rhs)
`self << mask(rhs), where
`,
where mask
`maskremoves any high-order bits of
` removes any high-order bits of rhs
`rhs` that
would cause the shift to exceed the bitwidth of the type.
fn wrapping_shr(self, rhs: u32) -> i16
Panic-free bitwise shift-left; yields self >> mask(rhs)
`self >> mask(rhs), where
`,
where mask
`maskremoves any high-order bits of
` removes any high-order bits of rhs
`rhs` that
would cause the shift to exceed the bitwidth of the type.
fn pow(self, exp: u32) -> i16
Raises self to the power of exp
`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) -> i16
Computes the absolute value of self
`self`.
Overflow behavior
The absolute value of i32::min_value()
`i32::min_value()cannot be represented as an
` cannot be represented as an
i32
`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
`, 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()
`i32::min_value()` without a panic.
fn signum(self) -> i16
Returns a number representing sign of self
`self`.
0
`0` if the number is zero1
`1` if the number is positive-1
`-1` if the number is negative
fn is_positive(self) -> bool
Returns true
`trueif
` if self
`selfis positive and
` is positive and false
`false` if the number
is zero or negative.
fn is_negative(self) -> bool
Returns true
`trueif
` if self
`selfis negative and
` is negative and false
`false` if the number
is zero or positive.