Type Alias NonZeroU128

pub type NonZeroU128 = NonZero<u128>;

core An unsigned integer that is known not to equal zero.

Re-exported from core::num:: .

---

A u128 that is known not to equal zero.

This enables some memory layout optimization. For example, Option<NonZeroU128> is the same size as u128:

use std::mem::size_of;
assert_eq!(size_of::<Option<core::num::NonZeroU128>>(), size_of::<u128>());

Layout

NonZeroU128 is guaranteed to have the same layout and bit validity as u128 with the exception that 0 is not a valid instance. Option<NonZeroU128> is guaranteed to be compatible with u128, including in FFI.

Thanks to the null pointer optimization, NonZeroU128 and Option<NonZeroU128> are guaranteed to have the same size and alignment:

use std::num::NonZeroU128;

assert_eq!(size_of::<NonZeroU128>(), size_of::<Option<NonZeroU128>>());
assert_eq!(align_of::<NonZeroU128>(), align_of::<Option<NonZeroU128>>());

Aliased Type

struct NonZeroU128(/* private fields */);

Trait Implementations

impl BitSized<128> for NonZeroU128

const BIT_SIZE: usize = _

The bit size of this type (only the relevant data part, without padding).

const MIN_BYTE_SIZE: usize = _

The rounded up byte size for this type.

fn bit_size(&self) -> usize

Returns the bit size of this type (only the relevant data part, without padding).

fn min_byte_size(&self) -> usize

Returns the rounded up byte size for this type.

impl Num for NonZeroU128

Available on crate feature _int_u128 only.

fn num_set_one(&mut self) -> Result<()>

Features

Makes use of the unsafe_niche feature if enabled.

type Inner = u128

The internal representation of this numeric type.

type Out = NonZero<u128>

The output type for operations.

type Rhs = NonZero<u128>

The right hand side type for operations.

fn num_into(self) -> Self::Inner

Returns the inner self representation.

fn num_from(from: Self::Inner) -> Result<Self>

Returns Self if given a valid value.

fn num_from_ref(from: &Self::Inner) -> Result<Self>

Returns Self if given a valid &value.

fn num_set(&mut self, value: Self::Inner) -> Result<()>

Sets self to the given valid value.

fn num_set_ref(&mut self, value: &Self::Inner) -> Result<()>

Sets self to the given valid &value.

fn num_is_zero(&self) -> Result<bool>

Returns true if self is zero.

fn num_is_one(&self) -> Result<bool>

Returns true if self is one.

fn num_get_zero() -> Result<Self>

Returns the number zero.

fn num_get_one() -> Result<Self>

Returns the number one.

fn num_set_zero(&mut self) -> Result<()>

Sets self to 0.

fn num_mul(self, other: Self) -> Result<Self::Out>

Computes self * rhs (multiplication).

fn num_ref_mul(&self, other: &Self) -> Result<Self::Out>

Like num_mul but takes the arguments by reference.

fn num_ref_mul_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self *= rhs; (multiplication).

fn num_add(self, other: Self) -> Result<Self::Out>

Computes self + rhs (addition).

fn num_ref_add(&self, other: &Self) -> Result<Self::Out>

Like num_add but takes the arguments by reference.

fn num_ref_add_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self += rhs; (addition).

fn num_sub(self, other: Self) -> Result<Self::Out>

Computes self - rhs (subtraction).

fn num_ref_sub(&self, other: &Self) -> Result<Self::Out>

Like num_sub but takes the arguments by reference.

fn num_ref_sub_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self -= rhs; (subtraction).

fn num_div(self, other: Self) -> Result<Self::Out>

Computes self / rhs (division).

fn num_ref_div(&self, other: &Self) -> Result<Self::Out>

Like num_div but takes the arguments by reference.

fn num_ref_div_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self /= rhs; (division).

fn num_rem(self, other: Self) -> Result<Self::Out>

Computes self % rhs (remainder).

fn num_ref_rem(&self, other: &Self) -> Result<Self::Out>

Like num_rem but takes the arguments by reference.

fn num_ref_rem_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self %= rhs; (remainder).

fn num_abs(self) -> Result<Self>

Computes |self| (absolute value).

fn num_ref_abs(&self) -> Result<Self>

Like num_abs but takes the arguments by reference.

fn num_neg(self) -> Result<Self::Out>

where Self: Sized,

Computes -self (additive inverse).

fn num_ref_neg(&self) -> Result<Self::Out>

Like num_neg but takes the arguments by reference.