Struct i256 

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

Large integer type

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

Implementations

impl i256

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; 4]

Returns the underlying array of words constituting large integer

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

Returns the underlying array of words constituting large integer

pub const fn from_inner(array: [u64; 4]) -> i256

Constructs integer type from the underlying array of words.

impl i256

pub const ZERO: i256

Zero value

pub const ONE: i256

Value for 1

pub const BITS: u32 = 256u32

Bit dimension

pub const BYTES: u8 = 32u8

Length of the integer in bytes

pub const INNER_LEN: u8 = 4u8

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) -> i256

pub fn from_be_bytes(bytes: [u8; 32]) -> i256

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

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

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

pub fn from_le_bytes(bytes: [u8; 32]) -> i256

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

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

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

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

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

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

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

impl i256

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

where T: Into<i256>,

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

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

where T: Into<i256>,

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

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

where T: Into<i256>,

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) -> i256

where T: Into<i256>,

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

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

where T: Into<i256>,

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

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

where T: Into<i256>,

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

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

where T: Into<i256>,

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) -> i256

where T: Into<i256>,

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

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

where T: Into<i256>,

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

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

where T: Into<i256>,

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

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

where T: Into<i256>,

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

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

where T: Into<i256>,

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) -> i256

where T: Into<i256>,

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<i256>

where T: Into<i256>,

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) -> i256

where T: Into<i256>,

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

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

where T: Into<i256>,

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) -> i256

where T: Into<i256>,

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<i256>

where T: Into<i256>,

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) -> i256

where T: Into<i256>,

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) -> (i256, bool)

where T: Into<i256>,

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) -> i256

where T: Into<i256>,

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<i256>

where T: Into<i256>,

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) -> i256

where T: Into<i256>,

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) -> (i256, bool)

where T: Into<i256>,

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) -> i256

where T: Into<i256>,

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<i256>

where T: Into<i256>,

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<i256>

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<i256>

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) -> i256

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 i256

pub const MIN: i256

Minimum value

pub const MAX: i256

Maximum value

pub 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) -> (i256, bool)

where T: Into<i256>,

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 i256

where T: Into<i256>,

type Output = i256

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AddAssign<T> for i256

where T: Into<i256>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T> BitAnd<T> for i256

where T: Into<i256>,

type Output = i256

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T> BitAndAssign<T> for i256

where T: Into<i256>,

fn bitand_assign(&mut self, rhs: T)

Performs the &= operation.

impl<T> BitOr<T> for i256

where T: Into<i256>,

type Output = i256

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T> BitOrAssign<T> for i256

where T: Into<i256>,

fn bitor_assign(&mut self, rhs: T)

Performs the |= operation.

impl<T> BitXor<T> for i256

where T: Into<i256>,

type Output = i256

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T> BitXorAssign<T> for i256

where T: Into<i256>,

fn bitxor_assign(&mut self, rhs: T)

Performs the ^= operation.

impl Clone for i256

fn clone(&self) -> i256

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for i256

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

Formats the value using the given formatter.

impl Default for i256

fn default() -> i256

Returns the “default value” for a type.

impl Display for i256

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

Formats the value using the given formatter.

impl<T> Div<T> for i256

where T: Into<i256>,

type Output = i256

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> DivAssign<T> for i256

where T: Into<i256>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl From<bool> for i256

fn from(init: bool) -> i256

Converts to this type from the input type.

impl From<i128> for i256

fn from(init: i128) -> i256

Converts to this type from the input type.

impl From<i16> for i256

fn from(init: i16) -> i256

Converts to this type from the input type.

impl From<i32> for i256

fn from(init: i32) -> i256

Converts to this type from the input type.

impl From<i64> for i256

fn from(init: i64) -> i256

Converts to this type from the input type.

impl From<i8> for i256

fn from(init: i8) -> i256

Converts to this type from the input type.

impl From<u128> for i256

fn from(init: u128) -> i256

Converts to this type from the input type.

impl From<u16> for i256

fn from(init: u16) -> i256

Converts to this type from the input type.

impl From<u32> for i256

fn from(init: u32) -> i256

Converts to this type from the input type.

impl From<u64> for i256

fn from(init: u64) -> i256

Converts to this type from the input type.

impl From<u8> for i256

fn from(init: u8) -> i256

Converts to this type from the input type.

impl Hash for i256

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 i256

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 i256

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 i256

type Output = [u64]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for i256

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 i256

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 i256

where T: Into<i256>,

type Output = i256

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign<T> for i256

where T: Into<i256>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl Neg for i256

type Output = i256

The resulting type after applying the - operator.

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

Performs the unary - operation.

impl Not for i256

type Output = i256

The resulting type after applying the ! operator.

fn not(self) -> i256

Performs the unary ! operation.

impl Ord for i256

fn cmp(&self, other: &i256) -> 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 i256

fn eq(&self, other: &i256) -> 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 i256

fn partial_cmp(&self, other: &i256) -> 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 i256

where T: Into<i256>,

type Output = i256

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T> RemAssign<T> for i256

where T: Into<i256>,

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl Shl<usize> for i256

type Output = i256

The resulting type after applying the << operator.

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

Performs the << operation.

impl ShlAssign<usize> for i256

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl Shr<usize> for i256

type Output = i256

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl ShrAssign<usize> for i256

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<T> Sub<T> for i256

where T: Into<i256>,

type Output = i256

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> SubAssign<T> for i256

where T: Into<i256>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

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

type Error = ParseLengthError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for i256

impl Eq for i256

impl StructuralPartialEq for i256

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: 32 bytes