Struct extprim::u128::u128

#[repr(C)]pub struct u128 { /* fields omitted */ }

An unsigned 128-bit number.

Implementations

impl u128

pub const fn new(lo: u64) -> u128

Constructs a new 128-bit integer from a 64-bit integer.

pub const fn from_built_in(value: u128) -> u128

Constructs a new 128-bit integer from the built-in 128-bit integer.

pub const fn from_parts(hi: u64, lo: u64) -> u128

Constructs a new 128-bit integer from the high-64-bit and low-64-bit parts.

The new integer can be considered as hi * 2**64 + lo.

Examples

use extprim::u128::u128;

let number = u128::from_parts(6692605942, 14083847773837265618);
assert_eq!(format!("{}", number), "123456789012345678901234567890");

pub fn low64(self) -> u64

Fetches the lower-64-bit of the number.

Examples

use extprim::u128::u128;

let number = u128::from_str_radix("ffd1390a0adc2fb8dabbb8174d95c99b", 16).unwrap();
assert_eq!(number.low64(), 0xdabbb8174d95c99b);

pub fn high64(self) -> u64

Fetch the higher-64-bit of the number.

Examples

use extprim::u128::u128;

let number = u128::from_str_radix("ffd1390a0adc2fb8dabbb8174d95c99b", 16).unwrap();
assert_eq!(number.high64(), 0xffd1390a0adc2fb8);

pub fn as_i128(self) -> i128

Converts this number to signed with wrapping.

Examples

use extprim::u128::u128;
use extprim::i128::i128;

let a = u128::from_str_radix( "ffd1390a0adc2fb8dabbb8174d95c99b", 16).unwrap();
let b = i128::from_str_radix("-002ec6f5f523d047254447e8b26a3665", 16).unwrap();
assert_eq!(a.as_i128(), b);
assert_eq!(b.as_u128(), a);

pub fn as_built_in(self) -> u128

Converts this number to the built-in 128-bit integer type.

impl u128

pub fn wrapping_add(self, other: u128) -> u128

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(5).wrapping_add(u128::new(6)), u128::new(11));
assert_eq!(u128::max_value().wrapping_add(u128::one()), u128::zero());

pub fn wrapping_sub(self, other: u128) -> u128

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).wrapping_sub(u128::new(5)), u128::one());
assert_eq!(u128::new(5).wrapping_sub(u128::new(6)), u128::max_value());

pub fn overflowing_add(self, other: u128) -> (u128, bool)

Calculates self + other.

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

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).overflowing_add(u128::new(13)), (u128::new(19), false));
assert_eq!(u128::max_value().overflowing_add(u128::one()), (u128::zero(), true));

pub fn overflowing_sub(self, other: u128) -> (u128, bool)

Calculates self - other.

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

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).overflowing_sub(u128::new(5)), (u128::one(), false));
assert_eq!(u128::new(5).overflowing_sub(u128::new(6)), (u128::max_value(), true));

pub fn saturating_add(self, other: u128) -> u128

Saturating integer addition. Computes self + other, saturating at the numeric bounds instead of overflowing.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(13).saturating_add(u128::new(7)), u128::new(20));

let huge_num = u128::from_str_radix("ccccccccbbbbbbbbaaaaaaaa99999999", 16).unwrap();
let also_big = u128::from_str_radix("5566778899aabbccddeeff0011223344", 16).unwrap();
assert_eq!(huge_num.saturating_add(also_big), u128::max_value());

pub fn saturating_sub(self, other: u128) -> u128

Saturating integer subtraction. Computes self - other, saturating at the numeric bounds instead of overflowing.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(91).saturating_sub(u128::new(13)), u128::new(78));
assert_eq!(u128::new(13).saturating_sub(u128::new(91)), u128::zero());

pub fn wrapping_neg(self) -> u128

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

Since unsigned types do not have negative equivalents all applications of this function will wrap (except for -0). For values smaller than the corresponding signed type's maximum the result is the same as casting the corresponding signed value. Any larger values are equivalent to MAX + 1 - (val - MAX - 1).

Examples

use extprim::u128::u128;

