Struct u512 

pub struct u512(/* private fields */);

Large integer type

The type is composed of little-endian ordered 64-bit words, which represents its inner representation.

Implementations

impl u512

pub fn as_ptr(&self) -> *const u64

Converts the object to a raw pointer

pub fn as_mut_ptr(&mut self) -> *mut u64

Converts the object to a mutable raw pointer

pub const fn as_inner(&self) -> &[u64; 8]

Returns the underlying array of words constituting large integer

pub const fn into_inner(self) -> [u64; 8]

Returns the underlying array of words constituting large integer

pub const fn from_inner(array: [u64; 8]) -> u512

Constructs integer type from the underlying array of words.

impl u512

pub const ZERO: u512

Zero value

pub const ONE: u512

Value for 1

pub const BITS: u32 = 512u32

Bit dimension

pub const BYTES: u8 = 64u8

Length of the integer in bytes

pub const INNER_LEN: u8 = 8u8

Length of the inner representation in 64-bit words

pub const fn bit(&self, index: usize) -> bool

Returns whether specific bit number is set to 1 or not

pub const fn low_u32(&self) -> u32

Returns lower 32 bits of the number as u32

pub const fn low_u64(&self) -> u64

Returns lower 64 bits of the number as u32

pub fn leading_ones(&self) -> u32

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

pub fn leading_zeros(&self) -> u32

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

pub fn trailing_ones(&self) -> u32

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

pub fn trailing_zeros(&self) -> u32

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

pub fn is_zero(&self) -> bool

pub fn is_positive(&self) -> bool

pub fn abs(self) -> u512

pub fn from_be_bytes(bytes: [u8; 64]) -> u512

Creates the integer value from a byte array using big-endian encoding

pub fn from_be_slice(bytes: &[u8]) -> Result<u512, ParseLengthError>

Creates the integer value from a byte slice using big-endian encoding

pub fn from_le_bytes(bytes: [u8; 64]) -> u512

Creates the integer value from a byte array using little-endian encoding

pub fn from_le_slice(bytes: &[u8]) -> Result<u512, ParseLengthError>

Creates the integer value from a byte slice using little-endian encoding

pub fn to_be_bytes(self) -> [u8; 64]

Convert the integer into a byte array using big-endian encoding

pub fn to_le_bytes(self) -> [u8; 64]

Convert a integer into a byte array using little-endian encoding

impl u512

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

where T: Into<u512>,

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

pub fn saturating_add<T>(self, other: T) -> u512

where T: Into<u512>,

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

pub fn overflowing_add<T>(self, other: T) -> (u512, bool)

where T: Into<u512>,

Calculates self + rhs

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.

pub fn wrapping_add<T>(self, other: T) -> u512

where T: Into<u512>,

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

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

where T: Into<u512>,

Checked integer subtraction. Computes self - rhs, returning None if overflow occurred.

pub fn saturating_sub<T>(self, other: T) -> u512

where T: Into<u512>,

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

pub fn overflowing_sub<T>(self, other: T) -> (u512, bool)

where T: Into<u512>,

Calculates self - rhs

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.

pub fn wrapping_sub<T>(self, other: T) -> u512

where T: Into<u512>,

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

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

where T: Into<u512>,

Checked integer multiplication. Computes self * rhs, returning None if overflow occurred.

pub fn saturating_mul<T>(self, other: T) -> u512

where T: Into<u512>,

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

pub fn wrapping_mul<T>(self, other: T) -> u512

where T: Into<u512>,

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

pub fn overflowing_div<T>(self, other: T) -> (u512, bool)

where T: Into<u512>,

Calculates self / rhs

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

pub fn wrapping_div<T>(self, other: T) -> u512

where T: Into<u512>,

Wrapping (modular) division. Calculates self / rhs, wrapping around at the boundary of the type.

The only case where such wrapping can occur is when one divides MIN / -1 on a signed type (where MIN is the negative minimal value for the type); this is equivalent to -MIN, a positive value that is too large to represent in the type. In such a case, this function returns MIN itself.

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

where T: Into<u512>,

Checked integer division. Computes self / rhs, returning None if rhs == 0 or the division results in overflow.

pub fn saturating_div<T>(self, other: T) -> u512

where T: Into<u512>,

Saturating integer division. Computes self / rhs, saturating at the numeric bounds instead of overflowing.

