The underlying value that corresponds to zero value.

Additional Information

The zero value for I256 is 0x8000000000000000000000000000000000000000000000000000000000000000u256.

Returns

• [u256] - The unsigned integer value representing a zero value.

Examples

use sway_libs::signed_integers::i256::I256;

fn foo() {
    let zero = I256::indent();
    assert(zero == 0x8000000000000000000000000000000000000000000000000000000000000000u256);
}

The size of this type in bits.

Returns

[u64] - The defined size of the I256 type.

Examples

``sway
use sway_libs::signed_integers::i256::I256;

fn foo() {
let bits = I256::bits();
assert(bits == 256);
}

Helper function to get a signed number from with an underlying.

Arguments

• underlying: [u256] - The unsigned number to become the underlying value for the I256.

Returns

• [I256] - The newly created I256 struct.

Examples

use sway_libs::signed_integers::i256::I256;

fn foo() {
    let underlying = 0x0000000000000000000000000000000000000000000000000000000000000001u256;
    let i256 = I256::from_uint(underlying);
    assert(i256.underlying() == underlying);
}

The largest value that can be represented by this integer type.

Returns

• [I256] - The newly created I256 struct.

Examples

use sway_libs::signed_integers::i256::I256;

fn foo() {
    let i256 = I256::max();
    assert(i256.underlying() == u256::max());
}

The smallest value that can be represented by this integer type.

Returns

• [I256] - The newly created I256 type.

Examples

use sway_libs::signed_integers::i256::I256;

fn foo() {
    let i256 = I256::min();
    assert(i256.underlying() == u256::min());
}

Helper function to get a negative value of an unsigned number.

Arguments

• value: [u256] - The unsigned number to negate.

Returns

• [Option] - The newly created I256 struct.

Examples

use sway_libs::signed_integers::i256::I256;

fn foo() {
    let underlying = 0x0000000000000000000000000000000000000000000000000000000000000000u256;
    let i256 = I256::neg_try_from(underlying).unwrap();
    assert(i256.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256);
}

Initializes a new, zeroed I256.

Additional Information

The zero value of I256 is 0x8000000000000000000000000000000000000000000000000000000000000000u256.

Returns

• [I256] - The newly created I256 struct.

Examples

use sway_libs::signed_integers::i256::I256;

fn foo() {
    let i256 = I256::new();
    assert(i256.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256);
}

The zero value I256.

Returns

• [I256] - The newly created I256 type.

Examples

use sway_libs::signed_integers::i256::I256;

fn foo() {
    let i256 = I256::zero();
    assert(i256.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256);
}

Returns whether a I256 is set to zero.

Returns

• [bool] -> True if the I256 is zero, otherwise false.

Examples

use sway_libs::signed_integers::i256::I256;

fn foo() {
    let i256 = I256::zero();
    assert(i256.is_zero());
}

Returns the underlying u256 representing the I256.

Returns

• [u256] - The u256 representing the I256.

Examples

use sway_libs::signed_integers::i256::I256;

fn foo() {
    let i256 = I256::zero();
    assert(i256.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256);
}

Evaluates if two values of the same type are not equal.

Additional Information

This function is inherited when eq() is implemented.

Arguments

• other: [Self] - The value of the same type.

Returns

• [bool] - true if the two values are not equal, otherwise false.

Examples

struct MyStruct {
    val: u64,
}

impl Eq for MyStruct {
    fn eq(self, other: Self) -> bool {
         self.val == other.val
    }
}

fn foo() {
    let struct1 = MyStruct { val: 10 };
    let struct2 = MyStruct { val: 2 };
    let result = struct1 != struct2;
    assert(result);
}

Evaluates if one value of the same type is greater or equal to than another.

Additional Information

This trait requires that the Ord and Eq traits are implemented.

Arguments

• other: [Self] - The value of the same type.

Returns

• [bool] - true if self is greater than or equal to other, otherwise false.

Examples

struct MyStruct {
    val: u64,
}

impl Eq for MyStruct {
    fn eq(self, other: Self) -> bool {
        self.val == other.val
    }
}

impl Ord for MyStruct {
    fn gt(self, other: Self) -> bool {
        self.val > other.val
    }
}

impl OrdEq for MyStruct {}

fn foo() {
    let struct1 = MyStruct { val: 10 };
    let struct2 = MyStruct { val: 10 };
    let result = struct1 >= struct2;
    assert(result);
}

Evaluates if one value of the same type is less or equal to than another.

Additional Information

This trait requires that the Ord and Eq traits are implemented.

Arguments

• other: [Self] - The value of the same type.

Returns

• [bool] - true if self is less than or equal to other, otherwise false.

Examples

struct MyStruct {
    val: u64,
}

impl Eq for MyStruct {
    fn eq(self, other: Self) -> bool {
        self.val == other.val
    }
}

impl Ord for MyStruct {
    fn lt(self, other: Self) -> bool {
        self.val < other.val
    }
}

impl OrdEq for MyStruct {}

fn foo() {
    let struct1 = MyStruct { val: 10 };
    let struct2 = MyStruct { val: 10 };
    let result = struct1 <= struct2;
    assert(result);
}

Add a I256 to a I256. Panics on overflow.

Divide a I256 by a I256. Panics if divisor is zero.

Multiply a I256 with a I256. Panics of overflow.

Subtract a I256 from a I256. Panics of overflow.