assert_eq!(u128::zero().wrapping_neg(), u128::zero());
assert_eq!(u128::one().wrapping_neg(), u128::max_value());
assert_eq!(u128::max_value().wrapping_neg(), u128::one());

impl u128

pub fn checked_add(self, other: u128) -> Option<u128>

Checked integer addition. Computes self + other, returning None if overflow occurred.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(5).checked_add(u128::new(8)), Some(u128::new(13)));
assert_eq!(u128::max_value().checked_add(u128::max_value()), None);

impl u128

pub fn checked_sub(self, other: u128) -> Option<u128>

Checked integer subtraction. Computes self - other, returning None if underflow occurred.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(8).checked_sub(u128::new(5)), Some(u128::new(3)));
assert_eq!(u128::new(5).checked_sub(u128::new(8)), None);

impl u128

pub fn wrapping_shl(self, shift: u32) -> u128

Panic-free bitwise shift-left; yields self << (shift % 128).

Examples

use extprim::u128::u128;

assert_eq!(u128::new(7).wrapping_shl(66), u128::from_parts(28, 0));
assert_eq!(u128::new(7).wrapping_shl(128), u128::new(7));
assert_eq!(u128::new(7).wrapping_shl(129), u128::new(14));

pub fn wrapping_shr(self, shift: u32) -> u128

Panic-free bitwsie shift-right; yields self >> (shift % 128).

Examples

use extprim::u128::u128;

assert_eq!(u128::max_value().wrapping_shr(66), u128::new(0x3fffffffffffffff));
assert_eq!(u128::new(7).wrapping_shr(128), u128::new(7));
assert_eq!(u128::new(7).wrapping_shr(129), u128::new(3));

pub fn overflowing_shl(self, other: u32) -> (u128, bool)

Shifts self left by other bits.

Returns a tuple of the shifted version of self along with a boolean indicating whether the shift value was larger than or equal to the number of bits (128). If the shift value is too large, then value is masked by 0x7f, and this value is then used to perform the shift.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(7).overflowing_shl(66), (u128::from_parts(28, 0), false));
assert_eq!(u128::new(7).overflowing_shl(128), (u128::new(7), true));
assert_eq!(u128::new(7).overflowing_shl(129), (u128::new(14), true));

pub fn overflowing_shr(self, other: u32) -> (u128, bool)

Shifts self right by other bits.

Returns a tuple of the shifted version of self along with a boolean indicating whether the shift value was larger than or equal to the number of bits (128). If the shift value is too large, then value is masked by 0x7f, and this value is then used to perform the shift.

Examples

use extprim::u128::u128;

assert_eq!(u128::max_value().overflowing_shr(66), (u128::new(0x3fffffffffffffff), false));
assert_eq!(u128::new(7).overflowing_shr(128), (u128::new(7), true));
assert_eq!(u128::new(7).overflowing_shr(129), (u128::new(3), true));

impl u128

pub fn checked_shl(self, other: u32) -> Option<u128>

Checked shift left. Computes self << other, returning None if the shift is larger than or equal to the number of bits in self (128).

Examples

use extprim::u128::u128;

assert_eq!(u128::new(7).checked_shl(66), Some(u128::from_parts(28, 0)));
assert_eq!(u128::new(7).checked_shl(128), None);
assert_eq!(u128::new(7).checked_shl(129), None);

impl u128

pub fn checked_shr(self, other: u32) -> Option<u128>

Checked shift right. Computes self >> other, returning None if the shift is larger than or equal to the number of bits in self (128).

Examples

use extprim::u128::u128;

assert_eq!(u128::max_value().checked_shr(66), Some(u128::new(0x3fffffffffffffff)));
assert_eq!(u128::new(7).checked_shr(128), None);
assert_eq!(u128::new(7).checked_shr(129), None);

impl u128

pub fn wrapping_mul(self, other: u128) -> u128

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).wrapping_mul(u128::new(9)), u128::new(54));

let a = u128::max_value() - u128::new(2);
let b = u128::max_value() - u128::new(4);
assert_eq!(a.wrapping_mul(b), u128::new(15));

pub fn overflowing_mul(self, other: u128) -> (u128, bool)