pub fn overflowing_rem<T>(self, other: T) -> (u512, bool)

where T: Into<u512>,

Calculates the remainder when self is divided by rhs.

Returns a tuple of the remainder after dividing along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would occur then 0 is returned.

pub fn wrapping_rem<T>(self, other: T) -> u512

where T: Into<u512>,

Wrapping (modular) remainder. Computes self % rhs, wrapping around at the boundary of the type.

Such wrap-around never actually occurs mathematically; implementation artifacts make x % y invalid for MIN / -1 on a signed type (where MIN is the negative minimal value). In such a case, this function returns 0.

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

where T: Into<u512>,

Checked integer remainder. Computes self % rhs, returning None if rhs == 0 or the division results in overflow.

pub fn div_euclid<T>(self, other: T) -> u512

where T: Into<u512>,

Calculates the quotient of Euclidean division of self by rhs.

This computes the integer q such that self = q * rhs + r, with r = self.rem_euclid(rhs) and 0 <= r < abs(rhs).

In other words, the result is self / rhs rounded to the integer q such that self >= q * rhs. If self > 0, this is equal to round towards zero (the default in Rust); if self < 0, this is equal to round towards +/- infinity.

pub fn overflowing_div_euclid<T>(self, other: T) -> (u512, bool)

where T: Into<u512>,

Calculates the quotient of Euclidean division self.div_euclid(rhs).

Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would occur then self is returned.

pub fn wrapping_div_euclid<T>(self, other: T) -> u512

where T: Into<u512>,

Wrapping Euclidean division. Computes self.div_euclid(rhs), wrapping around at the boundary of the type.

Wrapping will only occur in MIN / -1 on a signed type (where MIN is the negative minimal value for the type). This is equivalent to -MIN, a positive value that is too large to represent in the type. In this case, this method returns MIN itself.

pub fn checked_div_euclid<T>(self, other: T) -> Option<u512>

where T: Into<u512>,

Checked Euclidean division. Computes self.div_euclid(rhs), returning None if rhs == 0 or the division results in overflow.

pub fn rem_euclid<T>(self, other: T) -> u512

where T: Into<u512>,

Calculates the least nonnegative remainder of self (mod rhs).

This is done as if by the Euclidean division algorithm – given r = self.rem_euclid(rhs), self = rhs * self.div_euclid(rhs) + r, and 0 <= r < abs(rhs).

pub fn overflowing_rem_euclid<T>(self, other: T) -> (u512, bool)

where T: Into<u512>,

Overflowing Euclidean remainder. Calculates self.rem_euclid(rhs).

Returns a tuple of the remainder after dividing along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would occur then 0 is returned.

pub fn wrapping_rem_euclid<T>(self, other: T) -> u512

where T: Into<u512>,

Wrapping Euclidean remainder. Computes self.rem_euclid(rhs), wrapping around at the boundary of the type.

Wrapping will only occur in MIN % -1 on a signed type (where MIN is the negative minimal value for the type). In this case, this method returns 0.

pub fn checked_rem_euclid<T>(self, other: T) -> Option<u512>

where T: Into<u512>,

Checked Euclidean remainder. Computes self.rem_euclid(rhs), returning None if rhs == 0 or the division results in overflow.

pub fn checked_shl(self, rhs: u32) -> Option<u512>

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

pub fn checked_shr(self, rhs: u32) -> Option<u512>

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

pub fn wrapping_neg(self) -> u512

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) where MAX is the corresponding signed type’s maximum.

impl u512

pub const MIN: u512

Minimum value

pub const MAX: u512

Maximum value

pub const fn is_negative(&self) -> bool

pub fn bits_required(&self) -> usize

Return the least number of bits needed to represent the number

pub fn overflowing_mul<T>(self, other: T) -> (u512, bool)

where T: Into<u512>,

Calculates self * rhs

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.

Trait Implementations

impl<T> Add<T> for u512

where T: Into<u512>,

type Output = u512

The resulting type after applying the + operator.

fn add(self, other: T) -> u512

Performs the + operation.

impl<T> AddAssign<T> for u512

where T: Into<u512>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T> BitAnd<T> for u512

where T: Into<u512>,

type Output = u512

The resulting type after applying the & operator.

fn bitand(self, other: T) -> u512

Performs the & operation.

impl<T> BitAndAssign<T> for u512

where T: Into<u512>,

fn bitand_assign(&mut self, rhs: T)

