Struct amplify_num::i256

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source §

impl i256

source

pub const MIN: i256 = _

Minimum value

source

pub const MAX: i256 = _

Maximum value

source

pub fn is_negative(&self) -> bool

source

pub fn bits_required(&self) -> usize

Return the least number of bits needed to represent the number

source

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.