Calculates the multiplication of self and other.

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

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).overflowing_mul(u128::new(9)), (u128::new(54), false));

let a = u128::max_value() - u128::new(2);
let b = u128::max_value() - u128::new(4);
assert_eq!(a.overflowing_mul(b), (u128::new(15), true));

pub fn saturating_mul(self, other: u128) -> u128

Saturating integer multiplication. Computes self * other, saturating at the numeric bounds instead of overflowing.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).saturating_mul(u128::new(9)), u128::new(54));

let a = u128::max_value() - u128::new(2);
let b = u128::max_value() - u128::new(4);
assert_eq!(a.saturating_mul(b), u128::max_value());

pub fn wrapping_mul_64(self, other: u64) -> u128

Wrapping (modular) multiplication with a 64-bit number. Computes self * other, wrapping around at the boundary of the type.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).wrapping_mul_64(9), u128::new(54));

let a = u128::max_value() - u128::new(2);
assert_eq!(a.wrapping_mul_64(7), u128::max_value() - u128::new(20));

pub fn overflowing_mul_64(self, other: u64) -> (u128, bool)

Calculates the multiplication of self and other with a 64-bit number.

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

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).overflowing_mul_64(9), (u128::new(54), false));

let a = u128::max_value() - u128::new(2);
assert_eq!(a.overflowing_mul_64(7), (u128::max_value() - u128::new(20), true));

pub fn saturating_mul_64(self, other: u64) -> u128

Saturating integer multiplication with a 64-bit number. Computes self * other, saturating at the numeric bounds instead of overflowing.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).saturating_mul_64(9), u128::new(54));

let a = u128::max_value() - u128::new(2);
assert_eq!(a.saturating_mul_64(7), u128::max_value());

impl u128

pub fn checked_mul(self, other: u128) -> Option<u128>

Checked integer multiplication. Computes self * other, returning None if underflow or overflow occurred.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).checked_mul(u128::new(9)), Some(u128::new(54)));

let a = u128::max_value() - u128::new(2);
let b = u128::max_value() - u128::new(4);
assert_eq!(a.checked_mul(b), None);

impl u128

pub fn checked_mul_64(self, other: u64) -> Option<u128>

Checked integer multiplication with a 64-bit number. Computes self * other, returning None if underflow or overflow occurred.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(6).checked_mul_64(9), Some(u128::new(54)));

let a = u128::max_value() - u128::new(2);
assert_eq!(a.checked_mul_64(7), None);

impl u128

pub fn wrapping_div(self, other: u128) -> u128

Wrapping (modular) division. Computes self / other. Wrapped division on unsigned types is just normal division. There's no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

Panics

This function will panic if other is 0.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(100).wrapping_div(u128::new(8)), u128::new(12));

pub fn wrapping_rem(self, other: u128) -> u128

Wrapping (modular) remainder. Computes self % other. Wrapped remainder calculation on unsigned types is just the regular remainder calculation. There's no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

Panics

This function will panic if other is 0.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(100).wrapping_rem(u128::new(8)), u128::new(4));

pub fn overflowing_div(self, other: u128) -> (u128, bool)

Calculates the divisor when self is divided by other.

Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would occur. Note that for unsigned integers overflow never occurs, so the second value is always false.

Panics

This function will panic if other is 0.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(100).overflowing_div(u128::new(8)), (u128::new(12), false));

pub fn overflowing_rem(self, other: u128) -> (u128, bool)

Calculates the remainder when self is divided by other.

Returns a tuple of the remainder along with a boolean indicating whether an arithmetic overflow would occur. Note that for unsigned integers overflow never occurs, so the second value is always false.

Panics

This function will panic if other is 0.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(100).overflowing_rem(u128::new(8)), (u128::new(4), false));

pub fn checked_div(self, other: u128) -> Option<u128>

Checked integer division. Computes self / other, returning None if other == 0.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(100).checked_div(u128::new(8)), Some(u128::new(12)));
assert_eq!(u128::new(100).checked_div(u128::zero()), None);

pub fn checked_rem(self, other: u128) -> Option<u128>

Checked integer remainder. Computes self % other, returning None if other == 0.

Examples

