Struct I256 

pub struct I256 { /* private fields */ }

A 256-bit signed integer.

Limbs are the two’s complement representation, least-significant-first, so the layout and the wire encoding match U256 exactly. See the module documentation for the semantics.

Implementations

impl I256

pub const ZERO: I256

The additive identity.

pub const ONE: I256

The multiplicative identity.

pub const MINUS_ONE: I256

Negative one, whose two’s complement is all ones.

pub const MAX: I256

The largest representable value, 2^255 - 1.

pub const MIN: I256

The smallest representable value, -2^255.

Its magnitude is one larger than MAX’s, which is why negating, absolute value and division by -1 can all overflow.

pub const BITS: u32 = 256

The size of this integer in bits, sign bit included.

pub const fn from_limbs(limbs: [u32; 8]) -> I256

Constructs a value from its two’s complement limbs, least-significant-first.

pub const fn to_limbs(self) -> [u32; 8]

Returns the two’s complement limbs, least-significant-first.

pub const fn from(n: i128) -> I256

Constructs a value from an i128.

Inherent for the reason U256::from is: From is implemented for every signed width, which would leave I256::from(-1000) ambiguous, and an inherent function shadows the trait in path form and pins the literal to i128. It is also usable in const position.

The trait impls are untouched, so .into() and generic T: Into<I256> still convert from any width – including the unsigned ones, which all fit.

pub const fn from_i128(n: i128) -> I256

Constructs a value from an i128, under a name no trait shadows.

pub const fn from_i32(n: i32) -> I256

Constructs a value from an i32, without widening at the call site.

pub const fn from_i64(n: i64) -> I256

Constructs a value from an i64, without widening at the call site.

pub const fn cast_unsigned(self) -> U256

Reinterprets the two’s complement bits as a U256.

No arithmetic: (-1).cast_unsigned() is U256::MAX. Named after i128::cast_unsigned, which does the same thing at a narrower width.

pub const fn is_zero(self) -> bool

Returns true if this is zero.

pub const fn is_negative(self) -> bool

Returns true if this is strictly less than zero.

pub const fn is_positive(self) -> bool

Returns true if this is strictly greater than zero.

pub const fn signum(self) -> I256

-1, 0 or 1, according to the sign.

pub const fn unsigned_abs(self) -> U256

The absolute value, as a U256.

Total, unlike abs: MIN.unsigned_abs() is 2^255, which a U256 holds comfortably. SignedMath.abs.

pub const fn bit(self, i: u32) -> bool

Returns the bit at i, counting from the least significant. Bit 255 is the sign bit.

Bits at or above BITS read as zero rather than panicking, matching U256::bit – note that this is not a sign extension.

pub const fn const_cmp(self, other: I256) -> Ordering

Comparison usable from a const fn.

Flipping the sign bit maps the signed order onto the unsigned one, so this is U256::const_cmp on the flipped values.

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

Returns the big-endian two’s complement byte representation.

#[inline], not the inline(never) the unsigned pair carries: the body is a reinterpretation and a call, so the byte-swap loop this reaches is U256::to_be_bytes, which is already outlined on rv32 for exactly that reason. Outlining the wrapper too would add a second symbol and a call/return per conversion, not remove one.

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

Constructs a value from its big-endian two’s complement byte representation.

#[inline] for the reason to_be_bytes gives.

impl I256

pub const fn overflowing_neg(self) -> (I256, bool)

Negation, with a flag reporting whether it overflowed.

Only MIN overflows: its magnitude has no positive counterpart, and it negates to itself.

pub const fn checked_neg(self) -> Option<I256>

Negation, returning None on overflow.

pub const fn wrapping_neg(self) -> I256

Negation, wrapping on overflow (MIN negates to itself).

pub const fn saturating_neg(self) -> I256

Negation, saturating at MAX.

pub const fn overflowing_abs(self) -> (I256, bool)

