Returns whether a u64 is set to zero.

Returns

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

Examples

fn foo() {
    let zero_u64 = u64::zero();
    assert(zero_u64.is_zero());
}

Performs addition between two u64 values, returning a U128.

Additional Information

Allows for addition between two u64 values that would otherwise overflow.

Arguments

• right: [u64] - The right-hand side of the addition.

Returns

• [U128] - The result of the addition.

Examples

use std::u128::U128;

fn foo() {
    let x = u64::max();
    let y = u64::max();
    let z = x.overflowing_add(y);

    assert(z == U128::from(1, 18446744073709551614));
}

Performs multiplication between two u64 values, returning a U128.

Additional Information

Allows for multiplication between two u64 values that would otherwise overflow.

Arguments

• right: [u64] - The right-hand side of the multiplication.

Returns

• [U128] - The result of the multiplication.

Examples

use std::u128::U128;

fn foo() {
    let x = u64::max();
    let y = u64::max();
    let z = x.overflowing_mul(y);

    assert(z == U128::from(18446744073709551615, 1));
}

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

Returns

• [[u8; 8]] - An array of 8 u8 bytes that compose the u64.

Examples

fn foo() {
    let x: u64 = 578437695752307201;
    let result = x.to_le_bytes();

    assert(result[0] == 1_u8);
    assert(result[1] == 2_u8);
    assert(result[2] == 3_u8);
    assert(result[3] == 4_u8);
    assert(result[4] == 5_u8);
    assert(result[5] == 6_u8);
    assert(result[6] == 7_u8);
    assert(result[7] == 8_u8);
}

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

Arguments

• bytes: [[u8; 8]] - A sequence of 8 u8 bytes that represent a u64.

Returns

• [u64] - The resulting u64 value.

Examples

fn foo() {
    let bytes = [1_u8, 2_u8, 3_u8, 4_u8, 5_u8, 6_u8, 7_u8, 8_u8];
    let result = u64::from_le_bytes(bytes);

    assert(result == 578437695752307201);
}

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

Returns

• [[u8; 8]] - An array of 8 u8 bytes that compose the u64.

Examples

fn foo() {
    let x: u64 = 578437695752307201;
    let result = x.to_be_bytes();

    assert(result[0] == 8_u8);
    assert(result[1] == 7_u8);
    assert(result[2] == 6_u8);
    assert(result[3] == 5_u8);
    assert(result[4] == 4_u8);
    assert(result[5] == 3_u8);
    assert(result[6] == 2_u8);
    assert(result[7] == 1_u8);
}

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

Arguments

• bytes: [[u8; 8]] - A sequence of 8 u8 bytes that represent a u64.

Returns

• [u64] - The resulting u64 value.

Examples

fn foo() {
    let bytes = [8_u8, 7_u8, 6_u8, 5_u8, 4_u8, 3_u8, 2_u8, 1_u8];
    let result = u64::from_be_bytes(bytes);

    assert(result == 578437695752307201);
}

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

Returns

• [Bytes] - The bytes that compose the u64.

Examples

use std::bytes_conversions::u64::*;

fn foo() {
    let x: u64 = 578437695752307201;
    let result = x.to_le_bytes();

    assert(result.get(0).unwrap() == 1_u8);
    assert(result.get(1).unwrap() == 2_u8);
    assert(result.get(2).unwrap() == 3_u8);
    assert(result.get(3).unwrap() == 4_u8);
    assert(result.get(4).unwrap() == 5_u8);
    assert(result.get(5).unwrap() == 6_u8);
    assert(result.get(6).unwrap() == 7_u8);
    assert(result.get(7).unwrap() == 8_u8);
}

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

Arguments

• bytes: [Bytes] - A Bytes object that represent a u64.

Returns

• [u64] - The resulting u64 value.

Examples

use std::{bytes::Bytes, bytes_conversions::u64::*};

fn foo() {
    let mut bytes = Bytes::new();
    bytes.push(1_u8);
    bytes.push(2_u8);
    bytes.push(3_u8);
    bytes.push(4_u8);
    bytes.push(5_u8);
    bytes.push(6_u8);
    bytes.push(7_u8);
    bytes.push(8_u8);
    let result = u64::from_le_bytes(bytes);

    assert(result == 578437695752307201);
}

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

Returns

• [Bytes] - The bytes that compose the u64.

Examples

use std::bytes_conversions::u64::*;

fn foo() {
    let x: u64 = 578437695752307201;
    let result = x.to_be_bytes();

    assert(result.get(0).unwrap() == 8_u8);
    assert(result.get(1).unwrap() == 7_u8);
    assert(result.get(2).unwrap() == 6_u8);
    assert(result.get(3).unwrap() == 5_u8);
    assert(result.get(4).unwrap() == 4_u8);
    assert(result.get(5).unwrap() == 3_u8);
    assert(result.get(6).unwrap() == 2_u8);
    assert(result.get(7).unwrap() == 1_u8);
}

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

Arguments

• bytes: [Bytes] - A Bytes object that represent a u64.

Returns

• [u64] - The resulting u64 value.

Examples

use std::{bytes::Bytes, bytes_conversions::u64::*};

fn foo() {
    let mut bytes = Bytes::new();
    bytes.push(8_u8);
    bytes.push(7_u8);
    bytes.push(6_u8);
    bytes.push(5_u8);
    bytes.push(4_u8);
    bytes.push(3_u8);
    bytes.push(2_u8);
    bytes.push(1_u8);
    let result = u64::from_be_bytes(bytes);

    assert(result == 578437695752307201);
}

Casts a u8 to a u64.

Returns

• [u64] - The u64 representation of the u8 value.

Examples

fn foo() {
    let u64_value = u64::from(0u8);
}

Casts a u16 to a u64.

Returns

• [u64] - The u64 representation of the u16 value.

Examples

fn foo() {
    let u64_value = u64::from(0u16);
}

Casts a u32 to a u64.

Returns

• [u64] - The u64 representation of the u32 value.

Examples

fn foo() {
    let u64_value = u64::from(0u32);
}