use extprim::u128::u128;

assert_eq!(u128::new(100).checked_rem(u128::new(8)), Some(u128::new(4)));
assert_eq!(u128::new(100).checked_rem(u128::zero()), None);

impl u128

pub fn min_value() -> u128

Returns the smallest unsigned 128-bit integer (0).

pub fn max_value() -> u128

Returns the largest unsigned 128-bit integer (340_282_366_920_938_463_463_374_607_431_768_211_455).

pub fn zero() -> u128

Returns the constant 0.

pub fn one() -> u128

Returns the constant 1.

impl u128

pub fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

Examples

use extprim::u128::u128;

let n = u128::from_str_radix("6f32f1ef8b18a2bc3cea59789c79d441", 16).unwrap();
assert_eq!(n.count_ones(), 67);

pub fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self (including leading zeros).

Examples

use extprim::u128::u128;

let n = u128::from_str_radix("6f32f1ef8b18a2bc3cea59789c79d441", 16).unwrap();
assert_eq!(n.count_zeros(), 61);

pub fn leading_zeros(self) -> u32

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

Examples

use extprim::u128::u128;

assert_eq!(u128::zero().leading_zeros(), 128);
assert_eq!(u128::one().leading_zeros(), 127);
assert_eq!(u128::max_value().leading_zeros(), 0);
assert_eq!((u128::one() << 24u32).leading_zeros(), 103);
assert_eq!((u128::one() << 124u32).leading_zeros(), 3);

pub fn trailing_zeros(self) -> u32

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

Examples

use extprim::u128::u128;

assert_eq!(u128::zero().trailing_zeros(), 128);
assert_eq!(u128::one().trailing_zeros(), 0);
assert_eq!((u128::one() << 24u32).trailing_zeros(), 24);
assert_eq!((u128::one() << 124u32).trailing_zeros(), 124);

pub fn rotate_left(self, shift: u32) -> Self

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

Examples

use extprim::u128::u128;

let a = u128::from_str_radix("d0cf4b50cfe20765fff4b4e3f741cf6d", 16).unwrap();
let b = u128::from_str_radix("19e96a19fc40ecbffe969c7ee839edba", 16).unwrap();
assert_eq!(a.rotate_left(5), b);

pub fn rotate_right(self, shift: u32) -> Self

Shifts the bits to the right by a specified amount, shift, wrapping the truncated bits to the beginning of the resulting integer.

Examples

use extprim::u128::u128;

let a = u128::from_str_radix("d0cf4b50cfe20765fff4b4e3f741cf6d", 16).unwrap();
let b = u128::from_str_radix("6e867a5a867f103b2fffa5a71fba0e7b", 16).unwrap();
assert_eq!(a.rotate_right(5), b);

pub fn swap_bytes(self) -> Self

Reverses the byte order of the integer.

Examples

use extprim::u128::u128;

let a = u128::from_str_radix("0123456789abcdef1112223334445556", 16).unwrap();
let b = u128::from_str_radix("5655443433221211efcdab8967452301", 16).unwrap();
assert_eq!(a.swap_bytes(), b);

pub fn from_be(x: Self) -> Self

Converts an integer from big endian to the target's endianness.

On big endian this is a no-op. On little endian the bytes are swapped.

pub fn from_le(x: Self) -> Self

Converts an integer from little endian to the target's endianness.

On little endian this is a no-op. On big endian the bytes are swapped.

pub fn to_be(self) -> Self

Converts self to big endian from the target's endianness.

On big endian this is a no-op. On little endian the bytes are swapped.

pub fn to_le(self) -> Self

Converts self to little endian from the target's endianness.

On little endian this is a no-op. On big endian the bytes are swapped.

pub fn pow(self, exp: u32) -> Self

Raises self to the power of exp, using exponentiation by squaring.

Examples

use extprim::u128::u128;
use std::str::FromStr;

assert_eq!(u128::new(5).pow(30), u128::from_str("931322574615478515625").unwrap());

pub fn is_power_of_two(self) -> bool

Returns true if and only if self == 2**k for some k.

Examples

use extprim::u128::u128;