Absolute value, with a flag reporting whether it overflowed.

pub const fn checked_abs(self) -> Option<I256>

Absolute value, returning None on overflow.

pub const fn wrapping_abs(self) -> I256

Absolute value, wrapping on overflow (MIN maps to itself).

pub const fn saturating_abs(self) -> I256

Absolute value, saturating at MAX.

pub const fn abs(self) -> I256

Absolute value.

See unsigned_abs for the total version: MIN has no representable absolute value here.

Panics

On MIN, if overflow-checks is on – otherwise it wraps to MIN, like the primitives.

pub const fn overflowing_add(self, rhs: I256) -> (I256, bool)

Wrapping addition, with a flag reporting whether it overflowed.

pub const fn overflowing_sub(self, rhs: I256) -> (I256, bool)

Wrapping subtraction, with a flag reporting whether it overflowed.

pub const fn checked_add(self, rhs: I256) -> Option<I256>

Addition, returning None on overflow.

pub const fn checked_sub(self, rhs: I256) -> Option<I256>

Subtraction, returning None on overflow.

pub const fn wrapping_add(self, rhs: I256) -> I256

Addition, wrapping on overflow.

pub const fn wrapping_sub(self, rhs: I256) -> I256

Subtraction, wrapping on overflow.

pub const fn saturating_add(self, rhs: I256) -> I256

Addition, saturating at MIN or MAX.

pub const fn saturating_sub(self, rhs: I256) -> I256

Subtraction, saturating at MIN or MAX.

pub const fn overflowing_mul(self, rhs: I256) -> (I256, bool)

Wrapping multiplication, with a flag reporting whether it overflowed.

One 256x256 multiply, not two. The overflow test needs the magnitude product, and the wrapped signed bits follow from it without a second pass: a * b = (-1)^(sign a ^ sign b) * |a| * |b|, and that identity survives reduction mod 2^256, so negating the magnitude product gives exactly the bits cast_unsigned().wrapping_mul() would have.

Which callers this helps is worth being precise about. It is every form that consumes the overflow flag – checked_mul, saturating_mul, this function, and each step of pow. The bare * operator is not among them: in a release contract profile OVERFLOW_CHECKS folds to false, the flag goes unread, and LLVM was already dropping the second multiply as dead.

Measured on rv32 by scripts/bigint-bench.sh -o "mul signed_mul": a saturating signed multiply costs 1095.02 gas against 1019.02 for a bare wrapping unsigned one – +76 gas for the sign handling and the bound check, where a second full schoolbook pass would have been on the order of +1,000.

pub const fn checked_mul(self, rhs: I256) -> Option<I256>

Multiplication, returning None on overflow.

pub const fn wrapping_mul(self, rhs: I256) -> I256

Multiplication, wrapping on overflow.

pub const fn saturating_mul(self, rhs: I256) -> I256

Multiplication, saturating at MIN or MAX.

pub const fn checked_div_rem(self, rhs: I256) -> Option<(I256, I256)>

Divides, returning the quotient and remainder, or None if rhs is zero or the division overflows.

The quotient truncates toward zero and the remainder takes the sign of the dividend, matching Rust’s primitives and Solidity’s int256. MIN / -1 is the one overflow: its quotient is 2^255.

pub const fn div_rem(self, rhs: I256) -> (I256, I256)

Divides, returning the quotient and remainder.

Panics

If rhs is zero, or on MIN / -1. Both panics are unconditional, and deliberately so: division overflow is the one arithmetic overflow the primitives do not key off overflow-checks. i128::MIN / -1 panics under -C overflow-checks=off exactly as it does with checks on, because the alternative on real hardware is a trap rather than a wrapped value. Matching the primitives here means not gating this.

The consequence is worth stating plainly, since it is the opposite of what the rest of this type does: a contract profile silently wraps MIN + 1 and MIN * 2, but aborts on MIN / -1. Reach for wrapping_div or checked_div if an abort is not what the call site wants.