Performs the &= operation.

impl<T> BitOr<T> for u512

where T: Into<u512>,

type Output = u512

The resulting type after applying the | operator.

fn bitor(self, other: T) -> u512

Performs the | operation.

impl<T> BitOrAssign<T> for u512

where T: Into<u512>,

fn bitor_assign(&mut self, rhs: T)

Performs the |= operation.

impl<T> BitXor<T> for u512

where T: Into<u512>,

type Output = u512

The resulting type after applying the ^ operator.

fn bitxor(self, other: T) -> u512

Performs the ^ operation.

impl<T> BitXorAssign<T> for u512

where T: Into<u512>,

fn bitxor_assign(&mut self, rhs: T)

Performs the ^= operation.

impl Clone for u512

fn clone(&self) -> u512

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for u512

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for u512

fn default() -> u512

Returns the “default value” for a type.

impl Display for u512

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Div<T> for u512

where T: Into<u512>,

type Output = u512

The resulting type after applying the / operator.

fn div(self, other: T) -> u512

Performs the / operation.

impl<T> DivAssign<T> for u512

where T: Into<u512>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl From<bool> for u512

fn from(init: bool) -> u512

Converts to this type from the input type.

impl From<u128> for u512

fn from(init: u128) -> u512

Converts to this type from the input type.

impl From<u16> for u512

fn from(init: u16) -> u512

Converts to this type from the input type.

impl From<u256> for u512

fn from(init: u256) -> u512

Converts to this type from the input type.

impl From<u32> for u512

fn from(init: u32) -> u512

Converts to this type from the input type.

impl From<u512> for u1024

fn from(init: u512) -> u1024

Converts to this type from the input type.

impl From<u64> for u512

fn from(init: u64) -> u512

Converts to this type from the input type.

impl From<u8> for u512

fn from(init: u8) -> u512

Converts to this type from the input type.

impl Hash for u512

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

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<Range<usize>> for u512

type Output = [u64]

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &[u64]

Performs the indexing (container[index]) operation.

impl Index<RangeFrom<usize>> for u512

type Output = [u64]

The returned type after indexing.

fn index(&self, index: RangeFrom<usize>) -> &[u64]

Performs the indexing (container[index]) operation.

impl Index<RangeFull> for u512

type Output = [u64]

The returned type after indexing.

fn index(&self, _: RangeFull) -> &[u64]

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for u512

type Output = [u64]

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &[u64]

Performs the indexing (container[index]) operation.

impl Index<usize> for u512

type Output = u64

The returned type after indexing.

fn index(&self, index: usize) -> &u64

Performs the indexing (container[index]) operation.

impl<T> Mul<T> for u512

where T: Into<u512>,

type Output = u512

The resulting type after applying the * operator.

fn mul(self, other: T) -> u512

Performs the * operation.

impl<T> MulAssign<T> for u512

where T: Into<u512>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl Neg for u512

type Output = u512

The resulting type after applying the - operator.

fn neg(self) -> <u512 as Neg>::Output

Performs the unary - operation.

impl Not for u512

type Output = u512

The resulting type after applying the ! operator.

fn not(self) -> u512

Performs the unary ! operation.

impl Ord for u512

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for u512

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for u512

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

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<T> Rem<T> for u512

where T: Into<u512>,

type Output = u512

The resulting type after applying the % operator.

fn rem(self, other: T) -> u512

Performs the % operation.

impl<T> RemAssign<T> for u512

where T: Into<u512>,

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl Shl<usize> for u512

type Output = u512

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> u512

Performs the << operation.

impl ShlAssign<usize> for u512

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl Shr<usize> for u512

type Output = u512

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> u512

Performs the >> operation.

impl ShrAssign<usize> for u512

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<T> Sub<T> for u512

where T: Into<u512>,

type Output = u512

The resulting type after applying the - operator.

fn sub(self, other: T) -> u512

Performs the - operation.

impl<T> SubAssign<T> for u512

where T: Into<u512>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<'a> TryFrom<&'a [u64]> for u512

type Error = ParseLengthError

The type returned in the event of a conversion error.

fn try_from( data: &'a [u64], ) -> Result<u512, <u512 as TryFrom<&'a [u64]>>::Error>

Performs the conversion.

impl Copy for u512

impl Eq for u512

impl StructuralPartialEq for u512

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 64 bytes