assert!(!u128::new(0).is_power_of_two());
assert!( u128::new(1).is_power_of_two());
assert!( u128::new(2).is_power_of_two());
assert!(!u128::new(3).is_power_of_two());

pub fn next_power_of_two(self) -> Self

Returns the smallest power of two greater than or equal to self. Unspecified behavior on overflow.

Examples

use extprim::u128::u128;

assert_eq!(u128::zero().next_power_of_two(), u128::new(1));
assert_eq!(u128::one().next_power_of_two(), u128::new(1));
assert_eq!(u128::new(384).next_power_of_two(), u128::new(512));
assert_eq!(u128::new(0x80000000_00000001).next_power_of_two(), u128::from_parts(1, 0));
assert_eq!(u128::from_parts(0x80000000_00000000, 0).next_power_of_two(), u128::from_parts(0x80000000_00000000, 0));

pub fn checked_next_power_of_two(self) -> Option<Self>

Returns the smallest power of two greater than or equal to self. If the next power of two is greater than the type's maximum value, None is returned, otherwise the power of two is wrapped in Some.

Examples

use extprim::u128::u128;

assert_eq!(u128::zero().checked_next_power_of_two(), Some(u128::new(1)));
assert_eq!(u128::one().checked_next_power_of_two(), Some(u128::new(1)));
assert_eq!(u128::new(384).checked_next_power_of_two(), Some(u128::new(512)));
assert_eq!(u128::new(0x80000000_00000001).checked_next_power_of_two(), Some(u128::from_parts(1, 0)));
assert_eq!(u128::from_parts(0x80000000_00000000, 0).checked_next_power_of_two(), Some(u128::from_parts(0x80000000_00000000, 0)));
assert_eq!(u128::from_parts(0x80000000_00000000, 1).checked_next_power_of_two(), None);
assert_eq!(u128::max_value().checked_next_power_of_two(), None);

impl u128

pub fn from_str_radix(src: &str, radix: u32) -> Result<u128, ParseIntError>

Converts a string slice in a given base to an integer.

Leading and trailing whitespace represent an error.

Arguments

• src: A string slice
• radix: The base to use. Must lie in the range [2 ... 36].

Return value

Err(ParseIntError) if the string did not represent a valid number. Otherwise, Ok(n) where n is the integer represented by src.

Trait Implementations

impl Add<u128> for u128

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: u128) -> Self

Performs the + operation.

impl AddAssign<u128> for u128

fn add_assign(&mut self, other: u128)

Performs the += operation.

impl Binary for u128

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl BitAnd<u128> for u128

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Self

Performs the & operation.

impl BitAndAssign<u128> for u128

fn bitand_assign(&mut self, other: u128)

Performs the &= operation.

impl BitOr<u128> for u128

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self

Performs the | operation.

impl BitOrAssign<u128> for u128

fn bitor_assign(&mut self, other: u128)

Performs the |= operation.

impl BitXor<u128> for u128

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> Self

Performs the ^ operation.

impl BitXorAssign<u128> for u128

fn bitxor_assign(&mut self, other: u128)

Performs the ^= operation.

impl Bounded for u128

fn min_value() -> Self

returns the smallest finite number this type can represent

fn max_value() -> Self

returns the largest finite number this type can represent

impl CheckedAdd for u128