pub const fn overflowing_div(self, rhs: I256) -> (I256, bool)

Division, with a flag reporting whether it overflowed.

The flag is set only by MIN / -1, whose wrapped quotient is MIN.

Panics

If rhs is zero.

pub const fn overflowing_rem(self, rhs: I256) -> (I256, bool)

Remainder, with a flag reporting whether it overflowed.

The flag is set only by MIN % -1, whose wrapped remainder is zero.

Panics

If rhs is zero.

pub const fn checked_div(self, rhs: I256) -> Option<I256>

Division, returning None if rhs is zero or the division overflows.

pub const fn checked_rem(self, rhs: I256) -> Option<I256>

Remainder, returning None if rhs is zero or the division overflows.

pub const fn wrapping_div(self, rhs: I256) -> I256

Division, wrapping on overflow (MIN / -1 is MIN).

Panics

If rhs is zero.

pub const fn wrapping_rem(self, rhs: I256) -> I256

Remainder, wrapping on overflow (MIN % -1 is zero).

Panics

If rhs is zero.

pub const fn div_euclid(self, rhs: I256) -> I256

Euclidean division: the quotient whose remainder is never negative.

(-7).div_euclid(2) is -4, where (-7) / 2 is -3.

Panics

As div_rem.

pub const fn rem_euclid(self, rhs: I256) -> I256

The non-negative remainder of Euclidean division.

Panics

As div_rem.

pub const fn wrapping_shl(self, n: u32) -> I256

Left shift, masking the shift amount to 0..256.

Bit-identical to the unsigned shift: bits that fall off the top, including the sign bit, are simply gone.

pub const fn wrapping_shr(self, n: u32) -> I256

Arithmetic right shift, masking the shift amount to 0..256.

The sign bit is replicated into the vacated positions, so this rounds toward negative infinity: (-1) >> 1 is -1, not MAX.

pub const fn overflowing_shl(self, n: u32) -> (I256, bool)

Left shift, masking the shift amount and reporting whether the mask changed it.

pub const fn overflowing_shr(self, n: u32) -> (I256, bool)

Arithmetic right shift, masking the shift amount and reporting whether the mask changed it.

pub const fn checked_shl(self, n: u32) -> Option<I256>

Left shift, returning None if the shift amount is at least 256.

pub const fn checked_shr(self, n: u32) -> Option<I256>

Arithmetic right shift, returning None if the shift amount is at least 256.

pub const fn const_bitand(self, rhs: I256) -> I256

Bitwise AND, usable from a const fn.

pub const fn const_bitor(self, rhs: I256) -> I256

Bitwise OR, usable from a const fn.

pub const fn const_bitxor(self, rhs: I256) -> I256

Bitwise XOR, usable from a const fn.

pub const fn const_not(self) -> I256

Bitwise NOT, usable from a const fn. !x is -x - 1.

pub const fn overflowing_pow(self, exp: u32) -> (I256, bool)

Exponentiation, with a flag reporting whether it overflowed.

x.pow(0) is one for every x, matching the primitives.

pub const fn checked_pow(self, exp: u32) -> Option<I256>

Exponentiation, returning None on overflow.

pub const fn wrapping_pow(self, exp: u32) -> I256

Exponentiation, wrapping on overflow.

pub const fn saturating_pow(self, exp: u32) -> I256

Exponentiation, saturating at MIN or MAX.

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

Exponentiation.

Panics

On overflow, if overflow-checks is on – otherwise it wraps.

impl I256

pub const fn min(self, other: I256) -> I256

The smaller of two values. SignedMath.min.

Shadows Ord::min in method position, which resolves to the same answer; this one is a const fn.

pub const fn max(self, other: I256) -> I256

The larger of two values. SignedMath.max.

Shadows Ord::max in method position, which resolves to the same answer; this one is a const fn.

pub const fn clamp(self, min: I256, max: I256) -> I256

