Primitive std::u256

u256

Expand description

256-bit unsigned integer

Implementations

impl u256

pub fn min() -> Self

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

Returns

[u256] - The smallest u256 value.

Examples

fn foo() {
    let val = u256::min();
    assert(val == 0x0000000000000000000000000000000000000000000000000000000000000000u256);

pub fn max() -> Self

The largest value that can be represented by this integer type,
2256 - 1.

Returns

[u256] - The largest u256 value.

Examples

fn foo() {
    let val = u256::max();
    assert(val == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFu256);
}

pub fn bits() -> u64

The size of this integer type in bits.

Returns

[u32] - The number of bits for a u256.

Examples

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

pub fn zero() -> Self

Returns the zero value for the u256 type.

Returns

[u256] -> The zero value for the u256 type.

Examples

fn foo() {
    let zero_u256 = u256::zero();
    assert(zero_u256 == 0x00u256);
}

impl u256

pub fn is_zero(self) -> bool

Returns whether a u256 is set to zero.

Returns

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

Examples

fn foo() {
    let zero_u256 = u256::zero();
    assert(zero_u256.is_zero());
}

impl u256

pub fn as_b256(self) -> b256

Converts a u256 to a b256.

Returns

[b256] - The converted u256 value.

Examples

fn foo() {
    let val: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256;
    let result = val.as_b256();
    assert(result == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20);
}

impl u256

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

Converts the u256 to a sequence of little-endian bytes.

Returns

[[u8; 32]] - An array of 32 u8 bytes that compose the u256.

Examples

fn foo() {
    let bytes = [32_u8, 31_u8, 30_u8, 29_u8, 28_u8, 27_u8, 26_u8, 25_u8, 24_u8, 23_u8,
            22_u8, 21_u8, 20_u8, 19_u8, 18_u8, 17_u8, 16_u8, 15_u8, 14_u8, 13_u8,
            12_u8, 11_u8, 10_u8, 9_u8, 8_u8, 7_u8, 6_u8, 5_u8, 4_u8, 3_u8,
            2_u8, 1_u8];

    let x = u256::from_le_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256);
}

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

Converts a sequence of little-endian bytes to a u256.

Arguments

bytes: [[u8; 32]] - A sequence of 32 u8 bytes that represent a u256.

Returns

[u256] - The resulting u256 value.

Examples

fn foo() {
    let bytes = [32_u8, 31_u8, 30_u8, 29_u8, 28_u8, 27_u8, 26_u8, 25_u8, 24_u8, 23_u8,
            22_u8, 21_u8, 20_u8, 19_u8, 18_u8, 17_u8, 16_u8, 15_u8, 14_u8, 13_u8,
            12_u8, 11_u8, 10_u8, 9_u8, 8_u8, 7_u8, 6_u8, 5_u8, 4_u8, 3_u8,
            2_u8, 1_u8];

    let x = u256::from_le_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256;

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

Converts the u256 to a sequence of big-endian bytes.

Returns

[[u8; 32]] - An array of 32 u8 bytes that compose the u256.

Examples

fn foo() {
    let x: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256;
    let bytes = x.to_be_bytes();

    let mut i: u8 = 0;
    while i < 32_u8 {
        assert(bytes[i.as_u64()] == i + 1_u8);
        i += 1_u8;
    }
}

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

Converts a sequence of big-endian bytes to a u256.

Arguments

bytes: [[u8; 32]] - A sequence of 32 u8 bytes that represent a u256.

Returns

[u256] - The resulting u256 value.

Examples

fn foo() {
    let bytes = [1_u8, 2_u8, 3_u8, 4_u8, 5_u8, 6_u8, 7_u8, 8_u8, 9_u8, 10_u8,
            11_u8, 12_u8, 13_u8, 14_u8, 15_u8, 16_u8, 17_u8, 18_u8, 19_u8, 20_u8,
            21_u8, 22_u8, 23_u8, 24_u8, 25_u8, 26_u8, 27_u8, 28_u8, 29_u8, 30_u8,
            31_u8, 32_u8];
    let x = u256::from_be_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256);
}

impl u256

pub fn to_le_bytes(self) -> Bytes

Converts the u256 to a sequence of little-endian bytes.

Returns

[Bytes] - The 32 bytes that compose the u256.

Examples

fn foo() {
    let x: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20_u256;
    let bytes = x.to_le_bytes();

    let mut i: u8 = 0;
    while i < 32_u8 {
        assert(bytes.get(i.as_u64()).unwrap() == 32_u8 - i);
        i += 1_u8;
    }
}

pub fn from_le_bytes(bytes: Bytes) -> Self

Converts a sequence of little-endian bytes to a u256.

Arguments

bytes: [Bytes] - The 32 bytes that compose the u256.

Returns

[u256] - The resulting u256 value.

Examples

fn foo() {
    let mut bytes = Bytes::with_capacity(32);
    let mut i: u8 = 0;
    while i < 32_u8 {
        bytes.push(32_u8 - i);
        i += 1_u8;
    }

    let x = u256::from_le_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20_u256);
}

pub fn to_be_bytes(self) -> Bytes

Converts the u256 to a sequence of big-endian bytes.

Returns

[Bytes] - The 32 bytes that compose the u256.

Examples

fn foo() {
    let x: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20_u256;
    let bytes = x.to_be_bytes();

    let mut i: u8 = 0;
    while i < 32_u8 {
        assert(bytes.get(i.as_u64()).unwrap() == i + 1_u8);
        i += 1_u8;
    }
}