fn checked_add(&self, other: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl CheckedDiv for u128

fn checked_div(&self, other: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedMul for u128

fn checked_mul(&self, other: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl CheckedSub for u128

fn checked_sub(&self, other: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl Clone for u128

fn clone(&self) -> u128

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for u128

impl Debug for u128

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for u128

fn default() -> u128

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for u128

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for u128

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Distribution<u128> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl Div<u128> for u128

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self

Performs the / operation.

impl DivAssign<u128> for u128

fn div_assign(&mut self, other: u128)

Performs the /= operation.

impl Eq for u128

impl From<u128> for u128

fn from(arg: u128) -> Self

Performs the conversion.

impl From<u16> for u128

fn from(arg: u16) -> Self

Performs the conversion.

impl From<u32> for u128

fn from(arg: u32) -> Self

Performs the conversion.

impl From<u64> for u128

fn from(arg: u64) -> Self

Performs the conversion.

impl From<u8> for u128

fn from(arg: u8) -> Self

Performs the conversion.

impl FromPrimitive for u128

fn from_u64(n: u64) -> Option<u128>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i64(n: i64) -> Option<u128>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<u128>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl FromStr for u128

type Err = ParseIntError

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Self, ParseIntError>

Parses a string s to return a value of this type.

impl Hash for u128

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl LowerHex for u128

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Mul<u128> for u128

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: u128) -> Self

Performs the * operation.

impl Mul<u128> for u64

type Output = u128

The resulting type after applying the * operator.

fn mul(self, other: u128) -> u128

Performs the * operation.

impl Mul<u64> for u128

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: u64) -> Self

Performs the * operation.

impl MulAssign<u128> for u128

fn mul_assign(&mut self, other: u128)

Performs the *= operation.

impl MulAssign<u64> for u128

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

impl Not for u128

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Num for u128

type FromStrRadixErr = ParseIntError

fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError>

Convert from a string and radix <= 36.

impl NumCast for u128

fn from<T: ToPrimitive>(n: T) -> Option<u128>

Creates a number from another value that can be converted into a primitive via the ToPrimitive trait. If the source value cannot be represented by the target type, then None is returned.

impl Octal for u128

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl One for u128

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool where
    Self: PartialEq<Self>, 

Returns true if self is equal to the multiplicative identity.

impl Ord for u128

fn cmp(&self, other: &u128) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<u128> for u128

fn eq(&self, other: &u128) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &u128) -> bool

This method tests for !=.

impl PartialOrd<u128> for u128

fn partial_cmp(&self, other: &u128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PrimInt for u128

fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

fn leading_zeros(self) -> u32

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

fn trailing_zeros(self) -> u32

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

fn rotate_left(self, shift: u32) -> Self

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

fn rotate_right(self, shift: u32) -> Self

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

fn swap_bytes(self) -> Self

Reverses the byte order of the integer.

fn from_be(x: Self) -> Self

Convert an integer from big endian to the target's endianness.

fn from_le(x: Self) -> Self

Convert an integer from little endian to the target's endianness.

fn to_be(self) -> Self

Convert self to big endian from the target's endianness.

fn to_le(self) -> Self

Convert self to little endian from the target's endianness.

fn pow(self, exp: u32) -> Self

Raises self to the power of exp, using exponentiation by squaring.

fn signed_shl(self, shift: u32) -> Self

Shifts the bits to the left by a specified amount amount, n, filling zeros in the least significant bits.

fn signed_shr(self, shift: u32) -> Self

Shifts the bits to the right by a specified amount amount, n, copying the "sign bit" in the most significant bits even for unsigned types.

fn unsigned_shl(self, shift: u32) -> Self

Shifts the bits to the left by a specified amount amount, n, filling zeros in the least significant bits.

fn unsigned_shr(self, shift: u32) -> Self

Shifts the bits to the right by a specified amount amount, n, filling zeros in the most significant bits.

impl<'a> Product<&'a u128> for u128

fn product<I>(iter: I) -> Self where
    I: Iterator<Item = &'a Self>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl Product<u128> for u128

fn product<I>(iter: I) -> Self where
    I: Iterator<Item = Self>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl Rem<u128> for u128

type Output = Self

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self

Performs the % operation.

impl RemAssign<u128> for u128

fn rem_assign(&mut self, other: u128)

Performs the %= operation.

impl Saturating for u128

fn saturating_add(self, other: Self) -> Self

Saturating addition operator. Returns a+b, saturating at the numeric bounds instead of overflowing.

fn saturating_sub(self, other: Self) -> Self

Saturating subtraction operator. Returns a-b, saturating at the numeric bounds instead of overflowing.

impl Serialize for u128

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Shl<i16> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: i16) -> Self

Performs the << operation.

impl Shl<i32> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: i32) -> Self

Performs the << operation.

impl Shl<i64> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: i64) -> Self

Performs the << operation.

impl Shl<i8> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: i8) -> Self

Performs the << operation.

impl Shl<isize> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: isize) -> Self

Performs the << operation.

impl Shl<u16> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: u16) -> Self

