NonZero in std::num - Rust (original) (raw)
Struct NonZero
1.79.0 · Source
pub struct NonZero<T>(/* private fields */)
where
T: ZeroablePrimitive;Expand description
A value that is known not to equal zero.
This enables some memory layout optimization. For example, Option<NonZero<u32>> is the same size as u32:
use core::{mem::size_of, num::NonZero};
assert_eq!(size_of::<Option<NonZero<u32>>>(), size_of::<u32>());§Layout
NonZero<T> is guaranteed to have the same layout and bit validity as Twith the exception that the all-zero bit pattern is invalid.Option<NonZero<T>> is guaranteed to be compatible with T, including in FFI.
Thanks to the null pointer optimization, NonZero<T> andOption<NonZero<T>> are guaranteed to have the same size and alignment:
use std::num::NonZero;
assert_eq!(size_of::<NonZero<u32>>(), size_of::<Option<NonZero<u32>>>());
assert_eq!(align_of::<NonZero<u32>>(), align_of::<Option<NonZero<u32>>>());1.28.0 (const: 1.47.0) · Source
Creates a non-zero if the given value is not zero.
1.28.0 (const: 1.28.0) · Source
Creates a non-zero without checking whether the value is non-zero. This results in undefined behavior if the value is zero.
§Safety
The value must not be zero.
🔬This is a nightly-only experimental API. (nonzero_from_mut #106290)
Converts a reference to a non-zero mutable reference if the referenced value is not zero.
🔬This is a nightly-only experimental API. (nonzero_from_mut #106290)
Converts a mutable reference to a non-zero mutable reference without checking whether the referenced value is non-zero. This results in undefined behavior if the referenced value is zero.
§Safety
The referenced value must not be zero.
1.28.0 (const: 1.34.0) · Source
Returns the contained value as a primitive type.
1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to u8::BITS.
§Examples
assert_eq!(NonZero::<u8>::BITS, u8::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, 1.
§Examples
assert_eq!(NonZero::<u8>::MIN.get(), 1u8);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to u8::MAX.
§Examples
assert_eq!(NonZero::<u8>::MAX.get(), u8::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u8>::new(u8::MAX)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u8>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<u8>::new(0b100_0000)?;
let b = NonZero::<u8>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x82u8)?;
let m = NonZero::new(0xa)?;
assert_eq!(n.rotate_left(2), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xau8)?;
let m = NonZero::new(0x82)?;
assert_eq!(n.rotate_right(2), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12u8)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x12)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12u8)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU8;
let n = NonZero::new(0x1Au8)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroU8::from_be(n), n)
} else {
assert_eq!(NonZeroU8::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU8;
let n = NonZero::new(0x1Au8)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroU8::from_le(n), n)
} else {
assert_eq!(NonZeroU8::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au8)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au8)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let one = NonZero::new(1u8)?;
let two = NonZero::new(2u8)?;
let max = NonZero::new(u8::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Return NonZero::::MAX on overflow.
§Examples
let one = NonZero::new(1u8)?;
let two = NonZero::new(2u8)?;
let max = NonZero::new(u8::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Adds an unsigned integer to a non-zero value, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself + rhs > u8::MAX.
§Examples
#![feature(nonzero_ops)]
let one = NonZero::new(1u8)?;
let two = NonZero::new(2u8)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });1.64.0 (const: 1.64.0) · Source
Returns the smallest power of two greater than or equal to self. Checks for overflow and returns Noneif the next power of two is greater than the type’s maximum value. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u8)?;
let three = NonZero::new(3u8)?;
let four = NonZero::new(4u8)?;
let max = NonZero::new(u8::MAX)?;
assert_eq!(Some(two), two.checked_next_power_of_two() );
assert_eq!(Some(four), three.checked_next_power_of_two() );
assert_eq!(None, max.checked_next_power_of_two() );1.67.0 (const: 1.67.0) · Source
Returns the base 2 logarithm of the number, rounded down.
This is the same operation asu8::ilog2, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(7u8)?.ilog2(), 2);
assert_eq!(NonZero::new(8u8)?.ilog2(), 3);
assert_eq!(NonZero::new(9u8)?.ilog2(), 3);1.67.0 (const: 1.67.0) · Source
Returns the base 10 logarithm of the number, rounded down.
This is the same operation asu8::ilog10, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(99u8)?.ilog10(), 1);
assert_eq!(NonZero::new(100u8)?.ilog10(), 2);
assert_eq!(NonZero::new(101u8)?.ilog10(), 2);1.85.0 (const: 1.85.0) · Source
Calculates the middle point of self and rhs.
midpoint(a, b) is (a + b) >> 1 as if it were performed in a sufficiently-large signed integral type. This implies that the result is always rounded towards negative infinity and that no overflow will ever occur.
§Examples
let one = NonZero::new(1u8)?;
let two = NonZero::new(2u8)?;
let four = NonZero::new(4u8)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);1.59.0 (const: 1.59.0) · Source
Returns true if and only if self == (1 << k) for some k.
On many architectures, this function can perform better than is_power_of_two()on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let eight = NonZero::new(8u8)?;
assert!(eight.is_power_of_two());
let ten = NonZero::new(10u8)?;
assert!(!ten.is_power_of_two());1.84.0 (const: 1.84.0) · Source
Returns the square root of the number, rounded down.
§Examples
Basic usage:
let ten = NonZero::new(10u8)?;
let three = NonZero::new(3u8)?;
assert_eq!(ten.isqrt(), three);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as a signed integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::<u8>::MAX;
assert_eq!(n.cast_signed(), NonZero::new(-1i8).unwrap());1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u8)?;
let four = NonZero::new(4u8)?;
let max = NonZero::new(u8::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2u8)?;
let four = NonZero::new(4u8)?;
let max = NonZero::new(u8::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > u8::MAX.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2u8)?;
let four = NonZero::new(4u8)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3u8)?;
let twenty_seven = NonZero::new(27u8)?;
let half_max = NonZero::new(u8::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3u8)?;
let twenty_seven = NonZero::new(27u8)?;
let max = NonZero::new(u8::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));🔬This is a nightly-only experimental API. (unsigned_nonzero_div_ceil #132968)
Calculates the quotient of self and rhs, rounding the result towards positive infinity.
The result is guaranteed to be non-zero.
§Examples
let one = NonZero::new(1u8).unwrap();
let max = NonZero::new(u8::MAX).unwrap();
assert_eq!(one.div_ceil(max), one);
let two = NonZero::new(2u8).unwrap();
let three = NonZero::new(3u8).unwrap();
assert_eq!(three.div_ceil(two), two);1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to u16::BITS.
§Examples
assert_eq!(NonZero::<u16>::BITS, u16::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, 1.
§Examples
assert_eq!(NonZero::<u16>::MIN.get(), 1u16);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to u16::MAX.
§Examples
assert_eq!(NonZero::<u16>::MAX.get(), u16::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u16>::new(u16::MAX)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u16>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<u16>::new(0b100_0000)?;
let b = NonZero::<u16>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xa003u16)?;
let m = NonZero::new(0x3a)?;
assert_eq!(n.rotate_left(4), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x3au16)?;
let m = NonZero::new(0xa003)?;
assert_eq!(n.rotate_right(4), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234u16)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x3412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234u16)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU16;
let n = NonZero::new(0x1Au16)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroU16::from_be(n), n)
} else {
assert_eq!(NonZeroU16::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU16;
let n = NonZero::new(0x1Au16)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroU16::from_le(n), n)
} else {
assert_eq!(NonZeroU16::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au16)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au16)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let one = NonZero::new(1u16)?;
let two = NonZero::new(2u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Return NonZero::::MAX on overflow.
§Examples
let one = NonZero::new(1u16)?;
let two = NonZero::new(2u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Adds an unsigned integer to a non-zero value, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself + rhs > u16::MAX.
§Examples
#![feature(nonzero_ops)]
let one = NonZero::new(1u16)?;
let two = NonZero::new(2u16)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });1.64.0 (const: 1.64.0) · Source
Returns the smallest power of two greater than or equal to self. Checks for overflow and returns Noneif the next power of two is greater than the type’s maximum value. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u16)?;
let three = NonZero::new(3u16)?;
let four = NonZero::new(4u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(Some(two), two.checked_next_power_of_two() );
assert_eq!(Some(four), three.checked_next_power_of_two() );
assert_eq!(None, max.checked_next_power_of_two() );1.67.0 (const: 1.67.0) · Source
Returns the base 2 logarithm of the number, rounded down.
This is the same operation asu16::ilog2, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(7u16)?.ilog2(), 2);
assert_eq!(NonZero::new(8u16)?.ilog2(), 3);
assert_eq!(NonZero::new(9u16)?.ilog2(), 3);1.67.0 (const: 1.67.0) · Source
Returns the base 10 logarithm of the number, rounded down.
This is the same operation asu16::ilog10, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(99u16)?.ilog10(), 1);
assert_eq!(NonZero::new(100u16)?.ilog10(), 2);
assert_eq!(NonZero::new(101u16)?.ilog10(), 2);1.85.0 (const: 1.85.0) · Source
Calculates the middle point of self and rhs.
midpoint(a, b) is (a + b) >> 1 as if it were performed in a sufficiently-large signed integral type. This implies that the result is always rounded towards negative infinity and that no overflow will ever occur.
§Examples
let one = NonZero::new(1u16)?;
let two = NonZero::new(2u16)?;
let four = NonZero::new(4u16)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);1.59.0 (const: 1.59.0) · Source
Returns true if and only if self == (1 << k) for some k.
On many architectures, this function can perform better than is_power_of_two()on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let eight = NonZero::new(8u16)?;
assert!(eight.is_power_of_two());
let ten = NonZero::new(10u16)?;
assert!(!ten.is_power_of_two());1.84.0 (const: 1.84.0) · Source
Returns the square root of the number, rounded down.
§Examples
Basic usage:
let ten = NonZero::new(10u16)?;
let three = NonZero::new(3u16)?;
assert_eq!(ten.isqrt(), three);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as a signed integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::<u16>::MAX;
assert_eq!(n.cast_signed(), NonZero::new(-1i16).unwrap());1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u16)?;
let four = NonZero::new(4u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2u16)?;
let four = NonZero::new(4u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > u16::MAX.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2u16)?;
let four = NonZero::new(4u16)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3u16)?;
let twenty_seven = NonZero::new(27u16)?;
let half_max = NonZero::new(u16::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3u16)?;
let twenty_seven = NonZero::new(27u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));🔬This is a nightly-only experimental API. (unsigned_nonzero_div_ceil #132968)
Calculates the quotient of self and rhs, rounding the result towards positive infinity.
The result is guaranteed to be non-zero.
§Examples
let one = NonZero::new(1u16).unwrap();
let max = NonZero::new(u16::MAX).unwrap();
assert_eq!(one.div_ceil(max), one);
let two = NonZero::new(2u16).unwrap();
let three = NonZero::new(3u16).unwrap();
assert_eq!(three.div_ceil(two), two);1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to u32::BITS.
§Examples
assert_eq!(NonZero::<u32>::BITS, u32::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, 1.
§Examples
assert_eq!(NonZero::<u32>::MIN.get(), 1u32);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to u32::MAX.
§Examples
assert_eq!(NonZero::<u32>::MAX.get(), u32::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u32>::new(u32::MAX)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u32>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<u32>::new(0b100_0000)?;
let b = NonZero::<u32>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x10000b3u32)?;
let m = NonZero::new(0xb301)?;
assert_eq!(n.rotate_left(8), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xb301u32)?;
let m = NonZero::new(0x10000b3)?;
assert_eq!(n.rotate_right(8), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12345678u32)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x78563412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12345678u32)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x1e6a2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU32;
let n = NonZero::new(0x1Au32)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroU32::from_be(n), n)
} else {
assert_eq!(NonZeroU32::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU32;
let n = NonZero::new(0x1Au32)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroU32::from_le(n), n)
} else {
assert_eq!(NonZeroU32::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au32)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au32)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let one = NonZero::new(1u32)?;
let two = NonZero::new(2u32)?;
let max = NonZero::new(u32::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Return NonZero::::MAX on overflow.
§Examples
let one = NonZero::new(1u32)?;
let two = NonZero::new(2u32)?;
let max = NonZero::new(u32::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Adds an unsigned integer to a non-zero value, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself + rhs > u32::MAX.
§Examples
#![feature(nonzero_ops)]
let one = NonZero::new(1u32)?;
let two = NonZero::new(2u32)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });1.64.0 (const: 1.64.0) · Source
Returns the smallest power of two greater than or equal to self. Checks for overflow and returns Noneif the next power of two is greater than the type’s maximum value. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u32)?;
let three = NonZero::new(3u32)?;
let four = NonZero::new(4u32)?;
let max = NonZero::new(u32::MAX)?;
assert_eq!(Some(two), two.checked_next_power_of_two() );
assert_eq!(Some(four), three.checked_next_power_of_two() );
assert_eq!(None, max.checked_next_power_of_two() );1.67.0 (const: 1.67.0) · Source
Returns the base 2 logarithm of the number, rounded down.
This is the same operation asu32::ilog2, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(7u32)?.ilog2(), 2);
assert_eq!(NonZero::new(8u32)?.ilog2(), 3);
assert_eq!(NonZero::new(9u32)?.ilog2(), 3);1.67.0 (const: 1.67.0) · Source
Returns the base 10 logarithm of the number, rounded down.
This is the same operation asu32::ilog10, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(99u32)?.ilog10(), 1);
assert_eq!(NonZero::new(100u32)?.ilog10(), 2);
assert_eq!(NonZero::new(101u32)?.ilog10(), 2);1.85.0 (const: 1.85.0) · Source
Calculates the middle point of self and rhs.
midpoint(a, b) is (a + b) >> 1 as if it were performed in a sufficiently-large signed integral type. This implies that the result is always rounded towards negative infinity and that no overflow will ever occur.
§Examples
let one = NonZero::new(1u32)?;
let two = NonZero::new(2u32)?;
let four = NonZero::new(4u32)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);1.59.0 (const: 1.59.0) · Source
Returns true if and only if self == (1 << k) for some k.
On many architectures, this function can perform better than is_power_of_two()on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let eight = NonZero::new(8u32)?;
assert!(eight.is_power_of_two());
let ten = NonZero::new(10u32)?;
assert!(!ten.is_power_of_two());1.84.0 (const: 1.84.0) · Source
Returns the square root of the number, rounded down.
§Examples
Basic usage:
let ten = NonZero::new(10u32)?;
let three = NonZero::new(3u32)?;
assert_eq!(ten.isqrt(), three);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as a signed integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::<u32>::MAX;
assert_eq!(n.cast_signed(), NonZero::new(-1i32).unwrap());1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u32)?;
let four = NonZero::new(4u32)?;
let max = NonZero::new(u32::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2u32)?;
let four = NonZero::new(4u32)?;
let max = NonZero::new(u32::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > u32::MAX.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2u32)?;
let four = NonZero::new(4u32)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3u32)?;
let twenty_seven = NonZero::new(27u32)?;
let half_max = NonZero::new(u32::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3u32)?;
let twenty_seven = NonZero::new(27u32)?;
let max = NonZero::new(u32::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));🔬This is a nightly-only experimental API. (unsigned_nonzero_div_ceil #132968)
Calculates the quotient of self and rhs, rounding the result towards positive infinity.
The result is guaranteed to be non-zero.
§Examples
let one = NonZero::new(1u32).unwrap();
let max = NonZero::new(u32::MAX).unwrap();
assert_eq!(one.div_ceil(max), one);
let two = NonZero::new(2u32).unwrap();
let three = NonZero::new(3u32).unwrap();
assert_eq!(three.div_ceil(two), two);1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to u64::BITS.
§Examples
assert_eq!(NonZero::<u64>::BITS, u64::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, 1.
§Examples
assert_eq!(NonZero::<u64>::MIN.get(), 1u64);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to u64::MAX.
§Examples
assert_eq!(NonZero::<u64>::MAX.get(), u64::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u64>::new(u64::MAX)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u64>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<u64>::new(0b100_0000)?;
let b = NonZero::<u64>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xaa00000000006e1u64)?;
let m = NonZero::new(0x6e10aa)?;
assert_eq!(n.rotate_left(12), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x6e10aau64)?;
let m = NonZero::new(0xaa00000000006e1)?;
assert_eq!(n.rotate_right(12), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234567890123456u64)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x5634129078563412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234567890123456u64)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x6a2c48091e6a2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU64;
let n = NonZero::new(0x1Au64)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroU64::from_be(n), n)
} else {
assert_eq!(NonZeroU64::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU64;
let n = NonZero::new(0x1Au64)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroU64::from_le(n), n)
} else {
assert_eq!(NonZeroU64::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au64)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au64)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let one = NonZero::new(1u64)?;
let two = NonZero::new(2u64)?;
let max = NonZero::new(u64::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Return NonZero::::MAX on overflow.
§Examples
let one = NonZero::new(1u64)?;
let two = NonZero::new(2u64)?;
let max = NonZero::new(u64::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Adds an unsigned integer to a non-zero value, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself + rhs > u64::MAX.
§Examples
#![feature(nonzero_ops)]
let one = NonZero::new(1u64)?;
let two = NonZero::new(2u64)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });1.64.0 (const: 1.64.0) · Source
Returns the smallest power of two greater than or equal to self. Checks for overflow and returns Noneif the next power of two is greater than the type’s maximum value. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u64)?;
let three = NonZero::new(3u64)?;
let four = NonZero::new(4u64)?;
let max = NonZero::new(u64::MAX)?;
assert_eq!(Some(two), two.checked_next_power_of_two() );
assert_eq!(Some(four), three.checked_next_power_of_two() );
assert_eq!(None, max.checked_next_power_of_two() );1.67.0 (const: 1.67.0) · Source
Returns the base 2 logarithm of the number, rounded down.
This is the same operation asu64::ilog2, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(7u64)?.ilog2(), 2);
assert_eq!(NonZero::new(8u64)?.ilog2(), 3);
assert_eq!(NonZero::new(9u64)?.ilog2(), 3);1.67.0 (const: 1.67.0) · Source
Returns the base 10 logarithm of the number, rounded down.
This is the same operation asu64::ilog10, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(99u64)?.ilog10(), 1);
assert_eq!(NonZero::new(100u64)?.ilog10(), 2);
assert_eq!(NonZero::new(101u64)?.ilog10(), 2);1.85.0 (const: 1.85.0) · Source
Calculates the middle point of self and rhs.
midpoint(a, b) is (a + b) >> 1 as if it were performed in a sufficiently-large signed integral type. This implies that the result is always rounded towards negative infinity and that no overflow will ever occur.
§Examples
let one = NonZero::new(1u64)?;
let two = NonZero::new(2u64)?;
let four = NonZero::new(4u64)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);1.59.0 (const: 1.59.0) · Source
Returns true if and only if self == (1 << k) for some k.
On many architectures, this function can perform better than is_power_of_two()on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let eight = NonZero::new(8u64)?;
assert!(eight.is_power_of_two());
let ten = NonZero::new(10u64)?;
assert!(!ten.is_power_of_two());1.84.0 (const: 1.84.0) · Source
Returns the square root of the number, rounded down.
§Examples
Basic usage:
let ten = NonZero::new(10u64)?;
let three = NonZero::new(3u64)?;
assert_eq!(ten.isqrt(), three);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as a signed integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::<u64>::MAX;
assert_eq!(n.cast_signed(), NonZero::new(-1i64).unwrap());1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u64)?;
let four = NonZero::new(4u64)?;
let max = NonZero::new(u64::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2u64)?;
let four = NonZero::new(4u64)?;
let max = NonZero::new(u64::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > u64::MAX.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2u64)?;
let four = NonZero::new(4u64)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3u64)?;
let twenty_seven = NonZero::new(27u64)?;
let half_max = NonZero::new(u64::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3u64)?;
let twenty_seven = NonZero::new(27u64)?;
let max = NonZero::new(u64::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));🔬This is a nightly-only experimental API. (unsigned_nonzero_div_ceil #132968)
Calculates the quotient of self and rhs, rounding the result towards positive infinity.
The result is guaranteed to be non-zero.
§Examples
let one = NonZero::new(1u64).unwrap();
let max = NonZero::new(u64::MAX).unwrap();
assert_eq!(one.div_ceil(max), one);
let two = NonZero::new(2u64).unwrap();
let three = NonZero::new(3u64).unwrap();
assert_eq!(three.div_ceil(two), two);1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to u128::BITS.
§Examples
assert_eq!(NonZero::<u128>::BITS, u128::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, 1.
§Examples
assert_eq!(NonZero::<u128>::MIN.get(), 1u128);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to u128::MAX.
§Examples
assert_eq!(NonZero::<u128>::MAX.get(), u128::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u128>::new(u128::MAX)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u128>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<u128>::new(0b100_0000)?;
let b = NonZero::<u128>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x13f40000000000000000000000004f76u128)?;
let m = NonZero::new(0x4f7613f4)?;
assert_eq!(n.rotate_left(16), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x4f7613f4u128)?;
let m = NonZero::new(0x13f40000000000000000000000004f76)?;
assert_eq!(n.rotate_right(16), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12345678901234567890123456789012u128)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x12907856341290785634129078563412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12345678901234567890123456789012u128)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x48091e6a2c48091e6a2c48091e6a2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU128;
let n = NonZero::new(0x1Au128)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroU128::from_be(n), n)
} else {
assert_eq!(NonZeroU128::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU128;
let n = NonZero::new(0x1Au128)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroU128::from_le(n), n)
} else {
assert_eq!(NonZeroU128::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au128)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au128)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let one = NonZero::new(1u128)?;
let two = NonZero::new(2u128)?;
let max = NonZero::new(u128::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Return NonZero::::MAX on overflow.
§Examples
let one = NonZero::new(1u128)?;
let two = NonZero::new(2u128)?;
let max = NonZero::new(u128::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Adds an unsigned integer to a non-zero value, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself + rhs > u128::MAX.
§Examples
#![feature(nonzero_ops)]
let one = NonZero::new(1u128)?;
let two = NonZero::new(2u128)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });1.64.0 (const: 1.64.0) · Source
Returns the smallest power of two greater than or equal to self. Checks for overflow and returns Noneif the next power of two is greater than the type’s maximum value. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u128)?;
let three = NonZero::new(3u128)?;
let four = NonZero::new(4u128)?;
let max = NonZero::new(u128::MAX)?;
assert_eq!(Some(two), two.checked_next_power_of_two() );
assert_eq!(Some(four), three.checked_next_power_of_two() );
assert_eq!(None, max.checked_next_power_of_two() );1.67.0 (const: 1.67.0) · Source
Returns the base 2 logarithm of the number, rounded down.
This is the same operation asu128::ilog2, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(7u128)?.ilog2(), 2);
assert_eq!(NonZero::new(8u128)?.ilog2(), 3);
assert_eq!(NonZero::new(9u128)?.ilog2(), 3);1.67.0 (const: 1.67.0) · Source
Returns the base 10 logarithm of the number, rounded down.
This is the same operation asu128::ilog10, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(99u128)?.ilog10(), 1);
assert_eq!(NonZero::new(100u128)?.ilog10(), 2);
assert_eq!(NonZero::new(101u128)?.ilog10(), 2);1.85.0 (const: 1.85.0) · Source
Calculates the middle point of self and rhs.
midpoint(a, b) is (a + b) >> 1 as if it were performed in a sufficiently-large signed integral type. This implies that the result is always rounded towards negative infinity and that no overflow will ever occur.
§Examples
let one = NonZero::new(1u128)?;
let two = NonZero::new(2u128)?;
let four = NonZero::new(4u128)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);1.59.0 (const: 1.59.0) · Source
Returns true if and only if self == (1 << k) for some k.
On many architectures, this function can perform better than is_power_of_two()on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let eight = NonZero::new(8u128)?;
assert!(eight.is_power_of_two());
let ten = NonZero::new(10u128)?;
assert!(!ten.is_power_of_two());1.84.0 (const: 1.84.0) · Source
Returns the square root of the number, rounded down.
§Examples
Basic usage:
let ten = NonZero::new(10u128)?;
let three = NonZero::new(3u128)?;
assert_eq!(ten.isqrt(), three);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as a signed integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::<u128>::MAX;
assert_eq!(n.cast_signed(), NonZero::new(-1i128).unwrap());1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u128)?;
let four = NonZero::new(4u128)?;
let max = NonZero::new(u128::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2u128)?;
let four = NonZero::new(4u128)?;
let max = NonZero::new(u128::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > u128::MAX.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2u128)?;
let four = NonZero::new(4u128)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3u128)?;
let twenty_seven = NonZero::new(27u128)?;
let half_max = NonZero::new(u128::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3u128)?;
let twenty_seven = NonZero::new(27u128)?;
let max = NonZero::new(u128::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));🔬This is a nightly-only experimental API. (unsigned_nonzero_div_ceil #132968)
Calculates the quotient of self and rhs, rounding the result towards positive infinity.
The result is guaranteed to be non-zero.
§Examples
let one = NonZero::new(1u128).unwrap();
let max = NonZero::new(u128::MAX).unwrap();
assert_eq!(one.div_ceil(max), one);
let two = NonZero::new(2u128).unwrap();
let three = NonZero::new(3u128).unwrap();
assert_eq!(three.div_ceil(two), two);1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to usize::BITS.
§Examples
assert_eq!(NonZero::<usize>::BITS, usize::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, 1.
§Examples
assert_eq!(NonZero::<usize>::MIN.get(), 1usize);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to usize::MAX.
§Examples
assert_eq!(NonZero::<usize>::MAX.get(), usize::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<usize>::new(usize::MAX)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<usize>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<usize>::new(0b100_0000)?;
let b = NonZero::<usize>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xaa00000000006e1usize)?;
let m = NonZero::new(0x6e10aa)?;
assert_eq!(n.rotate_left(12), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x6e10aausize)?;
let m = NonZero::new(0xaa00000000006e1)?;
assert_eq!(n.rotate_right(12), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234567890123456usize)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x5634129078563412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234567890123456usize)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x6a2c48091e6a2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroUsize;
let n = NonZero::new(0x1Ausize)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroUsize::from_be(n), n)
} else {
assert_eq!(NonZeroUsize::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroUsize;
let n = NonZero::new(0x1Ausize)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroUsize::from_le(n), n)
} else {
assert_eq!(NonZeroUsize::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ausize)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ausize)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let one = NonZero::new(1usize)?;
let two = NonZero::new(2usize)?;
let max = NonZero::new(usize::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));1.64.0 (const: 1.64.0) · Source
Adds an unsigned integer to a non-zero value. Return NonZero::::MAX on overflow.
§Examples
let one = NonZero::new(1usize)?;
let two = NonZero::new(2usize)?;
let max = NonZero::new(usize::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Adds an unsigned integer to a non-zero value, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself + rhs > usize::MAX.
§Examples
#![feature(nonzero_ops)]
let one = NonZero::new(1usize)?;
let two = NonZero::new(2usize)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });1.64.0 (const: 1.64.0) · Source
Returns the smallest power of two greater than or equal to self. Checks for overflow and returns Noneif the next power of two is greater than the type’s maximum value. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2usize)?;
let three = NonZero::new(3usize)?;
let four = NonZero::new(4usize)?;
let max = NonZero::new(usize::MAX)?;
assert_eq!(Some(two), two.checked_next_power_of_two() );
assert_eq!(Some(four), three.checked_next_power_of_two() );
assert_eq!(None, max.checked_next_power_of_two() );1.67.0 (const: 1.67.0) · Source
Returns the base 2 logarithm of the number, rounded down.
This is the same operation asusize::ilog2, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(7usize)?.ilog2(), 2);
assert_eq!(NonZero::new(8usize)?.ilog2(), 3);
assert_eq!(NonZero::new(9usize)?.ilog2(), 3);1.67.0 (const: 1.67.0) · Source
Returns the base 10 logarithm of the number, rounded down.
This is the same operation asusize::ilog10, except that it has no failure cases to worry about since this value can never be zero.
§Examples
assert_eq!(NonZero::new(99usize)?.ilog10(), 1);
assert_eq!(NonZero::new(100usize)?.ilog10(), 2);
assert_eq!(NonZero::new(101usize)?.ilog10(), 2);1.85.0 (const: 1.85.0) · Source
Calculates the middle point of self and rhs.
midpoint(a, b) is (a + b) >> 1 as if it were performed in a sufficiently-large signed integral type. This implies that the result is always rounded towards negative infinity and that no overflow will ever occur.
§Examples
let one = NonZero::new(1usize)?;
let two = NonZero::new(2usize)?;
let four = NonZero::new(4usize)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);1.59.0 (const: 1.59.0) · Source
Returns true if and only if self == (1 << k) for some k.
On many architectures, this function can perform better than is_power_of_two()on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let eight = NonZero::new(8usize)?;
assert!(eight.is_power_of_two());
let ten = NonZero::new(10usize)?;
assert!(!ten.is_power_of_two());1.84.0 (const: 1.84.0) · Source
Returns the square root of the number, rounded down.
§Examples
Basic usage:
let ten = NonZero::new(10usize)?;
let three = NonZero::new(3usize)?;
assert_eq!(ten.isqrt(), three);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as a signed integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::<usize>::MAX;
assert_eq!(n.cast_signed(), NonZero::new(-1isize).unwrap());1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2usize)?;
let four = NonZero::new(4usize)?;
let max = NonZero::new(usize::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2usize)?;
let four = NonZero::new(4usize)?;
let max = NonZero::new(usize::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > usize::MAX.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2usize)?;
let four = NonZero::new(4usize)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3usize)?;
let twenty_seven = NonZero::new(27usize)?;
let half_max = NonZero::new(usize::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3usize)?;
let twenty_seven = NonZero::new(27usize)?;
let max = NonZero::new(usize::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));🔬This is a nightly-only experimental API. (unsigned_nonzero_div_ceil #132968)
Calculates the quotient of self and rhs, rounding the result towards positive infinity.
The result is guaranteed to be non-zero.
§Examples
let one = NonZero::new(1usize).unwrap();
let max = NonZero::new(usize::MAX).unwrap();
assert_eq!(one.div_ceil(max), one);
let two = NonZero::new(2usize).unwrap();
let three = NonZero::new(3usize).unwrap();
assert_eq!(three.div_ceil(two), two);1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to i8::BITS.
§Examples
assert_eq!(NonZero::<i8>::BITS, i8::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, equal to i8::MIN.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i8>::MIN.get(), i8::MIN);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to i8::MAX.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i8>::MAX.get(), i8::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i8>::new(-1i8)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i8>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<i8>::new(0b100_0000)?;
let b = NonZero::<i8>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(-0x7ei8)?;
let m = NonZero::new(0xa)?;
assert_eq!(n.rotate_left(2), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xai8)?;
let m = NonZero::new(-0x7e)?;
assert_eq!(n.rotate_right(2), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12i8)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x12)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12i8)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI8;
let n = NonZero::new(0x1Ai8)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroI8::from_be(n), n)
} else {
assert_eq!(NonZeroI8::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI8;
let n = NonZero::new(0x1Ai8)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroI8::from_le(n), n)
} else {
assert_eq!(NonZeroI8::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai8)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai8)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self. See i8::absfor documentation on overflow behavior.
§Example
let pos = NonZero::new(1i8)?;
let neg = NonZero::new(-1i8)?;
assert_eq!(pos, pos.abs());
assert_eq!(pos, neg.abs());1.64.0 (const: 1.64.0) · Source
Checked absolute value. Checks for overflow and returns None ifself == NonZero::<i8>::MIN. The result cannot be zero.
§Example
let pos = NonZero::new(1i8)?;
let neg = NonZero::new(-1i8)?;
let min = NonZero::new(i8::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self, with overflow information, seei8::overflowing_abs.
§Example
let pos = NonZero::new(1i8)?;
let neg = NonZero::new(-1i8)?;
let min = NonZero::new(i8::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());1.64.0 (const: 1.64.0) · Source
Saturating absolute value, seei8::saturating_abs.
§Example
let pos = NonZero::new(1i8)?;
let neg = NonZero::new(-1i8)?;
let min = NonZero::new(i8::MIN)?;
let min_plus = NonZero::new(i8::MIN + 1)?;
let max = NonZero::new(i8::MAX)?;
assert_eq!(pos, pos.saturating_abs());
assert_eq!(pos, neg.saturating_abs());
assert_eq!(max, min.saturating_abs());
assert_eq!(max, min_plus.saturating_abs());1.64.0 (const: 1.64.0) · Source
Wrapping absolute value, seei8::wrapping_abs.
§Example
let pos = NonZero::new(1i8)?;
let neg = NonZero::new(-1i8)?;
let min = NonZero::new(i8::MIN)?;
assert_eq!(pos, pos.wrapping_abs());
assert_eq!(pos, neg.wrapping_abs());
assert_eq!(min, min.wrapping_abs());
assert_eq!(max, (-max).wrapping_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZero::new(1u8)?;
let i_pos = NonZero::new(1i8)?;
let i_neg = NonZero::new(-1i8)?;
let i_min = NonZero::new(i8::MIN)?;
let u_max = NonZero::new(u8::MAX / 2 + 1)?;
assert_eq!(u_pos, i_pos.unsigned_abs());
assert_eq!(u_pos, i_neg.unsigned_abs());
assert_eq!(u_max, i_min.unsigned_abs());1.71.0 (const: 1.71.0) · Source
Returns true if self is positive and false if the number is negative.
§Example
let pos_five = NonZero::new(5i8)?;
let neg_five = NonZero::new(-5i8)?;
assert!(pos_five.is_positive());
assert!(!neg_five.is_positive());1.71.0 (const: 1.71.0) · Source
Returns true if self is negative and false if the number is positive.
§Example
let pos_five = NonZero::new(5i8)?;
let neg_five = NonZero::new(-5i8)?;
assert!(neg_five.is_negative());
assert!(!pos_five.is_negative());1.71.0 (const: 1.71.0) · Source
Checked negation. Computes -self, returning None if self == NonZero::<i8>::MIN.
§Example
let pos_five = NonZero::new(5i8)?;
let neg_five = NonZero::new(-5i8)?;
let min = NonZero::new(i8::MIN)?;
assert_eq!(pos_five.checked_neg(), Some(neg_five));
assert_eq!(min.checked_neg(), None);1.71.0 (const: 1.71.0) · Source
Negates self, overflowing if this is equal to the minimum value.
See i8::overflowing_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i8)?;
let neg_five = NonZero::new(-5i8)?;
let min = NonZero::new(i8::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));1.71.0 (const: 1.71.0) · Source
Saturating negation. Computes -self, returning NonZero::::MAXif self == NonZero::<i8>::MINinstead of overflowing.
§Example
let pos_five = NonZero::new(5i8)?;
let neg_five = NonZero::new(-5i8)?;
let min = NonZero::new(i8::MIN)?;
let min_plus_one = NonZero::new(i8::MIN + 1)?;
let max = NonZero::new(i8::MAX)?;
assert_eq!(pos_five.saturating_neg(), neg_five);
assert_eq!(min.saturating_neg(), max);
assert_eq!(max.saturating_neg(), min_plus_one);1.71.0 (const: 1.71.0) · Source
Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.
See i8::wrapping_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i8)?;
let neg_five = NonZero::new(-5i8)?;
let min = NonZero::new(i8::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as an unsigned integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::new(-1i8).unwrap();
assert_eq!(n.cast_unsigned(), NonZero::<u8>::MAX);1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2i8)?;
let four = NonZero::new(4i8)?;
let max = NonZero::new(i8::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2i8)?;
let four = NonZero::new(4i8)?;
let max = NonZero::new(i8::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > i8::MAX, or self * rhs < i8::MIN.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2i8)?;
let four = NonZero::new(4i8)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3i8)?;
let twenty_seven = NonZero::new(27i8)?;
let half_max = NonZero::new(i8::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MIN or NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3i8)?;
let twenty_seven = NonZero::new(27i8)?;
let max = NonZero::new(i8::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to i16::BITS.
§Examples
assert_eq!(NonZero::<i16>::BITS, i16::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, equal to i16::MIN.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i16>::MIN.get(), i16::MIN);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to i16::MAX.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i16>::MAX.get(), i16::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i16>::new(-1i16)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i16>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<i16>::new(0b100_0000)?;
let b = NonZero::<i16>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(-0x5ffdi16)?;
let m = NonZero::new(0x3a)?;
assert_eq!(n.rotate_left(4), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x3ai16)?;
let m = NonZero::new(-0x5ffd)?;
assert_eq!(n.rotate_right(4), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234i16)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x3412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234i16)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI16;
let n = NonZero::new(0x1Ai16)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroI16::from_be(n), n)
} else {
assert_eq!(NonZeroI16::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI16;
let n = NonZero::new(0x1Ai16)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroI16::from_le(n), n)
} else {
assert_eq!(NonZeroI16::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai16)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai16)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self. See i16::absfor documentation on overflow behavior.
§Example
let pos = NonZero::new(1i16)?;
let neg = NonZero::new(-1i16)?;
assert_eq!(pos, pos.abs());
assert_eq!(pos, neg.abs());1.64.0 (const: 1.64.0) · Source
Checked absolute value. Checks for overflow and returns None ifself == NonZero::<i16>::MIN. The result cannot be zero.
§Example
let pos = NonZero::new(1i16)?;
let neg = NonZero::new(-1i16)?;
let min = NonZero::new(i16::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self, with overflow information, seei16::overflowing_abs.
§Example
let pos = NonZero::new(1i16)?;
let neg = NonZero::new(-1i16)?;
let min = NonZero::new(i16::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());1.64.0 (const: 1.64.0) · Source
Saturating absolute value, seei16::saturating_abs.
§Example
let pos = NonZero::new(1i16)?;
let neg = NonZero::new(-1i16)?;
let min = NonZero::new(i16::MIN)?;
let min_plus = NonZero::new(i16::MIN + 1)?;
let max = NonZero::new(i16::MAX)?;
assert_eq!(pos, pos.saturating_abs());
assert_eq!(pos, neg.saturating_abs());
assert_eq!(max, min.saturating_abs());
assert_eq!(max, min_plus.saturating_abs());1.64.0 (const: 1.64.0) · Source
Wrapping absolute value, seei16::wrapping_abs.
§Example
let pos = NonZero::new(1i16)?;
let neg = NonZero::new(-1i16)?;
let min = NonZero::new(i16::MIN)?;
assert_eq!(pos, pos.wrapping_abs());
assert_eq!(pos, neg.wrapping_abs());
assert_eq!(min, min.wrapping_abs());
assert_eq!(max, (-max).wrapping_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZero::new(1u16)?;
let i_pos = NonZero::new(1i16)?;
let i_neg = NonZero::new(-1i16)?;
let i_min = NonZero::new(i16::MIN)?;
let u_max = NonZero::new(u16::MAX / 2 + 1)?;
assert_eq!(u_pos, i_pos.unsigned_abs());
assert_eq!(u_pos, i_neg.unsigned_abs());
assert_eq!(u_max, i_min.unsigned_abs());1.71.0 (const: 1.71.0) · Source
Returns true if self is positive and false if the number is negative.
§Example
let pos_five = NonZero::new(5i16)?;
let neg_five = NonZero::new(-5i16)?;
assert!(pos_five.is_positive());
assert!(!neg_five.is_positive());1.71.0 (const: 1.71.0) · Source
Returns true if self is negative and false if the number is positive.
§Example
let pos_five = NonZero::new(5i16)?;
let neg_five = NonZero::new(-5i16)?;
assert!(neg_five.is_negative());
assert!(!pos_five.is_negative());1.71.0 (const: 1.71.0) · Source
Checked negation. Computes -self, returning None if self == NonZero::<i16>::MIN.
§Example
let pos_five = NonZero::new(5i16)?;
let neg_five = NonZero::new(-5i16)?;
let min = NonZero::new(i16::MIN)?;
assert_eq!(pos_five.checked_neg(), Some(neg_five));
assert_eq!(min.checked_neg(), None);1.71.0 (const: 1.71.0) · Source
Negates self, overflowing if this is equal to the minimum value.
See i16::overflowing_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i16)?;
let neg_five = NonZero::new(-5i16)?;
let min = NonZero::new(i16::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));1.71.0 (const: 1.71.0) · Source
Saturating negation. Computes -self, returning NonZero::::MAXif self == NonZero::<i16>::MINinstead of overflowing.
§Example
let pos_five = NonZero::new(5i16)?;
let neg_five = NonZero::new(-5i16)?;
let min = NonZero::new(i16::MIN)?;
let min_plus_one = NonZero::new(i16::MIN + 1)?;
let max = NonZero::new(i16::MAX)?;
assert_eq!(pos_five.saturating_neg(), neg_five);
assert_eq!(min.saturating_neg(), max);
assert_eq!(max.saturating_neg(), min_plus_one);1.71.0 (const: 1.71.0) · Source
Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.
See i16::wrapping_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i16)?;
let neg_five = NonZero::new(-5i16)?;
let min = NonZero::new(i16::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as an unsigned integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::new(-1i16).unwrap();
assert_eq!(n.cast_unsigned(), NonZero::<u16>::MAX);1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2i16)?;
let four = NonZero::new(4i16)?;
let max = NonZero::new(i16::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2i16)?;
let four = NonZero::new(4i16)?;
let max = NonZero::new(i16::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > i16::MAX, or self * rhs < i16::MIN.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2i16)?;
let four = NonZero::new(4i16)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3i16)?;
let twenty_seven = NonZero::new(27i16)?;
let half_max = NonZero::new(i16::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MIN or NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3i16)?;
let twenty_seven = NonZero::new(27i16)?;
let max = NonZero::new(i16::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to i32::BITS.
§Examples
assert_eq!(NonZero::<i32>::BITS, i32::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, equal to i32::MIN.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i32>::MIN.get(), i32::MIN);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to i32::MAX.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i32>::MAX.get(), i32::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i32>::new(-1i32)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i32>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<i32>::new(0b100_0000)?;
let b = NonZero::<i32>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x10000b3i32)?;
let m = NonZero::new(0xb301)?;
assert_eq!(n.rotate_left(8), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xb301i32)?;
let m = NonZero::new(0x10000b3)?;
assert_eq!(n.rotate_right(8), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12345678i32)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x78563412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12345678i32)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x1e6a2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI32;
let n = NonZero::new(0x1Ai32)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroI32::from_be(n), n)
} else {
assert_eq!(NonZeroI32::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI32;
let n = NonZero::new(0x1Ai32)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroI32::from_le(n), n)
} else {
assert_eq!(NonZeroI32::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai32)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai32)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self. See i32::absfor documentation on overflow behavior.
§Example
let pos = NonZero::new(1i32)?;
let neg = NonZero::new(-1i32)?;
assert_eq!(pos, pos.abs());
assert_eq!(pos, neg.abs());1.64.0 (const: 1.64.0) · Source
Checked absolute value. Checks for overflow and returns None ifself == NonZero::<i32>::MIN. The result cannot be zero.
§Example
let pos = NonZero::new(1i32)?;
let neg = NonZero::new(-1i32)?;
let min = NonZero::new(i32::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self, with overflow information, seei32::overflowing_abs.
§Example
let pos = NonZero::new(1i32)?;
let neg = NonZero::new(-1i32)?;
let min = NonZero::new(i32::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());1.64.0 (const: 1.64.0) · Source
Saturating absolute value, seei32::saturating_abs.
§Example
let pos = NonZero::new(1i32)?;
let neg = NonZero::new(-1i32)?;
let min = NonZero::new(i32::MIN)?;
let min_plus = NonZero::new(i32::MIN + 1)?;
let max = NonZero::new(i32::MAX)?;
assert_eq!(pos, pos.saturating_abs());
assert_eq!(pos, neg.saturating_abs());
assert_eq!(max, min.saturating_abs());
assert_eq!(max, min_plus.saturating_abs());1.64.0 (const: 1.64.0) · Source
Wrapping absolute value, seei32::wrapping_abs.
§Example
let pos = NonZero::new(1i32)?;
let neg = NonZero::new(-1i32)?;
let min = NonZero::new(i32::MIN)?;
assert_eq!(pos, pos.wrapping_abs());
assert_eq!(pos, neg.wrapping_abs());
assert_eq!(min, min.wrapping_abs());
assert_eq!(max, (-max).wrapping_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZero::new(1u32)?;
let i_pos = NonZero::new(1i32)?;
let i_neg = NonZero::new(-1i32)?;
let i_min = NonZero::new(i32::MIN)?;
let u_max = NonZero::new(u32::MAX / 2 + 1)?;
assert_eq!(u_pos, i_pos.unsigned_abs());
assert_eq!(u_pos, i_neg.unsigned_abs());
assert_eq!(u_max, i_min.unsigned_abs());1.71.0 (const: 1.71.0) · Source
Returns true if self is positive and false if the number is negative.
§Example
let pos_five = NonZero::new(5i32)?;
let neg_five = NonZero::new(-5i32)?;
assert!(pos_five.is_positive());
assert!(!neg_five.is_positive());1.71.0 (const: 1.71.0) · Source
Returns true if self is negative and false if the number is positive.
§Example
let pos_five = NonZero::new(5i32)?;
let neg_five = NonZero::new(-5i32)?;
assert!(neg_five.is_negative());
assert!(!pos_five.is_negative());1.71.0 (const: 1.71.0) · Source
Checked negation. Computes -self, returning None if self == NonZero::<i32>::MIN.
§Example
let pos_five = NonZero::new(5i32)?;
let neg_five = NonZero::new(-5i32)?;
let min = NonZero::new(i32::MIN)?;
assert_eq!(pos_five.checked_neg(), Some(neg_five));
assert_eq!(min.checked_neg(), None);1.71.0 (const: 1.71.0) · Source
Negates self, overflowing if this is equal to the minimum value.
See i32::overflowing_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i32)?;
let neg_five = NonZero::new(-5i32)?;
let min = NonZero::new(i32::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));1.71.0 (const: 1.71.0) · Source
Saturating negation. Computes -self, returning NonZero::::MAXif self == NonZero::<i32>::MINinstead of overflowing.
§Example
let pos_five = NonZero::new(5i32)?;
let neg_five = NonZero::new(-5i32)?;
let min = NonZero::new(i32::MIN)?;
let min_plus_one = NonZero::new(i32::MIN + 1)?;
let max = NonZero::new(i32::MAX)?;
assert_eq!(pos_five.saturating_neg(), neg_five);
assert_eq!(min.saturating_neg(), max);
assert_eq!(max.saturating_neg(), min_plus_one);1.71.0 (const: 1.71.0) · Source
Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.
See i32::wrapping_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i32)?;
let neg_five = NonZero::new(-5i32)?;
let min = NonZero::new(i32::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as an unsigned integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::new(-1i32).unwrap();
assert_eq!(n.cast_unsigned(), NonZero::<u32>::MAX);1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2i32)?;
let four = NonZero::new(4i32)?;
let max = NonZero::new(i32::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2i32)?;
let four = NonZero::new(4i32)?;
let max = NonZero::new(i32::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > i32::MAX, or self * rhs < i32::MIN.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2i32)?;
let four = NonZero::new(4i32)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3i32)?;
let twenty_seven = NonZero::new(27i32)?;
let half_max = NonZero::new(i32::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MIN or NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3i32)?;
let twenty_seven = NonZero::new(27i32)?;
let max = NonZero::new(i32::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to i64::BITS.
§Examples
assert_eq!(NonZero::<i64>::BITS, i64::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, equal to i64::MIN.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i64>::MIN.get(), i64::MIN);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to i64::MAX.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i64>::MAX.get(), i64::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i64>::new(-1i64)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i64>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<i64>::new(0b100_0000)?;
let b = NonZero::<i64>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xaa00000000006e1i64)?;
let m = NonZero::new(0x6e10aa)?;
assert_eq!(n.rotate_left(12), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x6e10aai64)?;
let m = NonZero::new(0xaa00000000006e1)?;
assert_eq!(n.rotate_right(12), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234567890123456i64)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x5634129078563412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234567890123456i64)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x6a2c48091e6a2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI64;
let n = NonZero::new(0x1Ai64)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroI64::from_be(n), n)
} else {
assert_eq!(NonZeroI64::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI64;
let n = NonZero::new(0x1Ai64)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroI64::from_le(n), n)
} else {
assert_eq!(NonZeroI64::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai64)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai64)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self. See i64::absfor documentation on overflow behavior.
§Example
let pos = NonZero::new(1i64)?;
let neg = NonZero::new(-1i64)?;
assert_eq!(pos, pos.abs());
assert_eq!(pos, neg.abs());1.64.0 (const: 1.64.0) · Source
Checked absolute value. Checks for overflow and returns None ifself == NonZero::<i64>::MIN. The result cannot be zero.
§Example
let pos = NonZero::new(1i64)?;
let neg = NonZero::new(-1i64)?;
let min = NonZero::new(i64::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self, with overflow information, seei64::overflowing_abs.
§Example
let pos = NonZero::new(1i64)?;
let neg = NonZero::new(-1i64)?;
let min = NonZero::new(i64::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());1.64.0 (const: 1.64.0) · Source
Saturating absolute value, seei64::saturating_abs.
§Example
let pos = NonZero::new(1i64)?;
let neg = NonZero::new(-1i64)?;
let min = NonZero::new(i64::MIN)?;
let min_plus = NonZero::new(i64::MIN + 1)?;
let max = NonZero::new(i64::MAX)?;
assert_eq!(pos, pos.saturating_abs());
assert_eq!(pos, neg.saturating_abs());
assert_eq!(max, min.saturating_abs());
assert_eq!(max, min_plus.saturating_abs());1.64.0 (const: 1.64.0) · Source
Wrapping absolute value, seei64::wrapping_abs.
§Example
let pos = NonZero::new(1i64)?;
let neg = NonZero::new(-1i64)?;
let min = NonZero::new(i64::MIN)?;
assert_eq!(pos, pos.wrapping_abs());
assert_eq!(pos, neg.wrapping_abs());
assert_eq!(min, min.wrapping_abs());
assert_eq!(max, (-max).wrapping_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZero::new(1u64)?;
let i_pos = NonZero::new(1i64)?;
let i_neg = NonZero::new(-1i64)?;
let i_min = NonZero::new(i64::MIN)?;
let u_max = NonZero::new(u64::MAX / 2 + 1)?;
assert_eq!(u_pos, i_pos.unsigned_abs());
assert_eq!(u_pos, i_neg.unsigned_abs());
assert_eq!(u_max, i_min.unsigned_abs());1.71.0 (const: 1.71.0) · Source
Returns true if self is positive and false if the number is negative.
§Example
let pos_five = NonZero::new(5i64)?;
let neg_five = NonZero::new(-5i64)?;
assert!(pos_five.is_positive());
assert!(!neg_five.is_positive());1.71.0 (const: 1.71.0) · Source
Returns true if self is negative and false if the number is positive.
§Example
let pos_five = NonZero::new(5i64)?;
let neg_five = NonZero::new(-5i64)?;
assert!(neg_five.is_negative());
assert!(!pos_five.is_negative());1.71.0 (const: 1.71.0) · Source
Checked negation. Computes -self, returning None if self == NonZero::<i64>::MIN.
§Example
let pos_five = NonZero::new(5i64)?;
let neg_five = NonZero::new(-5i64)?;
let min = NonZero::new(i64::MIN)?;
assert_eq!(pos_five.checked_neg(), Some(neg_five));
assert_eq!(min.checked_neg(), None);1.71.0 (const: 1.71.0) · Source
Negates self, overflowing if this is equal to the minimum value.
See i64::overflowing_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i64)?;
let neg_five = NonZero::new(-5i64)?;
let min = NonZero::new(i64::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));1.71.0 (const: 1.71.0) · Source
Saturating negation. Computes -self, returning NonZero::::MAXif self == NonZero::<i64>::MINinstead of overflowing.
§Example
let pos_five = NonZero::new(5i64)?;
let neg_five = NonZero::new(-5i64)?;
let min = NonZero::new(i64::MIN)?;
let min_plus_one = NonZero::new(i64::MIN + 1)?;
let max = NonZero::new(i64::MAX)?;
assert_eq!(pos_five.saturating_neg(), neg_five);
assert_eq!(min.saturating_neg(), max);
assert_eq!(max.saturating_neg(), min_plus_one);1.71.0 (const: 1.71.0) · Source
Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.
See i64::wrapping_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i64)?;
let neg_five = NonZero::new(-5i64)?;
let min = NonZero::new(i64::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as an unsigned integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::new(-1i64).unwrap();
assert_eq!(n.cast_unsigned(), NonZero::<u64>::MAX);1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2i64)?;
let four = NonZero::new(4i64)?;
let max = NonZero::new(i64::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2i64)?;
let four = NonZero::new(4i64)?;
let max = NonZero::new(i64::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > i64::MAX, or self * rhs < i64::MIN.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2i64)?;
let four = NonZero::new(4i64)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3i64)?;
let twenty_seven = NonZero::new(27i64)?;
let half_max = NonZero::new(i64::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MIN or NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3i64)?;
let twenty_seven = NonZero::new(27i64)?;
let max = NonZero::new(i64::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to i128::BITS.
§Examples
assert_eq!(NonZero::<i128>::BITS, i128::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, equal to i128::MIN.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i128>::MIN.get(), i128::MIN);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to i128::MAX.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<i128>::MAX.get(), i128::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i128>::new(-1i128)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<i128>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<i128>::new(0b100_0000)?;
let b = NonZero::<i128>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x13f40000000000000000000000004f76i128)?;
let m = NonZero::new(0x4f7613f4)?;
assert_eq!(n.rotate_left(16), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x4f7613f4i128)?;
let m = NonZero::new(0x13f40000000000000000000000004f76)?;
assert_eq!(n.rotate_right(16), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12345678901234567890123456789012i128)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x12907856341290785634129078563412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x12345678901234567890123456789012i128)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x48091e6a2c48091e6a2c48091e6a2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI128;
let n = NonZero::new(0x1Ai128)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroI128::from_be(n), n)
} else {
assert_eq!(NonZeroI128::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroI128;
let n = NonZero::new(0x1Ai128)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroI128::from_le(n), n)
} else {
assert_eq!(NonZeroI128::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai128)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Ai128)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self. See i128::absfor documentation on overflow behavior.
§Example
let pos = NonZero::new(1i128)?;
let neg = NonZero::new(-1i128)?;
assert_eq!(pos, pos.abs());
assert_eq!(pos, neg.abs());1.64.0 (const: 1.64.0) · Source
Checked absolute value. Checks for overflow and returns None ifself == NonZero::<i128>::MIN. The result cannot be zero.
§Example
let pos = NonZero::new(1i128)?;
let neg = NonZero::new(-1i128)?;
let min = NonZero::new(i128::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self, with overflow information, seei128::overflowing_abs.
§Example
let pos = NonZero::new(1i128)?;
let neg = NonZero::new(-1i128)?;
let min = NonZero::new(i128::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());1.64.0 (const: 1.64.0) · Source
Saturating absolute value, seei128::saturating_abs.
§Example
let pos = NonZero::new(1i128)?;
let neg = NonZero::new(-1i128)?;
let min = NonZero::new(i128::MIN)?;
let min_plus = NonZero::new(i128::MIN + 1)?;
let max = NonZero::new(i128::MAX)?;
assert_eq!(pos, pos.saturating_abs());
assert_eq!(pos, neg.saturating_abs());
assert_eq!(max, min.saturating_abs());
assert_eq!(max, min_plus.saturating_abs());1.64.0 (const: 1.64.0) · Source
Wrapping absolute value, seei128::wrapping_abs.
§Example
let pos = NonZero::new(1i128)?;
let neg = NonZero::new(-1i128)?;
let min = NonZero::new(i128::MIN)?;
assert_eq!(pos, pos.wrapping_abs());
assert_eq!(pos, neg.wrapping_abs());
assert_eq!(min, min.wrapping_abs());
assert_eq!(max, (-max).wrapping_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZero::new(1u128)?;
let i_pos = NonZero::new(1i128)?;
let i_neg = NonZero::new(-1i128)?;
let i_min = NonZero::new(i128::MIN)?;
let u_max = NonZero::new(u128::MAX / 2 + 1)?;
assert_eq!(u_pos, i_pos.unsigned_abs());
assert_eq!(u_pos, i_neg.unsigned_abs());
assert_eq!(u_max, i_min.unsigned_abs());1.71.0 (const: 1.71.0) · Source
Returns true if self is positive and false if the number is negative.
§Example
let pos_five = NonZero::new(5i128)?;
let neg_five = NonZero::new(-5i128)?;
assert!(pos_five.is_positive());
assert!(!neg_five.is_positive());1.71.0 (const: 1.71.0) · Source
Returns true if self is negative and false if the number is positive.
§Example
let pos_five = NonZero::new(5i128)?;
let neg_five = NonZero::new(-5i128)?;
assert!(neg_five.is_negative());
assert!(!pos_five.is_negative());1.71.0 (const: 1.71.0) · Source
Checked negation. Computes -self, returning None if self == NonZero::<i128>::MIN.
§Example
let pos_five = NonZero::new(5i128)?;
let neg_five = NonZero::new(-5i128)?;
let min = NonZero::new(i128::MIN)?;
assert_eq!(pos_five.checked_neg(), Some(neg_five));
assert_eq!(min.checked_neg(), None);1.71.0 (const: 1.71.0) · Source
Negates self, overflowing if this is equal to the minimum value.
See i128::overflowing_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i128)?;
let neg_five = NonZero::new(-5i128)?;
let min = NonZero::new(i128::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));1.71.0 (const: 1.71.0) · Source
Saturating negation. Computes -self, returning NonZero::::MAXif self == NonZero::<i128>::MINinstead of overflowing.
§Example
let pos_five = NonZero::new(5i128)?;
let neg_five = NonZero::new(-5i128)?;
let min = NonZero::new(i128::MIN)?;
let min_plus_one = NonZero::new(i128::MIN + 1)?;
let max = NonZero::new(i128::MAX)?;
assert_eq!(pos_five.saturating_neg(), neg_five);
assert_eq!(min.saturating_neg(), max);
assert_eq!(max.saturating_neg(), min_plus_one);1.71.0 (const: 1.71.0) · Source
Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.
See i128::wrapping_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5i128)?;
let neg_five = NonZero::new(-5i128)?;
let min = NonZero::new(i128::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as an unsigned integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::new(-1i128).unwrap();
assert_eq!(n.cast_unsigned(), NonZero::<u128>::MAX);1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2i128)?;
let four = NonZero::new(4i128)?;
let max = NonZero::new(i128::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2i128)?;
let four = NonZero::new(4i128)?;
let max = NonZero::new(i128::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > i128::MAX, or self * rhs < i128::MIN.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2i128)?;
let four = NonZero::new(4i128)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3i128)?;
let twenty_seven = NonZero::new(27i128)?;
let half_max = NonZero::new(i128::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MIN or NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3i128)?;
let twenty_seven = NonZero::new(27i128)?;
let max = NonZero::new(i128::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));1.67.0 · Source
The size of this non-zero integer type in bits.
This value is equal to isize::BITS.
§Examples
assert_eq!(NonZero::<isize>::BITS, isize::BITS);1.70.0 · Source
The smallest value that can be represented by this non-zero integer type, equal to isize::MIN.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<isize>::MIN.get(), isize::MIN);1.70.0 · Source
The largest value that can be represented by this non-zero integer type, equal to isize::MAX.
Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZero::<isize>::MAX.get(), isize::MAX);1.53.0 (const: 1.53.0) · Source
Returns the number of leading zeros in the binary representation of self.
On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<isize>::new(-1isize)?;
assert_eq!(n.leading_zeros(), 0);1.53.0 (const: 1.53.0) · Source
Returns the number of trailing zeros in the binary representation of self.
On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<isize>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);1.86.0 (const: 1.86.0) · Source
Returns the number of ones in the binary representation of self.
§Examples
Basic usage:
let a = NonZero::<isize>::new(0b100_0000)?;
let b = NonZero::<isize>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the << shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xaa00000000006e1isize)?;
let m = NonZero::new(0x6e10aa)?;
assert_eq!(n.rotate_left(12), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.
Please note this isn’t the same operation as the >> shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x6e10aaisize)?;
let m = NonZero::new(0xaa00000000006e1)?;
assert_eq!(n.rotate_right(12), m);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234567890123456isize)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x5634129078563412)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234567890123456isize)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x6a2c48091e6a2c48)?);🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroIsize;
let n = NonZero::new(0x1Aisize)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroIsize::from_be(n), n)
} else {
assert_eq!(NonZeroIsize::from_be(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
use std::num::NonZeroIsize;
let n = NonZero::new(0x1Aisize)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroIsize::from_le(n), n)
} else {
assert_eq!(NonZeroIsize::from_le(n), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Aisize)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}🔬This is a nightly-only experimental API. (nonzero_bitwise #128281)
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:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Aisize)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self. See isize::absfor documentation on overflow behavior.
§Example
let pos = NonZero::new(1isize)?;
let neg = NonZero::new(-1isize)?;
assert_eq!(pos, pos.abs());
assert_eq!(pos, neg.abs());1.64.0 (const: 1.64.0) · Source
Checked absolute value. Checks for overflow and returns None ifself == NonZero::<isize>::MIN. The result cannot be zero.
§Example
let pos = NonZero::new(1isize)?;
let neg = NonZero::new(-1isize)?;
let min = NonZero::new(isize::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self, with overflow information, seeisize::overflowing_abs.
§Example
let pos = NonZero::new(1isize)?;
let neg = NonZero::new(-1isize)?;
let min = NonZero::new(isize::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());1.64.0 (const: 1.64.0) · Source
Saturating absolute value, seeisize::saturating_abs.
§Example
let pos = NonZero::new(1isize)?;
let neg = NonZero::new(-1isize)?;
let min = NonZero::new(isize::MIN)?;
let min_plus = NonZero::new(isize::MIN + 1)?;
let max = NonZero::new(isize::MAX)?;
assert_eq!(pos, pos.saturating_abs());
assert_eq!(pos, neg.saturating_abs());
assert_eq!(max, min.saturating_abs());
assert_eq!(max, min_plus.saturating_abs());1.64.0 (const: 1.64.0) · Source
Wrapping absolute value, seeisize::wrapping_abs.
§Example
let pos = NonZero::new(1isize)?;
let neg = NonZero::new(-1isize)?;
let min = NonZero::new(isize::MIN)?;
assert_eq!(pos, pos.wrapping_abs());
assert_eq!(pos, neg.wrapping_abs());
assert_eq!(min, min.wrapping_abs());
assert_eq!(max, (-max).wrapping_abs());1.64.0 (const: 1.64.0) · Source
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZero::new(1usize)?;
let i_pos = NonZero::new(1isize)?;
let i_neg = NonZero::new(-1isize)?;
let i_min = NonZero::new(isize::MIN)?;
let u_max = NonZero::new(usize::MAX / 2 + 1)?;
assert_eq!(u_pos, i_pos.unsigned_abs());
assert_eq!(u_pos, i_neg.unsigned_abs());
assert_eq!(u_max, i_min.unsigned_abs());1.71.0 (const: 1.71.0) · Source
Returns true if self is positive and false if the number is negative.
§Example
let pos_five = NonZero::new(5isize)?;
let neg_five = NonZero::new(-5isize)?;
assert!(pos_five.is_positive());
assert!(!neg_five.is_positive());1.71.0 (const: 1.71.0) · Source
Returns true if self is negative and false if the number is positive.
§Example
let pos_five = NonZero::new(5isize)?;
let neg_five = NonZero::new(-5isize)?;
assert!(neg_five.is_negative());
assert!(!pos_five.is_negative());1.71.0 (const: 1.71.0) · Source
Checked negation. Computes -self, returning None if self == NonZero::<isize>::MIN.
§Example
let pos_five = NonZero::new(5isize)?;
let neg_five = NonZero::new(-5isize)?;
let min = NonZero::new(isize::MIN)?;
assert_eq!(pos_five.checked_neg(), Some(neg_five));
assert_eq!(min.checked_neg(), None);1.71.0 (const: 1.71.0) · Source
Negates self, overflowing if this is equal to the minimum value.
See isize::overflowing_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5isize)?;
let neg_five = NonZero::new(-5isize)?;
let min = NonZero::new(isize::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));1.71.0 (const: 1.71.0) · Source
Saturating negation. Computes -self, returning NonZero::::MAXif self == NonZero::<isize>::MINinstead of overflowing.
§Example
let pos_five = NonZero::new(5isize)?;
let neg_five = NonZero::new(-5isize)?;
let min = NonZero::new(isize::MIN)?;
let min_plus_one = NonZero::new(isize::MIN + 1)?;
let max = NonZero::new(isize::MAX)?;
assert_eq!(pos_five.saturating_neg(), neg_five);
assert_eq!(min.saturating_neg(), max);
assert_eq!(max.saturating_neg(), min_plus_one);1.71.0 (const: 1.71.0) · Source
Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.
See isize::wrapping_negfor documentation on overflow behavior.
§Example
let pos_five = NonZero::new(5isize)?;
let neg_five = NonZero::new(-5isize)?;
let min = NonZero::new(isize::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);🔬This is a nightly-only experimental API. (integer_sign_cast #125882)
Returns the bit pattern of self reinterpreted as an unsigned integer of the same size.
§Examples
Basic usage:
#![feature(integer_sign_cast)]
let n = NonZero::new(-1isize).unwrap();
assert_eq!(n.cast_unsigned(), NonZero::<usize>::MAX);1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2isize)?;
let four = NonZero::new(4isize)?;
let max = NonZero::new(isize::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));1.64.0 (const: 1.64.0) · Source
Multiplies two non-zero integers together. Return NonZero::::MAX on overflow.
§Examples
let two = NonZero::new(2isize)?;
let four = NonZero::new(4isize)?;
let max = NonZero::new(isize::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));🔬This is a nightly-only experimental API. (nonzero_ops #84186)
Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behavior to overflow_even if the result would wrap to a non-zero value_. The behavior is undefined as soon asself * rhs > isize::MAX, or self * rhs < isize::MIN.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2isize)?;
let four = NonZero::new(4isize)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });1.64.0 (const: 1.64.0) · Source
Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3isize)?;
let twenty_seven = NonZero::new(27isize)?;
let half_max = NonZero::new(isize::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));1.64.0 (const: 1.64.0) · Source
Raise non-zero value to an integer power. Return NonZero::::MIN or NonZero::::MAX on overflow.
§Examples
let three = NonZero::new(3isize)?;
let twenty_seven = NonZero::new(27isize)?;
let max = NonZero::new(isize::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));The resulting type after applying the | operator.
The resulting type after applying the | operator.
The resulting type after applying the | operator.
Same as self / other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
The resulting type after applying the / operator.
Same as self / other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
The resulting type after applying the / operator.
Same as self / other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
The resulting type after applying the / operator.
Same as self / other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
The resulting type after applying the / operator.
Same as self / other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
The resulting type after applying the / operator.
Same as self / other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
The resulting type after applying the / operator.
Same as self /= other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
Same as self /= other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
Same as self /= other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
Same as self /= other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
Same as self /= other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
Same as self /= other.get(), but because other is a NonZero<_>, there’s never a runtime check for division-by-zero.
This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.
Converts to this type from the input type.
Converts to this type from the input type.
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
The resulting type after applying the % operator.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
The resulting type after applying the % operator.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
The resulting type after applying the % operator.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
The resulting type after applying the % operator.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
The resulting type after applying the % operator.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
The resulting type after applying the % operator.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
This operation satisfies n % d == n - (n / d) * d, and cannot panic.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.
The type returned in the event of a conversion error.