Struct extprim::u128::u128
[−]
[src]
pub struct u128 { // some fields omitted }
An unsigned 128-bit number.
Methods
impl u128
fn new(lo: u64) -> u128
Constructs a new 128-bit integer from a 64-bit integer.
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");
fn low64(self) -> u64
Fetch 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);
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);
fn as_i128(self) -> i128
Convert 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);
impl u128
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());
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());
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));
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));
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());
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());
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
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
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
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));
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));
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));
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
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
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
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));
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));
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());
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));
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));
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
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
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
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));
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));
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));
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));
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);
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
fn min_value() -> u128
Returns the smallest unsigned 128-bit integer (0).
fn max_value() -> u128
Returns the largest unsigned 128-bit integer
(340_282_366_920_938_463_463_374_607_431_768_211_455
).
fn zero() -> u128
Returns the constant 0.
fn one() -> u128
Returns the constant 1.
impl u128
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);
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);
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);
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);
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);
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);
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);
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.
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.
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.
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.
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());
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());
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));
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
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
.