Clamps to the inclusive range min..=max.

Panics

If min > max, matching Ord::clamp.

pub const fn average(self, other: I256) -> I256

The average of two values, rounded toward zero, without an intermediate that overflows. SignedMath.average.

(a & b) + ((a ^ b) >> 1) is the floor average – the shift is arithmetic, so it rounds toward negative infinity – and the correction below pulls a negative, inexact result back up by one. Note that this differs from U256::average only in that correction, because for a value that cannot be negative the two directions coincide.

pub const fn checked_mul_div(x: I256, y: I256, d: I256) -> Option<I256>

x * y / d computed on the exact 512-bit product, truncating toward zero. Returns None if d is zero or the quotient is out of range.

The signed counterpart of U256::mul_div; see the module docs for why it is a composition rather than a port.

pub const fn mul_div(x: I256, y: I256, d: I256) -> I256

x * y / d computed on the exact 512-bit product, truncating toward zero.

Panics

If d is zero, or if the quotient is out of range. Both panics are unconditional, as on the unsigned side.

pub const fn checked_mul_div_rounding( x: I256, y: I256, d: I256, rounding: Rounding, ) -> Option<I256>

x * y / d computed on the exact 512-bit product, following rounding. Returns None if d is zero or the result is out of range.

pub const fn mul_div_rounding( x: I256, y: I256, d: I256, rounding: Rounding, ) -> I256

x * y / d computed on the exact 512-bit product, following rounding.

Panics

As mul_div.

Trait Implementations

impl Add for I256

type Output = I256

The resulting type after applying the + operator.

fn add(self, rhs: I256) -> I256

Performs the + operation.

impl AddAssign for I256

fn add_assign(&mut self, rhs: I256)

Performs the += operation.

impl BitAnd for I256

type Output = I256

The resulting type after applying the & operator.

fn bitand(self, rhs: I256) -> I256

Performs the & operation.

impl BitAndAssign for I256

fn bitand_assign(&mut self, rhs: I256)

Performs the &= operation.

impl BitOr for I256

type Output = I256

The resulting type after applying the | operator.

fn bitor(self, rhs: I256) -> I256

Performs the | operation.

impl BitOrAssign for I256

fn bitor_assign(&mut self, rhs: I256)

Performs the |= operation.

impl BitXor for I256

type Output = I256

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: I256) -> I256

Performs the ^ operation.

impl BitXorAssign for I256

fn bitxor_assign(&mut self, rhs: I256)

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 CollectAuthHandles for I256

fn collect_auth_handles( &self, _out: &mut AuthHandleBuf, ) -> Result<(), FaultString>

impl ContractTypeRefSpec for I256

const INFO: ContractTypeInfo<'static>

The type reference. Transitive type definitions are not carried here; they are retained via the linker-anchor mechanism (__THRUPUT_SPEC_ANCHOR_ROOT) and resolved by spec-tool.

const SIGNED_PREIMAGE: Option<&'static ContractTypeView<'static>> = _

How this type appears as a signed-token preimage (ContractTypeView::SignedToken’s payload): the type itself by default, or None for a type-erased payload (the SDK’s Opaque overrides this).

impl Copy for I256

impl Debug for I256

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

Renders as sign-magnitude 0x-prefixed hex.

Like U256’s Debug, this does not honour width or fill flags; use {:x} when the exact textual shape matters.

impl Default for I256

fn default() -> I256

Returns the “default value” for a type.

impl Display for I256

Available on crate feature fmt only.

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

Formats the value using the given formatter.

impl Div for I256

fn div(self, rhs: I256) -> I256

Truncating division. Panics on a zero divisor regardless of overflow-checks, matching the primitive integers.

type Output = I256

The resulting type after applying the / operator.

impl DivAssign for I256

fn div_assign(&mut self, rhs: I256)

Performs the /= operation.

impl Eq for I256

impl From<bool> for I256