Performs the << operation.

impl Shl<u32> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: u32) -> Self

Performs the << operation.

impl Shl<u64> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: u64) -> Self

Performs the << operation.

impl Shl<u8> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: u8) -> Self

Performs the << operation.

impl Shl<usize> for u128

type Output = Self

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Self

Performs the << operation.

impl ShlAssign<i16> for u128

fn shl_assign(&mut self, other: i16)

Performs the <<= operation.

impl ShlAssign<i32> for u128

fn shl_assign(&mut self, other: i32)

Performs the <<= operation.

impl ShlAssign<i64> for u128

fn shl_assign(&mut self, other: i64)

Performs the <<= operation.

impl ShlAssign<i8> for u128

fn shl_assign(&mut self, other: i8)

Performs the <<= operation.

impl ShlAssign<isize> for u128

fn shl_assign(&mut self, other: isize)

Performs the <<= operation.

impl ShlAssign<u16> for u128

fn shl_assign(&mut self, other: u16)

Performs the <<= operation.

impl ShlAssign<u32> for u128

fn shl_assign(&mut self, other: u32)

Performs the <<= operation.

impl ShlAssign<u64> for u128

fn shl_assign(&mut self, other: u64)

Performs the <<= operation.

impl ShlAssign<u8> for u128

fn shl_assign(&mut self, other: u8)

Performs the <<= operation.

impl ShlAssign<usize> for u128

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl Shr<i16> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: i16) -> Self

Performs the >> operation.

impl Shr<i32> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: i32) -> Self

Performs the >> operation.

impl Shr<i64> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: i64) -> Self

Performs the >> operation.

impl Shr<i8> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: i8) -> Self

Performs the >> operation.

impl Shr<isize> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: isize) -> Self

Performs the >> operation.

impl Shr<u16> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: u16) -> Self

Performs the >> operation.

impl Shr<u32> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: u32) -> Self

Performs the >> operation.

impl Shr<u64> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: u64) -> Self

Performs the >> operation.

impl Shr<u8> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: u8) -> Self

Performs the >> operation.

impl Shr<usize> for u128

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Self

Performs the >> operation.

impl ShrAssign<i16> for u128

fn shr_assign(&mut self, other: i16)

Performs the >>= operation.

impl ShrAssign<i32> for u128

fn shr_assign(&mut self, other: i32)

Performs the >>= operation.

impl ShrAssign<i64> for u128

fn shr_assign(&mut self, other: i64)

Performs the >>= operation.

impl ShrAssign<i8> for u128

fn shr_assign(&mut self, other: i8)

Performs the >>= operation.

impl ShrAssign<isize> for u128

fn shr_assign(&mut self, other: isize)

Performs the >>= operation.

impl ShrAssign<u16> for u128

fn shr_assign(&mut self, other: u16)

Performs the >>= operation.

impl ShrAssign<u32> for u128

fn shr_assign(&mut self, other: u32)

Performs the >>= operation.

impl ShrAssign<u64> for u128

fn shr_assign(&mut self, other: u64)

Performs the >>= operation.

impl ShrAssign<u8> for u128

fn shr_assign(&mut self, other: u8)

Performs the >>= operation.

impl ShrAssign<usize> for u128

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl StructuralEq for u128

impl StructuralPartialEq for u128

impl Sub<u128> for u128

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: u128) -> Self

Performs the - operation.

impl SubAssign<u128> for u128

fn sub_assign(&mut self, other: u128)

Performs the -= operation.

impl<'a> Sum<&'a u128> for u128

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = &'a Self>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl Sum<u128> for u128

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = Self>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl ToExtraPrimitive for u128

fn to_u128(&self) -> Option<u128>

Tries to convert itself into an unsigned 128-bit integer.

fn to_i128(&self) -> Option<i128>

Tries to convert itself into a signed 128-bit integer.

impl ToPrimitive for u128

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. If the value cannot be represented by an f64, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. If the value cannot be represented by an f32, then None is returned.

impl Unsigned for u128

impl UpperHex for u128

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Zero for u128

fn zero() -> Self

Returns the additive identity element of Self, 0. # Purity

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.