pub fn from_be_bytes(bytes: Bytes) -> Self

Converts a sequence of big-endian bytes to a u256.

Arguments

bytes: [Bytes] - The 32 bytes that compose the u256.

Returns

[u256] - The resulting u256 value.

Examples

fn foo() {
    let mut bytes = Bytes::with_capacity(32);
    let mut i: u8 = 0;
    while i < 32_u8 {
        bytes.push(i + 1);
        i += 1_u8;
    }

    let x = u256::from_be_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20_u256);
}

Trait Implementations

impl Add for u256

pub fn add(self, other: Self) -> Self

impl Subtract for u256

pub fn subtract(self, other: Self) -> Self

impl Multiply for u256

pub fn multiply(self, other: Self) -> Self

impl Divide for u256

pub fn divide(self, other: Self) -> Self

impl Mod for u256

pub fn modulo(self, other: Self) -> Self

impl Not for u256

pub fn not(self) -> Self

impl PartialEq for u256

pub fn eq(self, other: Self) -> bool

pub fn neq(self, other: Self) -> bool

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 PartialEq 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);
}

impl Eq for u256

impl Ord for u256

pub fn gt(self, other: Self) -> bool

pub fn lt(self, other: Self) -> bool

impl BitwiseAnd for u256

pub fn binary_and(self, other: Self) -> Self

impl BitwiseOr for u256

pub fn binary_or(self, other: Self) -> Self

impl BitwiseXor for u256

pub fn binary_xor(self, other: Self) -> Self

impl OrdEq for u256

pub fn ge(self, other: Self) -> bool

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);
}

pub fn le(self, other: Self) -> bool

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);
}

impl Shift for u256

pub fn lsh(self, other: u64) -> Self

pub fn rsh(self, other: u64) -> Self

impl TotalOrd for u256

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

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

impl AbiEncode for u256

pub fn abi_encode(self, buffer: Buffer) -> Buffer

impl AbiDecode for u256

pub fn abi_decode(refmut buffer: BufferReader) -> u256

impl Clone for u256

pub fn clone(self) -> Self

impl TryFrom<B512> for u256

pub fn try_from(val: B512) -> Option<Self>

Attempts conversion from a B512 to a u256.

Additional Information

If the high bits of the B512 are not zero, the conversion will fail.

Arguments

val: [B512] - The B512 to be converted.

Returns

[Option] - The u256 representation of the B512 value.

Examples

use std::b512::B512;

fn foo() {
    let b512_value = B512::new();
    let u256_value = u256::try_from(b512_value).unwrap();
}

impl From<u8> for u256

pub fn from(num: u8) -> Self

Casts a u8 to a u256.

Arguments

num: [u8] - The u8 to be casted.

Returns

[u256] - The u256 representation of the u8 value.

Examples


fn foo() {
   let u256_value = u256::from(255_u8);
}

impl From<u16> for u256

pub fn from(num: u16) -> Self

Casts a u16 to a u256.

Arguments

num: [u16] - The u16 to be casted.

Returns

[u256] - The u256 representation of the u16 value.

Examples


fn foo() {
   let u256_value = u256::from(65535_u16);
}

impl From<u32> for u256

pub fn from(num: u32) -> Self

Casts a u32 to a u256.

Arguments

num: [u32] - The u32 to be casted.

Returns

[u256] - The u256 representation of the u32 value.

Examples


fn foo() {
   let u256_value = u256::from(4294967295_u32);
}

impl From<u64> for u256

pub fn from(num: u64) -> Self

Casts a u64 to a u256.

Arguments

num: [u64] - The u64 to be casted.

Returns

[u256] - The u256 representation of the u64 value.

Examples


fn foo() {
   let u256_value = u256::from(18446744073709551615_u64);
}

impl From<b256> for u256

pub fn from(bits: b256) -> Self

Casts raw b256 data to a u256.

Arguments

bits: [b256] - The raw b256 data to be casted.

Returns

[u256] - The u256 representation of the raw b256.

Examples

fn foo() {
   let u256_value = u256::zero();
}

impl From<(u64, u64, u64, u64)> for u256

pub fn from(nums: (u64, u64, u64, u64)) -> Self

Casts a tuple of 4 u64 values to a u256.

Arguments

nums: (u64, u64, u64, u64) - The tuple of u64 values to be casted.

Returns

[u256] - The u256 representation of the tuple of u64 values.

Examples


fn foo() {
   let u256_value = u256::from((1, 2, 3, 4));
}

impl Root for u256

pub fn sqrt(self) -> Self

impl Power for u256

pub fn pow(self, exponent: u32) -> Self

Raises self to the power of exponent, using exponentiation by squaring.

Additional Information

If panic on overflow is disabled, and the result overflows, the return value will be 0.

Reverts

Reverts if the result overflows the type, if panic on overflow is enabled.

impl BinaryLogarithm for u256

pub fn log2(self) -> Self

impl Logarithm for u256

pub fn log(self, base: Self) -> Self

impl From<U128> for u256

pub fn from(num: U128) -> Self

Converts a U128 to a u256.

Arguments

num: [U128] - The U128 to be converted.

Returns

[u256] - The u256 representation of the U128 value.

Examples

use std::u128::U128;

fn foo() {
   let u128_value = U128::from((18446744073709551615_u64, 18446744073709551615_u64));
   let u256_value = u256::from(u128_value);
}