pub struct NonZero<T>(/* private fields */)
where
T: ZeroablePrimitive;
generic_nonzero
#120257)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
:
#![feature(generic_nonzero)]
use core::mem::size_of;
assert_eq!(size_of::<Option<core::num::NonZero<u32>>>(), size_of::<u32>());
RunImplementations§
source§impl NonZero<u8>
impl NonZero<u8>
1.28.0 (const: 1.28.0) · sourcepub const unsafe fn new_unchecked(n: u8) -> NonZero<u8>
pub const unsafe fn new_unchecked(n: u8) -> NonZero<u8>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.28.0 (const: 1.47.0) · sourcepub const fn new(n: u8) -> Option<NonZero<u8>>
pub const fn new(n: u8) -> Option<NonZero<u8>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut u8) -> &mut NonZero<u8>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut u8) -> &mut NonZero<u8>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut u8) -> Option<&mut NonZero<u8>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut u8) -> Option<&mut NonZero<u8>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroU8::new(u8::MAX).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroU8::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroU8::new(0b100_0000)?;
let b = NonZeroU8::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_add(self, other: u8) -> Option<NonZero<u8>>
pub const fn checked_add(self, other: u8) -> Option<NonZero<u8>>
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 = NonZeroU8::new(1)?;
let two = NonZeroU8::new(2)?;
let max = NonZeroU8::new(u8::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_add(self, other: u8) -> NonZero<u8>
pub const fn saturating_add(self, other: u8) -> NonZero<u8>
Adds an unsigned integer to a non-zero value.
Return NonZeroU8::MAX
on overflow.
§Examples
let one = NonZeroU8::new(1)?;
let two = NonZeroU8::new(2)?;
let max = NonZeroU8::new(u8::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));
Runsourcepub const unsafe fn unchecked_add(self, other: u8) -> NonZero<u8>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_add(self, other: u8) -> NonZero<u8>
nonzero_ops
#84186)Adds an unsigned integer to a non-zero value,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self + rhs > u8::MAX
.
§Examples
#![feature(nonzero_ops)]
let one = NonZeroU8::new(1)?;
let two = NonZeroU8::new(2)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_next_power_of_two(self) -> Option<NonZero<u8>>
pub const fn checked_next_power_of_two(self) -> Option<NonZero<u8>>
Returns the smallest power of two greater than or equal to n.
Checks for overflow and returns None
if 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 = NonZeroU8::new(2)?;
let three = NonZeroU8::new(3)?;
let four = NonZeroU8::new(4)?;
let max = NonZeroU8::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() );
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog2(self) -> u32
pub const fn ilog2(self) -> u32
Returns the base 2 logarithm of the number, rounded down.
This is the same operation as
u8::ilog2
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU8::new(7).unwrap().ilog2(), 2);
assert_eq!(NonZeroU8::new(8).unwrap().ilog2(), 3);
assert_eq!(NonZeroU8::new(9).unwrap().ilog2(), 3);
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog10(self) -> u32
pub const fn ilog10(self) -> u32
Returns the base 10 logarithm of the number, rounded down.
This is the same operation as
u8::ilog10
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU8::new(99).unwrap().ilog10(), 1);
assert_eq!(NonZeroU8::new(100).unwrap().ilog10(), 2);
assert_eq!(NonZeroU8::new(101).unwrap().ilog10(), 2);
Runconst: unstable · sourcepub fn midpoint(self, rhs: NonZero<u8>) -> NonZero<u8>
🔬This is a nightly-only experimental API. (num_midpoint
#110840)
pub fn midpoint(self, rhs: NonZero<u8>) -> NonZero<u8>
num_midpoint
#110840)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
#![feature(num_midpoint)]
let one = NonZeroU8::new(1)?;
let two = NonZeroU8::new(2)?;
let four = NonZeroU8::new(4)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);
Run1.59.0 (const: 1.59.0) · sourcepub const fn is_power_of_two(self) -> bool
pub const fn is_power_of_two(self) -> bool
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 = std::num::NonZeroU8::new(8).unwrap();
assert!(eight.is_power_of_two());
let ten = std::num::NonZeroU8::new(10).unwrap();
assert!(!ten.is_power_of_two());
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<u8>) -> Option<NonZero<u8>>
pub const fn checked_mul(self, other: NonZero<u8>) -> Option<NonZero<u8>>
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 = NonZeroU8::new(2)?;
let four = NonZeroU8::new(4)?;
let max = NonZeroU8::new(u8::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<u8>) -> NonZero<u8>
pub const fn saturating_mul(self, other: NonZero<u8>) -> NonZero<u8>
Multiplies two non-zero integers together.
Return NonZeroU8::MAX
on overflow.
§Examples
let two = NonZeroU8::new(2)?;
let four = NonZeroU8::new(4)?;
let max = NonZeroU8::new(u8::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<u8>) -> NonZero<u8>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<u8>) -> NonZero<u8>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > u8::MAX
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroU8::new(2)?;
let four = NonZeroU8::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<u8>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<u8>>
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 = NonZeroU8::new(3)?;
let twenty_seven = NonZeroU8::new(27)?;
let half_max = NonZeroU8::new(u8::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<u8>
pub const fn saturating_pow(self, other: u32) -> NonZero<u8>
Raise non-zero value to an integer power.
Return NonZeroU8::MAX
on overflow.
§Examples
let three = NonZeroU8::new(3)?;
let twenty_seven = NonZeroU8::new(27)?;
let max = NonZeroU8::new(u8::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<u16>
impl NonZero<u16>
1.28.0 (const: 1.28.0) · sourcepub const unsafe fn new_unchecked(n: u16) -> NonZero<u16>
pub const unsafe fn new_unchecked(n: u16) -> NonZero<u16>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.28.0 (const: 1.47.0) · sourcepub const fn new(n: u16) -> Option<NonZero<u16>>
pub const fn new(n: u16) -> Option<NonZero<u16>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut u16) -> &mut NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut u16) -> &mut NonZero<u16>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut u16) -> Option<&mut NonZero<u16>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut u16) -> Option<&mut NonZero<u16>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroU16::new(u16::MAX).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroU16::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroU16::new(0b100_0000)?;
let b = NonZeroU16::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_add(self, other: u16) -> Option<NonZero<u16>>
pub const fn checked_add(self, other: u16) -> Option<NonZero<u16>>
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 = NonZeroU16::new(1)?;
let two = NonZeroU16::new(2)?;
let max = NonZeroU16::new(u16::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_add(self, other: u16) -> NonZero<u16>
pub const fn saturating_add(self, other: u16) -> NonZero<u16>
Adds an unsigned integer to a non-zero value.
Return NonZeroU16::MAX
on overflow.
§Examples
let one = NonZeroU16::new(1)?;
let two = NonZeroU16::new(2)?;
let max = NonZeroU16::new(u16::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));
Runsourcepub const unsafe fn unchecked_add(self, other: u16) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_add(self, other: u16) -> NonZero<u16>
nonzero_ops
#84186)Adds an unsigned integer to a non-zero value,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self + rhs > u16::MAX
.
§Examples
#![feature(nonzero_ops)]
let one = NonZeroU16::new(1)?;
let two = NonZeroU16::new(2)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_next_power_of_two(self) -> Option<NonZero<u16>>
pub const fn checked_next_power_of_two(self) -> Option<NonZero<u16>>
Returns the smallest power of two greater than or equal to n.
Checks for overflow and returns None
if 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 = NonZeroU16::new(2)?;
let three = NonZeroU16::new(3)?;
let four = NonZeroU16::new(4)?;
let max = NonZeroU16::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() );
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog2(self) -> u32
pub const fn ilog2(self) -> u32
Returns the base 2 logarithm of the number, rounded down.
This is the same operation as
u16::ilog2
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU16::new(7).unwrap().ilog2(), 2);
assert_eq!(NonZeroU16::new(8).unwrap().ilog2(), 3);
assert_eq!(NonZeroU16::new(9).unwrap().ilog2(), 3);
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog10(self) -> u32
pub const fn ilog10(self) -> u32
Returns the base 10 logarithm of the number, rounded down.
This is the same operation as
u16::ilog10
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU16::new(99).unwrap().ilog10(), 1);
assert_eq!(NonZeroU16::new(100).unwrap().ilog10(), 2);
assert_eq!(NonZeroU16::new(101).unwrap().ilog10(), 2);
Runconst: unstable · sourcepub fn midpoint(self, rhs: NonZero<u16>) -> NonZero<u16>
🔬This is a nightly-only experimental API. (num_midpoint
#110840)
pub fn midpoint(self, rhs: NonZero<u16>) -> NonZero<u16>
num_midpoint
#110840)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
#![feature(num_midpoint)]
let one = NonZeroU16::new(1)?;
let two = NonZeroU16::new(2)?;
let four = NonZeroU16::new(4)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);
Run1.59.0 (const: 1.59.0) · sourcepub const fn is_power_of_two(self) -> bool
pub const fn is_power_of_two(self) -> bool
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 = std::num::NonZeroU16::new(8).unwrap();
assert!(eight.is_power_of_two());
let ten = std::num::NonZeroU16::new(10).unwrap();
assert!(!ten.is_power_of_two());
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<u16>) -> Option<NonZero<u16>>
pub const fn checked_mul(self, other: NonZero<u16>) -> Option<NonZero<u16>>
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 = NonZeroU16::new(2)?;
let four = NonZeroU16::new(4)?;
let max = NonZeroU16::new(u16::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<u16>) -> NonZero<u16>
pub const fn saturating_mul(self, other: NonZero<u16>) -> NonZero<u16>
Multiplies two non-zero integers together.
Return NonZeroU16::MAX
on overflow.
§Examples
let two = NonZeroU16::new(2)?;
let four = NonZeroU16::new(4)?;
let max = NonZeroU16::new(u16::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<u16>) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<u16>) -> NonZero<u16>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > u16::MAX
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroU16::new(2)?;
let four = NonZeroU16::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<u16>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<u16>>
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 = NonZeroU16::new(3)?;
let twenty_seven = NonZeroU16::new(27)?;
let half_max = NonZeroU16::new(u16::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<u16>
pub const fn saturating_pow(self, other: u32) -> NonZero<u16>
Raise non-zero value to an integer power.
Return NonZeroU16::MAX
on overflow.
§Examples
let three = NonZeroU16::new(3)?;
let twenty_seven = NonZeroU16::new(27)?;
let max = NonZeroU16::new(u16::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<u32>
impl NonZero<u32>
1.28.0 (const: 1.28.0) · sourcepub const unsafe fn new_unchecked(n: u32) -> NonZero<u32>
pub const unsafe fn new_unchecked(n: u32) -> NonZero<u32>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.28.0 (const: 1.47.0) · sourcepub const fn new(n: u32) -> Option<NonZero<u32>>
pub const fn new(n: u32) -> Option<NonZero<u32>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut u32) -> &mut NonZero<u32>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut u32) -> &mut NonZero<u32>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut u32) -> Option<&mut NonZero<u32>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut u32) -> Option<&mut NonZero<u32>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroU32::new(u32::MAX).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroU32::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroU32::new(0b100_0000)?;
let b = NonZeroU32::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_add(self, other: u32) -> Option<NonZero<u32>>
pub const fn checked_add(self, other: u32) -> Option<NonZero<u32>>
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 = NonZeroU32::new(1)?;
let two = NonZeroU32::new(2)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_add(self, other: u32) -> NonZero<u32>
pub const fn saturating_add(self, other: u32) -> NonZero<u32>
Adds an unsigned integer to a non-zero value.
Return NonZeroU32::MAX
on overflow.
§Examples
let one = NonZeroU32::new(1)?;
let two = NonZeroU32::new(2)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));
Runsourcepub const unsafe fn unchecked_add(self, other: u32) -> NonZero<u32>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_add(self, other: u32) -> NonZero<u32>
nonzero_ops
#84186)Adds an unsigned integer to a non-zero value,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self + rhs > u32::MAX
.
§Examples
#![feature(nonzero_ops)]
let one = NonZeroU32::new(1)?;
let two = NonZeroU32::new(2)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_next_power_of_two(self) -> Option<NonZero<u32>>
pub const fn checked_next_power_of_two(self) -> Option<NonZero<u32>>
Returns the smallest power of two greater than or equal to n.
Checks for overflow and returns None
if 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 = NonZeroU32::new(2)?;
let three = NonZeroU32::new(3)?;
let four = NonZeroU32::new(4)?;
let max = NonZeroU32::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() );
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog2(self) -> u32
pub const fn ilog2(self) -> u32
Returns the base 2 logarithm of the number, rounded down.
This is the same operation as
u32::ilog2
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU32::new(7).unwrap().ilog2(), 2);
assert_eq!(NonZeroU32::new(8).unwrap().ilog2(), 3);
assert_eq!(NonZeroU32::new(9).unwrap().ilog2(), 3);
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog10(self) -> u32
pub const fn ilog10(self) -> u32
Returns the base 10 logarithm of the number, rounded down.
This is the same operation as
u32::ilog10
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU32::new(99).unwrap().ilog10(), 1);
assert_eq!(NonZeroU32::new(100).unwrap().ilog10(), 2);
assert_eq!(NonZeroU32::new(101).unwrap().ilog10(), 2);
Runconst: unstable · sourcepub fn midpoint(self, rhs: NonZero<u32>) -> NonZero<u32>
🔬This is a nightly-only experimental API. (num_midpoint
#110840)
pub fn midpoint(self, rhs: NonZero<u32>) -> NonZero<u32>
num_midpoint
#110840)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
#![feature(num_midpoint)]
let one = NonZeroU32::new(1)?;
let two = NonZeroU32::new(2)?;
let four = NonZeroU32::new(4)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);
Run1.59.0 (const: 1.59.0) · sourcepub const fn is_power_of_two(self) -> bool
pub const fn is_power_of_two(self) -> bool
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 = std::num::NonZeroU32::new(8).unwrap();
assert!(eight.is_power_of_two());
let ten = std::num::NonZeroU32::new(10).unwrap();
assert!(!ten.is_power_of_two());
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<u32>) -> Option<NonZero<u32>>
pub const fn checked_mul(self, other: NonZero<u32>) -> Option<NonZero<u32>>
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 = NonZeroU32::new(2)?;
let four = NonZeroU32::new(4)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<u32>) -> NonZero<u32>
pub const fn saturating_mul(self, other: NonZero<u32>) -> NonZero<u32>
Multiplies two non-zero integers together.
Return NonZeroU32::MAX
on overflow.
§Examples
let two = NonZeroU32::new(2)?;
let four = NonZeroU32::new(4)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<u32>) -> NonZero<u32>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<u32>) -> NonZero<u32>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > u32::MAX
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroU32::new(2)?;
let four = NonZeroU32::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<u32>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<u32>>
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 = NonZeroU32::new(3)?;
let twenty_seven = NonZeroU32::new(27)?;
let half_max = NonZeroU32::new(u32::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<u32>
pub const fn saturating_pow(self, other: u32) -> NonZero<u32>
Raise non-zero value to an integer power.
Return NonZeroU32::MAX
on overflow.
§Examples
let three = NonZeroU32::new(3)?;
let twenty_seven = NonZeroU32::new(27)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<u64>
impl NonZero<u64>
1.28.0 (const: 1.28.0) · sourcepub const unsafe fn new_unchecked(n: u64) -> NonZero<u64>
pub const unsafe fn new_unchecked(n: u64) -> NonZero<u64>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.28.0 (const: 1.47.0) · sourcepub const fn new(n: u64) -> Option<NonZero<u64>>
pub const fn new(n: u64) -> Option<NonZero<u64>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut u64) -> &mut NonZero<u64>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut u64) -> &mut NonZero<u64>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut u64) -> Option<&mut NonZero<u64>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut u64) -> Option<&mut NonZero<u64>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroU64::new(u64::MAX).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroU64::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroU64::new(0b100_0000)?;
let b = NonZeroU64::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_add(self, other: u64) -> Option<NonZero<u64>>
pub const fn checked_add(self, other: u64) -> Option<NonZero<u64>>
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 = NonZeroU64::new(1)?;
let two = NonZeroU64::new(2)?;
let max = NonZeroU64::new(u64::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_add(self, other: u64) -> NonZero<u64>
pub const fn saturating_add(self, other: u64) -> NonZero<u64>
Adds an unsigned integer to a non-zero value.
Return NonZeroU64::MAX
on overflow.
§Examples
let one = NonZeroU64::new(1)?;
let two = NonZeroU64::new(2)?;
let max = NonZeroU64::new(u64::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));
Runsourcepub const unsafe fn unchecked_add(self, other: u64) -> NonZero<u64>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_add(self, other: u64) -> NonZero<u64>
nonzero_ops
#84186)Adds an unsigned integer to a non-zero value,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self + rhs > u64::MAX
.
§Examples
#![feature(nonzero_ops)]
let one = NonZeroU64::new(1)?;
let two = NonZeroU64::new(2)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_next_power_of_two(self) -> Option<NonZero<u64>>
pub const fn checked_next_power_of_two(self) -> Option<NonZero<u64>>
Returns the smallest power of two greater than or equal to n.
Checks for overflow and returns None
if 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 = NonZeroU64::new(2)?;
let three = NonZeroU64::new(3)?;
let four = NonZeroU64::new(4)?;
let max = NonZeroU64::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() );
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog2(self) -> u32
pub const fn ilog2(self) -> u32
Returns the base 2 logarithm of the number, rounded down.
This is the same operation as
u64::ilog2
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU64::new(7).unwrap().ilog2(), 2);
assert_eq!(NonZeroU64::new(8).unwrap().ilog2(), 3);
assert_eq!(NonZeroU64::new(9).unwrap().ilog2(), 3);
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog10(self) -> u32
pub const fn ilog10(self) -> u32
Returns the base 10 logarithm of the number, rounded down.
This is the same operation as
u64::ilog10
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU64::new(99).unwrap().ilog10(), 1);
assert_eq!(NonZeroU64::new(100).unwrap().ilog10(), 2);
assert_eq!(NonZeroU64::new(101).unwrap().ilog10(), 2);
Runconst: unstable · sourcepub fn midpoint(self, rhs: NonZero<u64>) -> NonZero<u64>
🔬This is a nightly-only experimental API. (num_midpoint
#110840)
pub fn midpoint(self, rhs: NonZero<u64>) -> NonZero<u64>
num_midpoint
#110840)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
#![feature(num_midpoint)]
let one = NonZeroU64::new(1)?;
let two = NonZeroU64::new(2)?;
let four = NonZeroU64::new(4)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);
Run1.59.0 (const: 1.59.0) · sourcepub const fn is_power_of_two(self) -> bool
pub const fn is_power_of_two(self) -> bool
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 = std::num::NonZeroU64::new(8).unwrap();
assert!(eight.is_power_of_two());
let ten = std::num::NonZeroU64::new(10).unwrap();
assert!(!ten.is_power_of_two());
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<u64>) -> Option<NonZero<u64>>
pub const fn checked_mul(self, other: NonZero<u64>) -> Option<NonZero<u64>>
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 = NonZeroU64::new(2)?;
let four = NonZeroU64::new(4)?;
let max = NonZeroU64::new(u64::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<u64>) -> NonZero<u64>
pub const fn saturating_mul(self, other: NonZero<u64>) -> NonZero<u64>
Multiplies two non-zero integers together.
Return NonZeroU64::MAX
on overflow.
§Examples
let two = NonZeroU64::new(2)?;
let four = NonZeroU64::new(4)?;
let max = NonZeroU64::new(u64::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<u64>) -> NonZero<u64>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<u64>) -> NonZero<u64>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > u64::MAX
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroU64::new(2)?;
let four = NonZeroU64::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<u64>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<u64>>
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 = NonZeroU64::new(3)?;
let twenty_seven = NonZeroU64::new(27)?;
let half_max = NonZeroU64::new(u64::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<u64>
pub const fn saturating_pow(self, other: u32) -> NonZero<u64>
Raise non-zero value to an integer power.
Return NonZeroU64::MAX
on overflow.
§Examples
let three = NonZeroU64::new(3)?;
let twenty_seven = NonZeroU64::new(27)?;
let max = NonZeroU64::new(u64::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<u128>
impl NonZero<u128>
1.28.0 (const: 1.28.0) · sourcepub const unsafe fn new_unchecked(n: u128) -> NonZero<u128>
pub const unsafe fn new_unchecked(n: u128) -> NonZero<u128>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.28.0 (const: 1.47.0) · sourcepub const fn new(n: u128) -> Option<NonZero<u128>>
pub const fn new(n: u128) -> Option<NonZero<u128>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut u128) -> &mut NonZero<u128>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut u128) -> &mut NonZero<u128>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut u128) -> Option<&mut NonZero<u128>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut u128) -> Option<&mut NonZero<u128>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.67.0 · sourcepub const BITS: u32 = 128u32
pub const BITS: u32 = 128u32
The size of this non-zero integer type in bits.
This value is equal to u128::BITS
.
§Examples
assert_eq!(NonZeroU128::BITS, u128::BITS);
Run1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroU128::new(u128::MAX).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroU128::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroU128::new(0b100_0000)?;
let b = NonZeroU128::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_add(self, other: u128) -> Option<NonZero<u128>>
pub const fn checked_add(self, other: u128) -> Option<NonZero<u128>>
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 = NonZeroU128::new(1)?;
let two = NonZeroU128::new(2)?;
let max = NonZeroU128::new(u128::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_add(self, other: u128) -> NonZero<u128>
pub const fn saturating_add(self, other: u128) -> NonZero<u128>
Adds an unsigned integer to a non-zero value.
Return NonZeroU128::MAX
on overflow.
§Examples
let one = NonZeroU128::new(1)?;
let two = NonZeroU128::new(2)?;
let max = NonZeroU128::new(u128::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));
Runsourcepub const unsafe fn unchecked_add(self, other: u128) -> NonZero<u128>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_add(self, other: u128) -> NonZero<u128>
nonzero_ops
#84186)Adds an unsigned integer to a non-zero value,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self + rhs > u128::MAX
.
§Examples
#![feature(nonzero_ops)]
let one = NonZeroU128::new(1)?;
let two = NonZeroU128::new(2)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_next_power_of_two(self) -> Option<NonZero<u128>>
pub const fn checked_next_power_of_two(self) -> Option<NonZero<u128>>
Returns the smallest power of two greater than or equal to n.
Checks for overflow and returns None
if 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 = NonZeroU128::new(2)?;
let three = NonZeroU128::new(3)?;
let four = NonZeroU128::new(4)?;
let max = NonZeroU128::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() );
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog2(self) -> u32
pub const fn ilog2(self) -> u32
Returns the base 2 logarithm of the number, rounded down.
This is the same operation as
u128::ilog2
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU128::new(7).unwrap().ilog2(), 2);
assert_eq!(NonZeroU128::new(8).unwrap().ilog2(), 3);
assert_eq!(NonZeroU128::new(9).unwrap().ilog2(), 3);
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog10(self) -> u32
pub const fn ilog10(self) -> u32
Returns the base 10 logarithm of the number, rounded down.
This is the same operation as
u128::ilog10
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroU128::new(99).unwrap().ilog10(), 1);
assert_eq!(NonZeroU128::new(100).unwrap().ilog10(), 2);
assert_eq!(NonZeroU128::new(101).unwrap().ilog10(), 2);
Runconst: unstable · sourcepub fn midpoint(self, rhs: NonZero<u128>) -> NonZero<u128>
🔬This is a nightly-only experimental API. (num_midpoint
#110840)
pub fn midpoint(self, rhs: NonZero<u128>) -> NonZero<u128>
num_midpoint
#110840)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
#![feature(num_midpoint)]
let one = NonZeroU128::new(1)?;
let two = NonZeroU128::new(2)?;
let four = NonZeroU128::new(4)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);
Run1.59.0 (const: 1.59.0) · sourcepub const fn is_power_of_two(self) -> bool
pub const fn is_power_of_two(self) -> bool
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 = std::num::NonZeroU128::new(8).unwrap();
assert!(eight.is_power_of_two());
let ten = std::num::NonZeroU128::new(10).unwrap();
assert!(!ten.is_power_of_two());
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<u128>) -> Option<NonZero<u128>>
pub const fn checked_mul(self, other: NonZero<u128>) -> Option<NonZero<u128>>
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 = NonZeroU128::new(2)?;
let four = NonZeroU128::new(4)?;
let max = NonZeroU128::new(u128::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<u128>) -> NonZero<u128>
pub const fn saturating_mul(self, other: NonZero<u128>) -> NonZero<u128>
Multiplies two non-zero integers together.
Return NonZeroU128::MAX
on overflow.
§Examples
let two = NonZeroU128::new(2)?;
let four = NonZeroU128::new(4)?;
let max = NonZeroU128::new(u128::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<u128>) -> NonZero<u128>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<u128>) -> NonZero<u128>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > u128::MAX
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroU128::new(2)?;
let four = NonZeroU128::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<u128>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<u128>>
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 = NonZeroU128::new(3)?;
let twenty_seven = NonZeroU128::new(27)?;
let half_max = NonZeroU128::new(u128::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<u128>
pub const fn saturating_pow(self, other: u32) -> NonZero<u128>
Raise non-zero value to an integer power.
Return NonZeroU128::MAX
on overflow.
§Examples
let three = NonZeroU128::new(3)?;
let twenty_seven = NonZeroU128::new(27)?;
let max = NonZeroU128::new(u128::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<usize>
impl NonZero<usize>
1.28.0 (const: 1.28.0) · sourcepub const unsafe fn new_unchecked(n: usize) -> NonZero<usize>
pub const unsafe fn new_unchecked(n: usize) -> NonZero<usize>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.28.0 (const: 1.47.0) · sourcepub const fn new(n: usize) -> Option<NonZero<usize>>
pub const fn new(n: usize) -> Option<NonZero<usize>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut usize) -> &mut NonZero<usize>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut usize) -> &mut NonZero<usize>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut usize) -> Option<&mut NonZero<usize>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut usize) -> Option<&mut NonZero<usize>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.28.0 (const: 1.34.0) · sourcepub const fn get(self) -> usize
pub const fn get(self) -> usize
Returns the value as a primitive type.
1.67.0 · sourcepub const BITS: u32 = 64u32
pub const BITS: u32 = 64u32
The size of this non-zero integer type in bits.
This value is equal to usize::BITS
.
§Examples
assert_eq!(NonZeroUsize::BITS, usize::BITS);
Run1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroUsize::new(usize::MAX).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroUsize::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroUsize::new(0b100_0000)?;
let b = NonZeroUsize::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.70.0 · sourcepub const MAX: NonZero<usize> = _
pub const MAX: NonZero<usize> = _
The largest value that can be represented by this non-zero
integer type,
equal to usize::MAX
.
§Examples
assert_eq!(NonZeroUsize::MAX.get(), usize::MAX);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_add(self, other: usize) -> Option<NonZero<usize>>
pub const fn checked_add(self, other: usize) -> Option<NonZero<usize>>
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 = NonZeroUsize::new(1)?;
let two = NonZeroUsize::new(2)?;
let max = NonZeroUsize::new(usize::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_add(self, other: usize) -> NonZero<usize>
pub const fn saturating_add(self, other: usize) -> NonZero<usize>
Adds an unsigned integer to a non-zero value.
Return NonZeroUsize::MAX
on overflow.
§Examples
let one = NonZeroUsize::new(1)?;
let two = NonZeroUsize::new(2)?;
let max = NonZeroUsize::new(usize::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));
Runsourcepub const unsafe fn unchecked_add(self, other: usize) -> NonZero<usize>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_add(self, other: usize) -> NonZero<usize>
nonzero_ops
#84186)Adds an unsigned integer to a non-zero value,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self + rhs > usize::MAX
.
§Examples
#![feature(nonzero_ops)]
let one = NonZeroUsize::new(1)?;
let two = NonZeroUsize::new(2)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_next_power_of_two(self) -> Option<NonZero<usize>>
pub const fn checked_next_power_of_two(self) -> Option<NonZero<usize>>
Returns the smallest power of two greater than or equal to n.
Checks for overflow and returns None
if 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 = NonZeroUsize::new(2)?;
let three = NonZeroUsize::new(3)?;
let four = NonZeroUsize::new(4)?;
let max = NonZeroUsize::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() );
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog2(self) -> u32
pub const fn ilog2(self) -> u32
Returns the base 2 logarithm of the number, rounded down.
This is the same operation as
usize::ilog2
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroUsize::new(7).unwrap().ilog2(), 2);
assert_eq!(NonZeroUsize::new(8).unwrap().ilog2(), 3);
assert_eq!(NonZeroUsize::new(9).unwrap().ilog2(), 3);
Run1.67.0 (const: 1.67.0) · sourcepub const fn ilog10(self) -> u32
pub const fn ilog10(self) -> u32
Returns the base 10 logarithm of the number, rounded down.
This is the same operation as
usize::ilog10
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZeroUsize::new(99).unwrap().ilog10(), 1);
assert_eq!(NonZeroUsize::new(100).unwrap().ilog10(), 2);
assert_eq!(NonZeroUsize::new(101).unwrap().ilog10(), 2);
Runconst: unstable · sourcepub fn midpoint(self, rhs: NonZero<usize>) -> NonZero<usize>
🔬This is a nightly-only experimental API. (num_midpoint
#110840)
pub fn midpoint(self, rhs: NonZero<usize>) -> NonZero<usize>
num_midpoint
#110840)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
#![feature(num_midpoint)]
let one = NonZeroUsize::new(1)?;
let two = NonZeroUsize::new(2)?;
let four = NonZeroUsize::new(4)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);
Run1.59.0 (const: 1.59.0) · sourcepub const fn is_power_of_two(self) -> bool
pub const fn is_power_of_two(self) -> bool
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 = std::num::NonZeroUsize::new(8).unwrap();
assert!(eight.is_power_of_two());
let ten = std::num::NonZeroUsize::new(10).unwrap();
assert!(!ten.is_power_of_two());
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<usize>) -> Option<NonZero<usize>>
pub const fn checked_mul(self, other: NonZero<usize>) -> Option<NonZero<usize>>
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 = NonZeroUsize::new(2)?;
let four = NonZeroUsize::new(4)?;
let max = NonZeroUsize::new(usize::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<usize>) -> NonZero<usize>
pub const fn saturating_mul(self, other: NonZero<usize>) -> NonZero<usize>
Multiplies two non-zero integers together.
Return NonZeroUsize::MAX
on overflow.
§Examples
let two = NonZeroUsize::new(2)?;
let four = NonZeroUsize::new(4)?;
let max = NonZeroUsize::new(usize::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<usize>) -> NonZero<usize>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<usize>) -> NonZero<usize>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > usize::MAX
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroUsize::new(2)?;
let four = NonZeroUsize::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<usize>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<usize>>
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 = NonZeroUsize::new(3)?;
let twenty_seven = NonZeroUsize::new(27)?;
let half_max = NonZeroUsize::new(usize::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<usize>
pub const fn saturating_pow(self, other: u32) -> NonZero<usize>
Raise non-zero value to an integer power.
Return NonZeroUsize::MAX
on overflow.
§Examples
let three = NonZeroUsize::new(3)?;
let twenty_seven = NonZeroUsize::new(27)?;
let max = NonZeroUsize::new(usize::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<i8>
impl NonZero<i8>
1.34.0 (const: 1.34.0) · sourcepub const unsafe fn new_unchecked(n: i8) -> NonZero<i8>
pub const unsafe fn new_unchecked(n: i8) -> NonZero<i8>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.34.0 (const: 1.47.0) · sourcepub const fn new(n: i8) -> Option<NonZero<i8>>
pub const fn new(n: i8) -> Option<NonZero<i8>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut i8) -> &mut NonZero<i8>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut i8) -> &mut NonZero<i8>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut i8) -> Option<&mut NonZero<i8>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut i8) -> Option<&mut NonZero<i8>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroI8::new(-1i8).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroI8::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroI8::new(0b100_0000)?;
let b = NonZeroI8::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.70.0 · sourcepub const MIN: NonZero<i8> = _
pub const MIN: NonZero<i8> = _
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!(NonZeroI8::MIN.get(), i8::MIN);
Run1.70.0 · sourcepub const MAX: NonZero<i8> = _
pub const MAX: NonZero<i8> = _
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!(NonZeroI8::MAX.get(), i8::MAX);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_abs(self) -> Option<NonZero<i8>>
pub const fn checked_abs(self) -> Option<NonZero<i8>>
Checked absolute value.
Checks for overflow and returns None
if
self == NonZeroI8::MIN
.
The result cannot be zero.
§Example
let pos = NonZeroI8::new(1)?;
let neg = NonZeroI8::new(-1)?;
let min = NonZeroI8::new(i8::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn overflowing_abs(self) -> (NonZero<i8>, bool)
pub const fn overflowing_abs(self) -> (NonZero<i8>, bool)
Computes the absolute value of self,
with overflow information, see
i8::overflowing_abs
.
§Example
let pos = NonZeroI8::new(1)?;
let neg = NonZeroI8::new(-1)?;
let min = NonZeroI8::new(i8::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_abs(self) -> NonZero<i8>
pub const fn saturating_abs(self) -> NonZero<i8>
Saturating absolute value, see
i8::saturating_abs
.
§Example
let pos = NonZeroI8::new(1)?;
let neg = NonZeroI8::new(-1)?;
let min = NonZeroI8::new(i8::MIN)?;
let min_plus = NonZeroI8::new(i8::MIN + 1)?;
let max = NonZeroI8::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn wrapping_abs(self) -> NonZero<i8>
pub const fn wrapping_abs(self) -> NonZero<i8>
Wrapping absolute value, see
i8::wrapping_abs
.
§Example
let pos = NonZeroI8::new(1)?;
let neg = NonZeroI8::new(-1)?;
let min = NonZeroI8::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn unsigned_abs(self) -> NonZero<u8>
pub const fn unsigned_abs(self) -> NonZero<u8>
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZeroU8::new(1)?;
let i_pos = NonZeroI8::new(1)?;
let i_neg = NonZeroI8::new(-1)?;
let i_min = NonZeroI8::new(i8::MIN)?;
let u_max = NonZeroU8::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());
Run1.71.0 (const: 1.71.0) · sourcepub const fn is_positive(self) -> bool
pub const fn is_positive(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn is_negative(self) -> bool
pub const fn is_negative(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn checked_neg(self) -> Option<NonZero<i8>>
pub const fn checked_neg(self) -> Option<NonZero<i8>>
1.71.0 (const: 1.71.0) · sourcepub const fn overflowing_neg(self) -> (NonZero<i8>, bool)
pub const fn overflowing_neg(self) -> (NonZero<i8>, bool)
Negates self, overflowing if this is equal to the minimum value.
See i8::overflowing_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI8::new(5)?;
let neg_five = NonZeroI8::new(-5)?;
let min = NonZeroI8::new(i8::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));
Run1.71.0 (const: 1.71.0) · sourcepub const fn saturating_neg(self) -> NonZero<i8>
pub const fn saturating_neg(self) -> NonZero<i8>
Saturating negation. Computes -self
,
returning NonZeroI8::MAX
if self == NonZeroI8::MIN
instead of overflowing.
§Example
let pos_five = NonZeroI8::new(5)?;
let neg_five = NonZeroI8::new(-5)?;
let min = NonZeroI8::new(i8::MIN)?;
let min_plus_one = NonZeroI8::new(i8::MIN + 1)?;
let max = NonZeroI8::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);
Run1.71.0 (const: 1.71.0) · sourcepub const fn wrapping_neg(self) -> NonZero<i8>
pub const fn wrapping_neg(self) -> NonZero<i8>
Wrapping (modular) negation. Computes -self
, wrapping around at the boundary
of the type.
See i8::wrapping_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI8::new(5)?;
let neg_five = NonZeroI8::new(-5)?;
let min = NonZeroI8::new(i8::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<i8>) -> Option<NonZero<i8>>
pub const fn checked_mul(self, other: NonZero<i8>) -> Option<NonZero<i8>>
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 = NonZeroI8::new(2)?;
let four = NonZeroI8::new(4)?;
let max = NonZeroI8::new(i8::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<i8>) -> NonZero<i8>
pub const fn saturating_mul(self, other: NonZero<i8>) -> NonZero<i8>
Multiplies two non-zero integers together.
Return NonZeroI8::MAX
on overflow.
§Examples
let two = NonZeroI8::new(2)?;
let four = NonZeroI8::new(4)?;
let max = NonZeroI8::new(i8::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<i8>) -> NonZero<i8>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<i8>) -> NonZero<i8>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > i8::MAX
, or self * rhs < i8::MIN
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroI8::new(2)?;
let four = NonZeroI8::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<i8>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<i8>>
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 = NonZeroI8::new(3)?;
let twenty_seven = NonZeroI8::new(27)?;
let half_max = NonZeroI8::new(i8::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<i8>
pub const fn saturating_pow(self, other: u32) -> NonZero<i8>
Raise non-zero value to an integer power.
Return NonZeroI8::MIN
or NonZeroI8::MAX
on overflow.
§Examples
let three = NonZeroI8::new(3)?;
let twenty_seven = NonZeroI8::new(27)?;
let max = NonZeroI8::new(i8::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<i16>
impl NonZero<i16>
1.34.0 (const: 1.34.0) · sourcepub const unsafe fn new_unchecked(n: i16) -> NonZero<i16>
pub const unsafe fn new_unchecked(n: i16) -> NonZero<i16>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.34.0 (const: 1.47.0) · sourcepub const fn new(n: i16) -> Option<NonZero<i16>>
pub const fn new(n: i16) -> Option<NonZero<i16>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut i16) -> &mut NonZero<i16>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut i16) -> &mut NonZero<i16>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut i16) -> Option<&mut NonZero<i16>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut i16) -> Option<&mut NonZero<i16>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroI16::new(-1i16).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroI16::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroI16::new(0b100_0000)?;
let b = NonZeroI16::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.70.0 · sourcepub const MIN: NonZero<i16> = _
pub const MIN: NonZero<i16> = _
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!(NonZeroI16::MIN.get(), i16::MIN);
Run1.70.0 · sourcepub const MAX: NonZero<i16> = _
pub const MAX: NonZero<i16> = _
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!(NonZeroI16::MAX.get(), i16::MAX);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_abs(self) -> Option<NonZero<i16>>
pub const fn checked_abs(self) -> Option<NonZero<i16>>
Checked absolute value.
Checks for overflow and returns None
if
self == NonZeroI16::MIN
.
The result cannot be zero.
§Example
let pos = NonZeroI16::new(1)?;
let neg = NonZeroI16::new(-1)?;
let min = NonZeroI16::new(i16::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn overflowing_abs(self) -> (NonZero<i16>, bool)
pub const fn overflowing_abs(self) -> (NonZero<i16>, bool)
Computes the absolute value of self,
with overflow information, see
i16::overflowing_abs
.
§Example
let pos = NonZeroI16::new(1)?;
let neg = NonZeroI16::new(-1)?;
let min = NonZeroI16::new(i16::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_abs(self) -> NonZero<i16>
pub const fn saturating_abs(self) -> NonZero<i16>
Saturating absolute value, see
i16::saturating_abs
.
§Example
let pos = NonZeroI16::new(1)?;
let neg = NonZeroI16::new(-1)?;
let min = NonZeroI16::new(i16::MIN)?;
let min_plus = NonZeroI16::new(i16::MIN + 1)?;
let max = NonZeroI16::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn wrapping_abs(self) -> NonZero<i16>
pub const fn wrapping_abs(self) -> NonZero<i16>
Wrapping absolute value, see
i16::wrapping_abs
.
§Example
let pos = NonZeroI16::new(1)?;
let neg = NonZeroI16::new(-1)?;
let min = NonZeroI16::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn unsigned_abs(self) -> NonZero<u16>
pub const fn unsigned_abs(self) -> NonZero<u16>
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZeroU16::new(1)?;
let i_pos = NonZeroI16::new(1)?;
let i_neg = NonZeroI16::new(-1)?;
let i_min = NonZeroI16::new(i16::MIN)?;
let u_max = NonZeroU16::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());
Run1.71.0 (const: 1.71.0) · sourcepub const fn is_positive(self) -> bool
pub const fn is_positive(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn is_negative(self) -> bool
pub const fn is_negative(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn checked_neg(self) -> Option<NonZero<i16>>
pub const fn checked_neg(self) -> Option<NonZero<i16>>
1.71.0 (const: 1.71.0) · sourcepub const fn overflowing_neg(self) -> (NonZero<i16>, bool)
pub const fn overflowing_neg(self) -> (NonZero<i16>, bool)
Negates self, overflowing if this is equal to the minimum value.
See i16::overflowing_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI16::new(5)?;
let neg_five = NonZeroI16::new(-5)?;
let min = NonZeroI16::new(i16::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));
Run1.71.0 (const: 1.71.0) · sourcepub const fn saturating_neg(self) -> NonZero<i16>
pub const fn saturating_neg(self) -> NonZero<i16>
Saturating negation. Computes -self
,
returning NonZeroI16::MAX
if self == NonZeroI16::MIN
instead of overflowing.
§Example
let pos_five = NonZeroI16::new(5)?;
let neg_five = NonZeroI16::new(-5)?;
let min = NonZeroI16::new(i16::MIN)?;
let min_plus_one = NonZeroI16::new(i16::MIN + 1)?;
let max = NonZeroI16::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);
Run1.71.0 (const: 1.71.0) · sourcepub const fn wrapping_neg(self) -> NonZero<i16>
pub const fn wrapping_neg(self) -> NonZero<i16>
Wrapping (modular) negation. Computes -self
, wrapping around at the boundary
of the type.
See i16::wrapping_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI16::new(5)?;
let neg_five = NonZeroI16::new(-5)?;
let min = NonZeroI16::new(i16::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<i16>) -> Option<NonZero<i16>>
pub const fn checked_mul(self, other: NonZero<i16>) -> Option<NonZero<i16>>
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 = NonZeroI16::new(2)?;
let four = NonZeroI16::new(4)?;
let max = NonZeroI16::new(i16::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<i16>) -> NonZero<i16>
pub const fn saturating_mul(self, other: NonZero<i16>) -> NonZero<i16>
Multiplies two non-zero integers together.
Return NonZeroI16::MAX
on overflow.
§Examples
let two = NonZeroI16::new(2)?;
let four = NonZeroI16::new(4)?;
let max = NonZeroI16::new(i16::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<i16>) -> NonZero<i16>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<i16>) -> NonZero<i16>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > i16::MAX
, or self * rhs < i16::MIN
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroI16::new(2)?;
let four = NonZeroI16::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<i16>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<i16>>
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 = NonZeroI16::new(3)?;
let twenty_seven = NonZeroI16::new(27)?;
let half_max = NonZeroI16::new(i16::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<i16>
pub const fn saturating_pow(self, other: u32) -> NonZero<i16>
Raise non-zero value to an integer power.
Return NonZeroI16::MIN
or NonZeroI16::MAX
on overflow.
§Examples
let three = NonZeroI16::new(3)?;
let twenty_seven = NonZeroI16::new(27)?;
let max = NonZeroI16::new(i16::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<i32>
impl NonZero<i32>
1.34.0 (const: 1.34.0) · sourcepub const unsafe fn new_unchecked(n: i32) -> NonZero<i32>
pub const unsafe fn new_unchecked(n: i32) -> NonZero<i32>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.34.0 (const: 1.47.0) · sourcepub const fn new(n: i32) -> Option<NonZero<i32>>
pub const fn new(n: i32) -> Option<NonZero<i32>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut i32) -> &mut NonZero<i32>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut i32) -> &mut NonZero<i32>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut i32) -> Option<&mut NonZero<i32>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut i32) -> Option<&mut NonZero<i32>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroI32::new(-1i32).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroI32::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroI32::new(0b100_0000)?;
let b = NonZeroI32::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.70.0 · sourcepub const MIN: NonZero<i32> = _
pub const MIN: NonZero<i32> = _
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!(NonZeroI32::MIN.get(), i32::MIN);
Run1.70.0 · sourcepub const MAX: NonZero<i32> = _
pub const MAX: NonZero<i32> = _
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!(NonZeroI32::MAX.get(), i32::MAX);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_abs(self) -> Option<NonZero<i32>>
pub const fn checked_abs(self) -> Option<NonZero<i32>>
Checked absolute value.
Checks for overflow and returns None
if
self == NonZeroI32::MIN
.
The result cannot be zero.
§Example
let pos = NonZeroI32::new(1)?;
let neg = NonZeroI32::new(-1)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn overflowing_abs(self) -> (NonZero<i32>, bool)
pub const fn overflowing_abs(self) -> (NonZero<i32>, bool)
Computes the absolute value of self,
with overflow information, see
i32::overflowing_abs
.
§Example
let pos = NonZeroI32::new(1)?;
let neg = NonZeroI32::new(-1)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_abs(self) -> NonZero<i32>
pub const fn saturating_abs(self) -> NonZero<i32>
Saturating absolute value, see
i32::saturating_abs
.
§Example
let pos = NonZeroI32::new(1)?;
let neg = NonZeroI32::new(-1)?;
let min = NonZeroI32::new(i32::MIN)?;
let min_plus = NonZeroI32::new(i32::MIN + 1)?;
let max = NonZeroI32::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn wrapping_abs(self) -> NonZero<i32>
pub const fn wrapping_abs(self) -> NonZero<i32>
Wrapping absolute value, see
i32::wrapping_abs
.
§Example
let pos = NonZeroI32::new(1)?;
let neg = NonZeroI32::new(-1)?;
let min = NonZeroI32::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn unsigned_abs(self) -> NonZero<u32>
pub const fn unsigned_abs(self) -> NonZero<u32>
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZeroU32::new(1)?;
let i_pos = NonZeroI32::new(1)?;
let i_neg = NonZeroI32::new(-1)?;
let i_min = NonZeroI32::new(i32::MIN)?;
let u_max = NonZeroU32::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());
Run1.71.0 (const: 1.71.0) · sourcepub const fn is_positive(self) -> bool
pub const fn is_positive(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn is_negative(self) -> bool
pub const fn is_negative(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn checked_neg(self) -> Option<NonZero<i32>>
pub const fn checked_neg(self) -> Option<NonZero<i32>>
1.71.0 (const: 1.71.0) · sourcepub const fn overflowing_neg(self) -> (NonZero<i32>, bool)
pub const fn overflowing_neg(self) -> (NonZero<i32>, bool)
Negates self, overflowing if this is equal to the minimum value.
See i32::overflowing_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI32::new(5)?;
let neg_five = NonZeroI32::new(-5)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));
Run1.71.0 (const: 1.71.0) · sourcepub const fn saturating_neg(self) -> NonZero<i32>
pub const fn saturating_neg(self) -> NonZero<i32>
Saturating negation. Computes -self
,
returning NonZeroI32::MAX
if self == NonZeroI32::MIN
instead of overflowing.
§Example
let pos_five = NonZeroI32::new(5)?;
let neg_five = NonZeroI32::new(-5)?;
let min = NonZeroI32::new(i32::MIN)?;
let min_plus_one = NonZeroI32::new(i32::MIN + 1)?;
let max = NonZeroI32::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);
Run1.71.0 (const: 1.71.0) · sourcepub const fn wrapping_neg(self) -> NonZero<i32>
pub const fn wrapping_neg(self) -> NonZero<i32>
Wrapping (modular) negation. Computes -self
, wrapping around at the boundary
of the type.
See i32::wrapping_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI32::new(5)?;
let neg_five = NonZeroI32::new(-5)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<i32>) -> Option<NonZero<i32>>
pub const fn checked_mul(self, other: NonZero<i32>) -> Option<NonZero<i32>>
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 = NonZeroI32::new(2)?;
let four = NonZeroI32::new(4)?;
let max = NonZeroI32::new(i32::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<i32>) -> NonZero<i32>
pub const fn saturating_mul(self, other: NonZero<i32>) -> NonZero<i32>
Multiplies two non-zero integers together.
Return NonZeroI32::MAX
on overflow.
§Examples
let two = NonZeroI32::new(2)?;
let four = NonZeroI32::new(4)?;
let max = NonZeroI32::new(i32::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<i32>) -> NonZero<i32>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<i32>) -> NonZero<i32>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > i32::MAX
, or self * rhs < i32::MIN
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroI32::new(2)?;
let four = NonZeroI32::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<i32>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<i32>>
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 = NonZeroI32::new(3)?;
let twenty_seven = NonZeroI32::new(27)?;
let half_max = NonZeroI32::new(i32::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<i32>
pub const fn saturating_pow(self, other: u32) -> NonZero<i32>
Raise non-zero value to an integer power.
Return NonZeroI32::MIN
or NonZeroI32::MAX
on overflow.
§Examples
let three = NonZeroI32::new(3)?;
let twenty_seven = NonZeroI32::new(27)?;
let max = NonZeroI32::new(i32::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<i64>
impl NonZero<i64>
1.34.0 (const: 1.34.0) · sourcepub const unsafe fn new_unchecked(n: i64) -> NonZero<i64>
pub const unsafe fn new_unchecked(n: i64) -> NonZero<i64>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.34.0 (const: 1.47.0) · sourcepub const fn new(n: i64) -> Option<NonZero<i64>>
pub const fn new(n: i64) -> Option<NonZero<i64>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut i64) -> &mut NonZero<i64>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut i64) -> &mut NonZero<i64>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut i64) -> Option<&mut NonZero<i64>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut i64) -> Option<&mut NonZero<i64>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroI64::new(-1i64).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroI64::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroI64::new(0b100_0000)?;
let b = NonZeroI64::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.70.0 · sourcepub const MIN: NonZero<i64> = _
pub const MIN: NonZero<i64> = _
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!(NonZeroI64::MIN.get(), i64::MIN);
Run1.70.0 · sourcepub const MAX: NonZero<i64> = _
pub const MAX: NonZero<i64> = _
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!(NonZeroI64::MAX.get(), i64::MAX);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_abs(self) -> Option<NonZero<i64>>
pub const fn checked_abs(self) -> Option<NonZero<i64>>
Checked absolute value.
Checks for overflow and returns None
if
self == NonZeroI64::MIN
.
The result cannot be zero.
§Example
let pos = NonZeroI64::new(1)?;
let neg = NonZeroI64::new(-1)?;
let min = NonZeroI64::new(i64::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn overflowing_abs(self) -> (NonZero<i64>, bool)
pub const fn overflowing_abs(self) -> (NonZero<i64>, bool)
Computes the absolute value of self,
with overflow information, see
i64::overflowing_abs
.
§Example
let pos = NonZeroI64::new(1)?;
let neg = NonZeroI64::new(-1)?;
let min = NonZeroI64::new(i64::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_abs(self) -> NonZero<i64>
pub const fn saturating_abs(self) -> NonZero<i64>
Saturating absolute value, see
i64::saturating_abs
.
§Example
let pos = NonZeroI64::new(1)?;
let neg = NonZeroI64::new(-1)?;
let min = NonZeroI64::new(i64::MIN)?;
let min_plus = NonZeroI64::new(i64::MIN + 1)?;
let max = NonZeroI64::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn wrapping_abs(self) -> NonZero<i64>
pub const fn wrapping_abs(self) -> NonZero<i64>
Wrapping absolute value, see
i64::wrapping_abs
.
§Example
let pos = NonZeroI64::new(1)?;
let neg = NonZeroI64::new(-1)?;
let min = NonZeroI64::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn unsigned_abs(self) -> NonZero<u64>
pub const fn unsigned_abs(self) -> NonZero<u64>
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZeroU64::new(1)?;
let i_pos = NonZeroI64::new(1)?;
let i_neg = NonZeroI64::new(-1)?;
let i_min = NonZeroI64::new(i64::MIN)?;
let u_max = NonZeroU64::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());
Run1.71.0 (const: 1.71.0) · sourcepub const fn is_positive(self) -> bool
pub const fn is_positive(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn is_negative(self) -> bool
pub const fn is_negative(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn checked_neg(self) -> Option<NonZero<i64>>
pub const fn checked_neg(self) -> Option<NonZero<i64>>
1.71.0 (const: 1.71.0) · sourcepub const fn overflowing_neg(self) -> (NonZero<i64>, bool)
pub const fn overflowing_neg(self) -> (NonZero<i64>, bool)
Negates self, overflowing if this is equal to the minimum value.
See i64::overflowing_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI64::new(5)?;
let neg_five = NonZeroI64::new(-5)?;
let min = NonZeroI64::new(i64::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));
Run1.71.0 (const: 1.71.0) · sourcepub const fn saturating_neg(self) -> NonZero<i64>
pub const fn saturating_neg(self) -> NonZero<i64>
Saturating negation. Computes -self
,
returning NonZeroI64::MAX
if self == NonZeroI64::MIN
instead of overflowing.
§Example
let pos_five = NonZeroI64::new(5)?;
let neg_five = NonZeroI64::new(-5)?;
let min = NonZeroI64::new(i64::MIN)?;
let min_plus_one = NonZeroI64::new(i64::MIN + 1)?;
let max = NonZeroI64::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);
Run1.71.0 (const: 1.71.0) · sourcepub const fn wrapping_neg(self) -> NonZero<i64>
pub const fn wrapping_neg(self) -> NonZero<i64>
Wrapping (modular) negation. Computes -self
, wrapping around at the boundary
of the type.
See i64::wrapping_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI64::new(5)?;
let neg_five = NonZeroI64::new(-5)?;
let min = NonZeroI64::new(i64::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<i64>) -> Option<NonZero<i64>>
pub const fn checked_mul(self, other: NonZero<i64>) -> Option<NonZero<i64>>
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 = NonZeroI64::new(2)?;
let four = NonZeroI64::new(4)?;
let max = NonZeroI64::new(i64::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<i64>) -> NonZero<i64>
pub const fn saturating_mul(self, other: NonZero<i64>) -> NonZero<i64>
Multiplies two non-zero integers together.
Return NonZeroI64::MAX
on overflow.
§Examples
let two = NonZeroI64::new(2)?;
let four = NonZeroI64::new(4)?;
let max = NonZeroI64::new(i64::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<i64>) -> NonZero<i64>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<i64>) -> NonZero<i64>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > i64::MAX
, or self * rhs < i64::MIN
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroI64::new(2)?;
let four = NonZeroI64::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<i64>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<i64>>
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 = NonZeroI64::new(3)?;
let twenty_seven = NonZeroI64::new(27)?;
let half_max = NonZeroI64::new(i64::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<i64>
pub const fn saturating_pow(self, other: u32) -> NonZero<i64>
Raise non-zero value to an integer power.
Return NonZeroI64::MIN
or NonZeroI64::MAX
on overflow.
§Examples
let three = NonZeroI64::new(3)?;
let twenty_seven = NonZeroI64::new(27)?;
let max = NonZeroI64::new(i64::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<i128>
impl NonZero<i128>
1.34.0 (const: 1.34.0) · sourcepub const unsafe fn new_unchecked(n: i128) -> NonZero<i128>
pub const unsafe fn new_unchecked(n: i128) -> NonZero<i128>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.34.0 (const: 1.47.0) · sourcepub const fn new(n: i128) -> Option<NonZero<i128>>
pub const fn new(n: i128) -> Option<NonZero<i128>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut i128) -> &mut NonZero<i128>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut i128) -> &mut NonZero<i128>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut i128) -> Option<&mut NonZero<i128>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut i128) -> Option<&mut NonZero<i128>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.67.0 · sourcepub const BITS: u32 = 128u32
pub const BITS: u32 = 128u32
The size of this non-zero integer type in bits.
This value is equal to i128::BITS
.
§Examples
assert_eq!(NonZeroI128::BITS, i128::BITS);
Run1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroI128::new(-1i128).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroI128::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroI128::new(0b100_0000)?;
let b = NonZeroI128::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.70.0 · sourcepub const MIN: NonZero<i128> = _
pub const MIN: NonZero<i128> = _
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!(NonZeroI128::MIN.get(), i128::MIN);
Run1.70.0 · sourcepub const MAX: NonZero<i128> = _
pub const MAX: NonZero<i128> = _
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!(NonZeroI128::MAX.get(), i128::MAX);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_abs(self) -> Option<NonZero<i128>>
pub const fn checked_abs(self) -> Option<NonZero<i128>>
Checked absolute value.
Checks for overflow and returns None
if
self == NonZeroI128::MIN
.
The result cannot be zero.
§Example
let pos = NonZeroI128::new(1)?;
let neg = NonZeroI128::new(-1)?;
let min = NonZeroI128::new(i128::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn overflowing_abs(self) -> (NonZero<i128>, bool)
pub const fn overflowing_abs(self) -> (NonZero<i128>, bool)
Computes the absolute value of self,
with overflow information, see
i128::overflowing_abs
.
§Example
let pos = NonZeroI128::new(1)?;
let neg = NonZeroI128::new(-1)?;
let min = NonZeroI128::new(i128::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_abs(self) -> NonZero<i128>
pub const fn saturating_abs(self) -> NonZero<i128>
Saturating absolute value, see
i128::saturating_abs
.
§Example
let pos = NonZeroI128::new(1)?;
let neg = NonZeroI128::new(-1)?;
let min = NonZeroI128::new(i128::MIN)?;
let min_plus = NonZeroI128::new(i128::MIN + 1)?;
let max = NonZeroI128::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn wrapping_abs(self) -> NonZero<i128>
pub const fn wrapping_abs(self) -> NonZero<i128>
Wrapping absolute value, see
i128::wrapping_abs
.
§Example
let pos = NonZeroI128::new(1)?;
let neg = NonZeroI128::new(-1)?;
let min = NonZeroI128::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn unsigned_abs(self) -> NonZero<u128>
pub const fn unsigned_abs(self) -> NonZero<u128>
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZeroU128::new(1)?;
let i_pos = NonZeroI128::new(1)?;
let i_neg = NonZeroI128::new(-1)?;
let i_min = NonZeroI128::new(i128::MIN)?;
let u_max = NonZeroU128::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());
Run1.71.0 (const: 1.71.0) · sourcepub const fn is_positive(self) -> bool
pub const fn is_positive(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn is_negative(self) -> bool
pub const fn is_negative(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn checked_neg(self) -> Option<NonZero<i128>>
pub const fn checked_neg(self) -> Option<NonZero<i128>>
1.71.0 (const: 1.71.0) · sourcepub const fn overflowing_neg(self) -> (NonZero<i128>, bool)
pub const fn overflowing_neg(self) -> (NonZero<i128>, bool)
Negates self, overflowing if this is equal to the minimum value.
See i128::overflowing_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI128::new(5)?;
let neg_five = NonZeroI128::new(-5)?;
let min = NonZeroI128::new(i128::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));
Run1.71.0 (const: 1.71.0) · sourcepub const fn saturating_neg(self) -> NonZero<i128>
pub const fn saturating_neg(self) -> NonZero<i128>
Saturating negation. Computes -self
,
returning NonZeroI128::MAX
if self == NonZeroI128::MIN
instead of overflowing.
§Example
let pos_five = NonZeroI128::new(5)?;
let neg_five = NonZeroI128::new(-5)?;
let min = NonZeroI128::new(i128::MIN)?;
let min_plus_one = NonZeroI128::new(i128::MIN + 1)?;
let max = NonZeroI128::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);
Run1.71.0 (const: 1.71.0) · sourcepub const fn wrapping_neg(self) -> NonZero<i128>
pub const fn wrapping_neg(self) -> NonZero<i128>
Wrapping (modular) negation. Computes -self
, wrapping around at the boundary
of the type.
See i128::wrapping_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI128::new(5)?;
let neg_five = NonZeroI128::new(-5)?;
let min = NonZeroI128::new(i128::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<i128>) -> Option<NonZero<i128>>
pub const fn checked_mul(self, other: NonZero<i128>) -> Option<NonZero<i128>>
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 = NonZeroI128::new(2)?;
let four = NonZeroI128::new(4)?;
let max = NonZeroI128::new(i128::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<i128>) -> NonZero<i128>
pub const fn saturating_mul(self, other: NonZero<i128>) -> NonZero<i128>
Multiplies two non-zero integers together.
Return NonZeroI128::MAX
on overflow.
§Examples
let two = NonZeroI128::new(2)?;
let four = NonZeroI128::new(4)?;
let max = NonZeroI128::new(i128::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<i128>) -> NonZero<i128>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<i128>) -> NonZero<i128>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > i128::MAX
, or self * rhs < i128::MIN
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroI128::new(2)?;
let four = NonZeroI128::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<i128>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<i128>>
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 = NonZeroI128::new(3)?;
let twenty_seven = NonZeroI128::new(27)?;
let half_max = NonZeroI128::new(i128::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<i128>
pub const fn saturating_pow(self, other: u32) -> NonZero<i128>
Raise non-zero value to an integer power.
Return NonZeroI128::MIN
or NonZeroI128::MAX
on overflow.
§Examples
let three = NonZeroI128::new(3)?;
let twenty_seven = NonZeroI128::new(27)?;
let max = NonZeroI128::new(i128::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZero<isize>
impl NonZero<isize>
1.34.0 (const: 1.34.0) · sourcepub const unsafe fn new_unchecked(n: isize) -> NonZero<isize>
pub const unsafe fn new_unchecked(n: isize) -> NonZero<isize>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
1.34.0 (const: 1.47.0) · sourcepub const fn new(n: isize) -> Option<NonZero<isize>>
pub const fn new(n: isize) -> Option<NonZero<isize>>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut isize) -> &mut NonZero<isize>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub unsafe fn from_mut_unchecked(n: &mut isize) -> &mut NonZero<isize>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut isize) -> Option<&mut NonZero<isize>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
#106290)
pub fn from_mut(n: &mut isize) -> Option<&mut NonZero<isize>>
nonzero_from_mut
#106290)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.34.0 (const: 1.34.0) · sourcepub const fn get(self) -> isize
pub const fn get(self) -> isize
Returns the value as a primitive type.
1.67.0 · sourcepub const BITS: u32 = 64u32
pub const BITS: u32 = 64u32
The size of this non-zero integer type in bits.
This value is equal to isize::BITS
.
§Examples
assert_eq!(NonZeroIsize::BITS, isize::BITS);
Run1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
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 = std::num::NonZeroIsize::new(-1isize).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
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 = std::num::NonZeroIsize::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runconst: unstable · sourcepub fn count_ones(self) -> NonZero<u32>
🔬This is a nightly-only experimental API. (non_zero_count_ones
#120287)
pub fn count_ones(self) -> NonZero<u32>
non_zero_count_ones
#120287)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroIsize::new(0b100_0000)?;
let b = NonZeroIsize::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
Run1.70.0 · sourcepub const MIN: NonZero<isize> = _
pub const MIN: NonZero<isize> = _
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!(NonZeroIsize::MIN.get(), isize::MIN);
Run1.70.0 · sourcepub const MAX: NonZero<isize> = _
pub const MAX: NonZero<isize> = _
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!(NonZeroIsize::MAX.get(), isize::MAX);
Run1.64.0 (const: 1.64.0) · sourcepub const fn abs(self) -> NonZero<isize>
pub const fn abs(self) -> NonZero<isize>
Computes the absolute value of self.
See isize::abs
for documentation on overflow behaviour.
§Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;
assert_eq!(pos, pos.abs());
assert_eq!(pos, neg.abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_abs(self) -> Option<NonZero<isize>>
pub const fn checked_abs(self) -> Option<NonZero<isize>>
Checked absolute value.
Checks for overflow and returns None
if
self == NonZeroIsize::MIN
.
The result cannot be zero.
§Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;
let min = NonZeroIsize::new(isize::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn overflowing_abs(self) -> (NonZero<isize>, bool)
pub const fn overflowing_abs(self) -> (NonZero<isize>, bool)
Computes the absolute value of self,
with overflow information, see
isize::overflowing_abs
.
§Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;
let min = NonZeroIsize::new(isize::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_abs(self) -> NonZero<isize>
pub const fn saturating_abs(self) -> NonZero<isize>
Saturating absolute value, see
isize::saturating_abs
.
§Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;
let min = NonZeroIsize::new(isize::MIN)?;
let min_plus = NonZeroIsize::new(isize::MIN + 1)?;
let max = NonZeroIsize::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn wrapping_abs(self) -> NonZero<isize>
pub const fn wrapping_abs(self) -> NonZero<isize>
Wrapping absolute value, see
isize::wrapping_abs
.
§Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;
let min = NonZeroIsize::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());
Run1.64.0 (const: 1.64.0) · sourcepub const fn unsigned_abs(self) -> NonZero<usize>
pub const fn unsigned_abs(self) -> NonZero<usize>
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZeroUsize::new(1)?;
let i_pos = NonZeroIsize::new(1)?;
let i_neg = NonZeroIsize::new(-1)?;
let i_min = NonZeroIsize::new(isize::MIN)?;
let u_max = NonZeroUsize::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());
Run1.71.0 (const: 1.71.0) · sourcepub const fn is_positive(self) -> bool
pub const fn is_positive(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn is_negative(self) -> bool
pub const fn is_negative(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn checked_neg(self) -> Option<NonZero<isize>>
pub const fn checked_neg(self) -> Option<NonZero<isize>>
1.71.0 (const: 1.71.0) · sourcepub const fn overflowing_neg(self) -> (NonZero<isize>, bool)
pub const fn overflowing_neg(self) -> (NonZero<isize>, bool)
Negates self, overflowing if this is equal to the minimum value.
See isize::overflowing_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroIsize::new(5)?;
let neg_five = NonZeroIsize::new(-5)?;
let min = NonZeroIsize::new(isize::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));
Run1.71.0 (const: 1.71.0) · sourcepub const fn saturating_neg(self) -> NonZero<isize>
pub const fn saturating_neg(self) -> NonZero<isize>
Saturating negation. Computes -self
,
returning NonZeroIsize::MAX
if self == NonZeroIsize::MIN
instead of overflowing.
§Example
let pos_five = NonZeroIsize::new(5)?;
let neg_five = NonZeroIsize::new(-5)?;
let min = NonZeroIsize::new(isize::MIN)?;
let min_plus_one = NonZeroIsize::new(isize::MIN + 1)?;
let max = NonZeroIsize::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);
Run1.71.0 (const: 1.71.0) · sourcepub const fn wrapping_neg(self) -> NonZero<isize>
pub const fn wrapping_neg(self) -> NonZero<isize>
Wrapping (modular) negation. Computes -self
, wrapping around at the boundary
of the type.
See isize::wrapping_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroIsize::new(5)?;
let neg_five = NonZeroIsize::new(-5)?;
let min = NonZeroIsize::new(isize::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZero<isize>) -> Option<NonZero<isize>>
pub const fn checked_mul(self, other: NonZero<isize>) -> Option<NonZero<isize>>
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 = NonZeroIsize::new(2)?;
let four = NonZeroIsize::new(4)?;
let max = NonZeroIsize::new(isize::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZero<isize>) -> NonZero<isize>
pub const fn saturating_mul(self, other: NonZero<isize>) -> NonZero<isize>
Multiplies two non-zero integers together.
Return NonZeroIsize::MAX
on overflow.
§Examples
let two = NonZeroIsize::new(2)?;
let four = NonZeroIsize::new(4)?;
let max = NonZeroIsize::new(isize::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZero<isize>) -> NonZero<isize>
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZero<isize>) -> NonZero<isize>
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > isize::MAX
, or self * rhs < isize::MIN
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroIsize::new(2)?;
let four = NonZeroIsize::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<isize>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<isize>>
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 = NonZeroIsize::new(3)?;
let twenty_seven = NonZeroIsize::new(27)?;
let half_max = NonZeroIsize::new(isize::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZero<isize>
pub const fn saturating_pow(self, other: u32) -> NonZero<isize>
Raise non-zero value to an integer power.
Return NonZeroIsize::MIN
or NonZeroIsize::MAX
on overflow.
§Examples
let three = NonZeroIsize::new(3)?;
let twenty_seven = NonZeroIsize::new(27)?;
let max = NonZeroIsize::new(isize::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
RunTrait Implementations§
1.45.0 · source§impl BitOrAssign<i128> for NonZero<i128>
impl BitOrAssign<i128> for NonZero<i128>
source§fn bitor_assign(&mut self, rhs: i128)
fn bitor_assign(&mut self, rhs: i128)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<i16> for NonZero<i16>
impl BitOrAssign<i16> for NonZero<i16>
source§fn bitor_assign(&mut self, rhs: i16)
fn bitor_assign(&mut self, rhs: i16)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<i32> for NonZero<i32>
impl BitOrAssign<i32> for NonZero<i32>
source§fn bitor_assign(&mut self, rhs: i32)
fn bitor_assign(&mut self, rhs: i32)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<i64> for NonZero<i64>
impl BitOrAssign<i64> for NonZero<i64>
source§fn bitor_assign(&mut self, rhs: i64)
fn bitor_assign(&mut self, rhs: i64)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<i8> for NonZero<i8>
impl BitOrAssign<i8> for NonZero<i8>
source§fn bitor_assign(&mut self, rhs: i8)
fn bitor_assign(&mut self, rhs: i8)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<isize> for NonZero<isize>
impl BitOrAssign<isize> for NonZero<isize>
source§fn bitor_assign(&mut self, rhs: isize)
fn bitor_assign(&mut self, rhs: isize)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<u128> for NonZero<u128>
impl BitOrAssign<u128> for NonZero<u128>
source§fn bitor_assign(&mut self, rhs: u128)
fn bitor_assign(&mut self, rhs: u128)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<u16> for NonZero<u16>
impl BitOrAssign<u16> for NonZero<u16>
source§fn bitor_assign(&mut self, rhs: u16)
fn bitor_assign(&mut self, rhs: u16)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<u32> for NonZero<u32>
impl BitOrAssign<u32> for NonZero<u32>
source§fn bitor_assign(&mut self, rhs: u32)
fn bitor_assign(&mut self, rhs: u32)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<u64> for NonZero<u64>
impl BitOrAssign<u64> for NonZero<u64>
source§fn bitor_assign(&mut self, rhs: u64)
fn bitor_assign(&mut self, rhs: u64)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<u8> for NonZero<u8>
impl BitOrAssign<u8> for NonZero<u8>
source§fn bitor_assign(&mut self, rhs: u8)
fn bitor_assign(&mut self, rhs: u8)
|=
operation. Read more1.45.0 · source§impl BitOrAssign<usize> for NonZero<usize>
impl BitOrAssign<usize> for NonZero<usize>
source§fn bitor_assign(&mut self, rhs: usize)
fn bitor_assign(&mut self, rhs: usize)
|=
operation. Read more1.45.0 · source§impl BitOrAssign for NonZero<i128>
impl BitOrAssign for NonZero<i128>
1.45.0 · source§impl BitOrAssign for NonZero<i16>
impl BitOrAssign for NonZero<i16>
1.45.0 · source§impl BitOrAssign for NonZero<i32>
impl BitOrAssign for NonZero<i32>
1.45.0 · source§impl BitOrAssign for NonZero<i64>
impl BitOrAssign for NonZero<i64>
1.45.0 · source§impl BitOrAssign for NonZero<i8>
impl BitOrAssign for NonZero<i8>
1.45.0 · source§impl BitOrAssign for NonZero<isize>
impl BitOrAssign for NonZero<isize>
1.45.0 · source§impl BitOrAssign for NonZero<u128>
impl BitOrAssign for NonZero<u128>
1.45.0 · source§impl BitOrAssign for NonZero<u16>
impl BitOrAssign for NonZero<u16>
1.45.0 · source§impl BitOrAssign for NonZero<u32>
impl BitOrAssign for NonZero<u32>
1.45.0 · source§impl BitOrAssign for NonZero<u64>
impl BitOrAssign for NonZero<u64>
1.45.0 · source§impl BitOrAssign for NonZero<u8>
impl BitOrAssign for NonZero<u8>
1.45.0 · source§impl BitOrAssign for NonZero<usize>
impl BitOrAssign for NonZero<usize>
1.34.0 · source§impl Ord for NonZero<i128>
impl Ord for NonZero<i128>
1.34.0 · source§impl Ord for NonZero<i16>
impl Ord for NonZero<i16>
1.34.0 · source§impl Ord for NonZero<i32>
impl Ord for NonZero<i32>
1.34.0 · source§impl Ord for NonZero<i64>
impl Ord for NonZero<i64>
1.34.0 · source§impl Ord for NonZero<i8>
impl Ord for NonZero<i8>
1.34.0 · source§impl Ord for NonZero<isize>
impl Ord for NonZero<isize>
1.28.0 · source§impl Ord for NonZero<u128>
impl Ord for NonZero<u128>
1.28.0 · source§impl Ord for NonZero<u16>
impl Ord for NonZero<u16>
1.28.0 · source§impl Ord for NonZero<u32>
impl Ord for NonZero<u32>
1.28.0 · source§impl Ord for NonZero<u64>
impl Ord for NonZero<u64>
1.28.0 · source§impl Ord for NonZero<u8>
impl Ord for NonZero<u8>
1.28.0 · source§impl Ord for NonZero<usize>
impl Ord for NonZero<usize>
1.34.0 · source§impl PartialEq for NonZero<i128>
impl PartialEq for NonZero<i128>
1.34.0 · source§impl PartialEq for NonZero<i16>
impl PartialEq for NonZero<i16>
1.34.0 · source§impl PartialEq for NonZero<i32>
impl PartialEq for NonZero<i32>
1.34.0 · source§impl PartialEq for NonZero<i64>
impl PartialEq for NonZero<i64>
1.34.0 · source§impl PartialEq for NonZero<i8>
impl PartialEq for NonZero<i8>
1.34.0 · source§impl PartialEq for NonZero<isize>
impl PartialEq for NonZero<isize>
1.28.0 · source§impl PartialEq for NonZero<u128>
impl PartialEq for NonZero<u128>
1.28.0 · source§impl PartialEq for NonZero<u16>
impl PartialEq for NonZero<u16>
1.28.0 · source§impl PartialEq for NonZero<u32>
impl PartialEq for NonZero<u32>
1.28.0 · source§impl PartialEq for NonZero<u64>
impl PartialEq for NonZero<u64>
1.28.0 · source§impl PartialEq for NonZero<u8>
impl PartialEq for NonZero<u8>
1.28.0 · source§impl PartialEq for NonZero<usize>
impl PartialEq for NonZero<usize>
1.34.0 · source§impl PartialOrd for NonZero<i128>
impl PartialOrd for NonZero<i128>
source§fn le(&self, other: &NonZero<i128>) -> bool
fn le(&self, other: &NonZero<i128>) -> bool
self
and other
) and is used by the <=
operator. Read more1.34.0 · source§impl PartialOrd for NonZero<i16>
impl PartialOrd for NonZero<i16>
source§fn le(&self, other: &NonZero<i16>) -> bool
fn le(&self, other: &NonZero<i16>) -> bool
self
and other
) and is used by the <=
operator. Read more1.34.0 · source§impl PartialOrd for NonZero<i32>
impl PartialOrd for NonZero<i32>
source§fn le(&self, other: &NonZero<i32>) -> bool
fn le(&self, other: &NonZero<i32>) -> bool
self
and other
) and is used by the <=
operator. Read more1.34.0 · source§impl PartialOrd for NonZero<i64>
impl PartialOrd for NonZero<i64>
source§fn le(&self, other: &NonZero<i64>) -> bool
fn le(&self, other: &NonZero<i64>) -> bool
self
and other
) and is used by the <=
operator. Read more1.34.0 · source§impl PartialOrd for NonZero<i8>
impl PartialOrd for NonZero<i8>
source§fn le(&self, other: &NonZero<i8>) -> bool
fn le(&self, other: &NonZero<i8>) -> bool
self
and other
) and is used by the <=
operator. Read more1.34.0 · source§impl PartialOrd for NonZero<isize>
impl PartialOrd for NonZero<isize>
source§fn le(&self, other: &NonZero<isize>) -> bool
fn le(&self, other: &NonZero<isize>) -> bool
self
and other
) and is used by the <=
operator. Read more1.28.0 · source§impl PartialOrd for NonZero<u128>
impl PartialOrd for NonZero<u128>
source§fn le(&self, other: &NonZero<u128>) -> bool
fn le(&self, other: &NonZero<u128>) -> bool
self
and other
) and is used by the <=
operator. Read more1.28.0 · source§impl PartialOrd for NonZero<u16>
impl PartialOrd for NonZero<u16>
source§fn le(&self, other: &NonZero<u16>) -> bool
fn le(&self, other: &NonZero<u16>) -> bool
self
and other
) and is used by the <=
operator. Read more1.28.0 · source§impl PartialOrd for NonZero<u32>
impl PartialOrd for NonZero<u32>
source§fn le(&self, other: &NonZero<u32>) -> bool
fn le(&self, other: &NonZero<u32>) -> bool
self
and other
) and is used by the <=
operator. Read more1.28.0 · source§impl PartialOrd for NonZero<u64>
impl PartialOrd for NonZero<u64>
source§fn le(&self, other: &NonZero<u64>) -> bool
fn le(&self, other: &NonZero<u64>) -> bool
self
and other
) and is used by the <=
operator. Read more1.28.0 · source§impl PartialOrd for NonZero<u8>
impl PartialOrd for NonZero<u8>
source§fn le(&self, other: &NonZero<u8>) -> bool
fn le(&self, other: &NonZero<u8>) -> bool
self
and other
) and is used by the <=
operator. Read more1.28.0 · source§impl PartialOrd for NonZero<usize>
impl PartialOrd for NonZero<usize>
source§fn le(&self, other: &NonZero<usize>) -> bool
fn le(&self, other: &NonZero<usize>) -> bool
self
and other
) and is used by the <=
operator. Read more