fn from(b: bool) -> I256

Converts to this type from the input type.

impl From<i8> for I256

fn from(n: i8) -> I256

Converts to this type from the input type.

impl From<i16> for I256

fn from(n: i16) -> I256

Converts to this type from the input type.

impl From<i32> for I256

fn from(n: i32) -> I256

Converts to this type from the input type.

impl From<i64> for I256

fn from(n: i64) -> I256

Converts to this type from the input type.

impl From<i128> for I256

fn from(n: i128) -> I256

Converts to this type from the input type.

impl From<u8> for I256

fn from(n: u8) -> I256

Converts to this type from the input type.

impl From<u16> for I256

fn from(n: u16) -> I256

Converts to this type from the input type.

impl From<u32> for I256

fn from(n: u32) -> I256

Converts to this type from the input type.

impl From<u64> for I256

fn from(n: u64) -> I256

Converts to this type from the input type.

impl From<u128> for I256

fn from(n: u128) -> I256

Converts to this type from the input type.

impl FromStr for I256

Available on crate feature fmt only.

type Err = ParseI256Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<I256, <I256 as FromStr>::Err>

Parses a string s to return a value of this 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 IntoTopic for I256

fn into_topic(&self) -> TopicSrc<'_>

impl LowerHex for I256

Available on crate feature fmt only.

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

The two’s complement bits, as the primitives do it: -1 is all fs, not -1.

impl Mintable for I256

fn mint_into_parent(preimage: I256, _children: &mut ChildNodeBuf) -> Self

impl MintableType for I256

type Preimage = I256

impl Mul for I256

type Output = I256

The resulting type after applying the * operator.

fn mul(self, rhs: I256) -> I256

Performs the * operation.

impl MulAssign for I256

fn mul_assign(&mut self, rhs: I256)

Performs the *= operation.

impl Neg for I256

type Output = I256

The resulting type after applying the - operator.

fn neg(self) -> I256

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 using logical or bitwise negation.

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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl PartialEq for I256

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

Equality operator ==.

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

Inequality operator !=.

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<'r> ReadXDR<'r> for I256

fn read_xdr<R>(r: &mut R) -> Result<I256, ReadError>

where R: Reader<'r>,

Reads an XDR value from the reader.

fn read_xdr_in_place<'s, R>( r: &mut R, slot: Slot<'s, Self>, ) -> Result<Init<'s, Self>, ReadError>

where R: Reader<'r>,

Reads an XDR value directly into slot, without first building it on the stack.

impl ReceiveAuthHandles for I256

fn receive_auth_handles( &mut self, _handles: &mut impl Iterator<Item = u32>, ) -> Result<(), AuthTokenError>

impl Rem for I256

fn rem(self, rhs: I256) -> I256

Remainder, taking the sign of the dividend. Panics on a zero divisor regardless of overflow-checks, matching the primitive integers.

type Output = I256

The resulting type after applying the % operator.

impl RemAssign for I256

fn rem_assign(&mut self, rhs: I256)

Performs the %= operation.

impl Shl<i8> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> I256

Performs the << operation.

impl Shl<i16> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> I256

Performs the << operation.

impl Shl<i32> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> I256

Performs the << operation.

impl Shl<i64> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> I256

Performs the << operation.

impl Shl<i128> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: i128) -> I256

Performs the << operation.

impl Shl<isize> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> I256

Performs the << operation.

impl Shl<u8> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> I256

Performs the << operation.

impl Shl<u16> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> I256

Performs the << operation.

impl Shl<u32> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> I256

Performs the << operation.

impl Shl<u64> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> I256

Performs the << operation.

impl Shl<u128> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: u128) -> I256

Performs the << operation.

impl Shl<usize> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> I256

Performs the << operation.

impl ShlAssign<i8> for I256

fn shl_assign(&mut self, rhs: i8)

Performs the <<= operation.

impl ShlAssign<i16> for I256

fn shl_assign(&mut self, rhs: i16)

Performs the <<= operation.

impl ShlAssign<i32> for I256

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl ShlAssign<i64> for I256

fn shl_assign(&mut self, rhs: i64)

Performs the <<= operation.

impl ShlAssign<i128> for I256

fn shl_assign(&mut self, rhs: i128)

Performs the <<= operation.

impl ShlAssign<isize> for I256

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl ShlAssign<u8> for I256

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl ShlAssign<u16> for I256

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation.

impl ShlAssign<u32> for I256

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl ShlAssign<u64> for I256

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation.

impl ShlAssign<u128> for I256

fn shl_assign(&mut self, rhs: u128)

Performs the <<= operation.

impl ShlAssign<usize> for I256

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl Shr<i8> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> I256

Performs the >> operation.

impl Shr<i16> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> I256

Performs the >> operation.

impl Shr<i32> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> I256

Performs the >> operation.

impl Shr<i64> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> I256

Performs the >> operation.

impl Shr<i128> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: i128) -> I256

Performs the >> operation.

impl Shr<isize> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> I256

Performs the >> operation.

impl Shr<u8> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> I256

Performs the >> operation.

impl Shr<u16> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> I256

Performs the >> operation.

impl Shr<u32> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> I256

Performs the >> operation.

impl Shr<u64> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> I256

Performs the >> operation.

impl Shr<u128> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: u128) -> I256

Performs the >> operation.

impl Shr<usize> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> I256

Performs the >> operation.

impl ShrAssign<i8> for I256

fn shr_assign(&mut self, rhs: i8)

Performs the >>= operation.

impl ShrAssign<i16> for I256

fn shr_assign(&mut self, rhs: i16)

Performs the >>= operation.

impl ShrAssign<i32> for I256

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl ShrAssign<i64> for I256

fn shr_assign(&mut self, rhs: i64)

Performs the >>= operation.

impl ShrAssign<i128> for I256

fn shr_assign(&mut self, rhs: i128)

Performs the >>= operation.

impl ShrAssign<isize> for I256

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl ShrAssign<u8> for I256

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl ShrAssign<u16> for I256

fn shr_assign(&mut self, rhs: u16)

Performs the >>= operation.

impl ShrAssign<u32> for I256

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl ShrAssign<u64> for I256

fn shr_assign(&mut self, rhs: u64)

Performs the >>= operation.

impl ShrAssign<u128> for I256

fn shr_assign(&mut self, rhs: u128)

Performs the >>= operation.

impl ShrAssign<usize> for I256

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl StructuralPartialEq for I256

impl Sub for I256

type Output = I256

The resulting type after applying the - operator.

fn sub(self, rhs: I256) -> I256

Performs the - operation.

impl SubAssign for I256

fn sub_assign(&mut self, rhs: I256)

Performs the -= operation.

impl TryFrom<I256> for U256

fn try_from(n: I256) -> Result<U256, <U256 as TryFrom<I256>>::Error>

Fails for negative values. Use I256::cast_unsigned to reinterpret those bits instead.

type Error = TryFromIntError

The type returned in the event of a conversion error.

impl TryFrom<U256> for I256

fn try_from(n: U256) -> Result<I256, <I256 as TryFrom<U256>>::Error>

Fails for values above 2^255 - 1, which would land on a negative I256. Use U256::cast_signed to reinterpret those bits instead.

type Error = TryFromIntError

The type returned in the event of a conversion error.

impl UpperHex for I256

Available on crate feature fmt only.

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

Formats the value using the given formatter.

impl WriteXDR for I256

fn write_xdr<F, W>(&self, w: &mut W) -> Result<(), WriteError>

where W: Writer<F>,

Writes this value as XDR data to the writer.

unsafe fn write_xdr_unchecked<F, W>(&self, w: &mut W)

where W: WriterUnchecked<F>,

Writes this value as XDR data to the writer, without runtime checks.