Module math.unsigned stdlib

math.unsigned
Version:
0.3.3
License:
MIT
Dependencies from vmod:
0
Imports:
2
Imported by:
1
Repository:
OS-specific
Show selected OS-specific symbols.
Backend-specific
Show selected Backend-specific symbols.

Dependencies defined in v.mod

This section is empty.

Imports

Imported by

Aliases

This section is empty.

Constants

#constant uint128_zero

uint128_zero = Uint128{}

#constant uint128_max

uint128_max  = Uint128{18446744073709551615, 18446744073709551615}

#constant uint256_zero

uint256_zero = Uint256{Uint128{}, Uint128{}}

#constant uint256_max

uint256_max  = Uint256{uint128_max, uint128_max}

Sum types

This section is empty.

Functions

#fn add_128

fn add_128(x Uint128, y Uint128, carry u64) (Uint128, u64)

#fn add_256

fn add_256(x Uint256, y Uint256, carry u64) (Uint256, u64)

add_256 - untested

#fn div_128

fn div_128(hi Uint128, lo Uint128, y_ Uint128) (Uint128, Uint128)

#fn mul_128

fn mul_128(x Uint128, y Uint128) (Uint128, Uint128)

#fn mul_256

fn mul_256(x Uint256, y Uint256) (Uint256, Uint256)

mul_256 - untested

#fn sub_128

fn sub_128(x Uint128, y Uint128, borrow u64) (Uint128, u64)

#fn sub_256

fn sub_256(x Uint256, y Uint256, borrow u64) (Uint256, u64)

sub_256 - untested

#fn uint128_from_64

fn uint128_from_64(v u64) Uint128

uint128_from_64 converts v to a Uint128 value

#fn uint128_from_dec_str

fn uint128_from_dec_str(value string) !Uint128

#fn uint128_new

fn uint128_new(lo u64, hi u64) Uint128

#fn uint256_from_128

fn uint256_from_128(v Uint128) Uint256

uint256_from_128 creates a new unsigned.Uint256 from the given Uint128 value

#fn uint256_from_64

fn uint256_from_64(v u64) Uint256

uint256_from_64 creates a new unsigned.Uint256 from the given u64 value

#fn uint256_from_dec_str

fn uint256_from_dec_str(value string) ?Uint256

uint256_from_dec_str creates a new unsigned.Uint256 from the given string if possible

Structs

#struct Uint128

pub struct Uint128 {
pub mut:
	lo u64
	hi u64
}

#fn (Uint128) is_zero

fn (u Uint128) is_zero() bool

is_zero returns true if u == 0

#fn (Uint128) equals

fn (u Uint128) equals(v Uint128) bool

equals returns true if u == v.

Uint128 values can be compared directly with ==, but use of the Equals method is preferred for consistency.

#fn (Uint128) equals_64

fn (u Uint128) equals_64(v u64) bool

equals_64 returns true if u == v

#fn (Uint128) cmp

fn (u Uint128) cmp(v Uint128) int

cmp compares u and v and returns:

-1 if u < v

0 if u == v +1 if u > v

#fn (Uint128) cmp_64

fn (u Uint128) cmp_64(v u64) int

cmp_64 compares u and v and returns:

-1 if u < v 0 if u == v +1 if u > v

#fn (Uint128) and

fn (u Uint128) and(v Uint128) Uint128

and returns u & v

#fn (Uint128) and_64

fn (u Uint128) and_64(v u64) Uint128

and_64 rreturns u & v

#fn (Uint128) or_

fn (u Uint128) or_(v Uint128) Uint128

or returns u | v

#fn (Uint128) or_64

fn (u Uint128) or_64(v u64) Uint128

or returns u | v

#fn (Uint128) xor

fn (u Uint128) xor(v Uint128) Uint128

xor returns u ^ v

#fn (Uint128) xor_64

fn (u Uint128) xor_64(v u64) Uint128

xor_64 returns u ^ v

#fn (Uint128) add

fn (u Uint128) add(v Uint128) Uint128

add returns u + v with wraparound semantics

#fn (Uint128) add_64

fn (u Uint128) add_64(v u64) Uint128

add_64 returns u + v with wraparound semantics

#fn (Uint128) sub

fn (u Uint128) sub(v Uint128) Uint128

sub returns u - v with wraparound semantics

#fn (Uint128) sub_64

fn (u Uint128) sub_64(v u64) Uint128

sub_64 returns u - v with wraparound semantics

#fn (Uint128) mul

fn (u Uint128) mul(v Uint128) Uint128

mul returns u * v with wraparound semantics

#fn (Uint128) mul_64

fn (u Uint128) mul_64(v u64) Uint128

mul_64 returns u * v with wraparound semantics

#fn (Uint128) overflowing_mul_64

fn (u Uint128) overflowing_mul_64(v u64) (Uint128, bool)

#fn (Uint128) overflowing_add_64

fn (u Uint128) overflowing_add_64(v u64) (Uint128, u64)

#fn (Uint128) div

fn (u Uint128) div(v Uint128) Uint128

div returns u / v

#fn (Uint128) mod

fn (u Uint128) mod(v Uint128) Uint128

mod returns r = u % v

#fn (Uint128) mod_64

fn (u Uint128) mod_64(v u64) u64

mod_64 returns r = u % v

#fn (Uint128) quo_rem_64

fn (u Uint128) quo_rem_64(v u64) (Uint128, u64)

quo_rem_64 returns q = u/v and r = u%v

#fn (Uint128) quo_rem

fn (u Uint128) quo_rem(v Uint128) (Uint128, Uint128)

quo_rem returns q = u/v and r = u%v

#fn (Uint128) lsh

fn (u Uint128) lsh(n u32) Uint128

lsh returns u << n

#fn (Uint128) rsh

fn (u Uint128) rsh(n u32) Uint128

rsh returns u >> n

#fn (Uint128) leading_zeros

fn (u Uint128) leading_zeros() int

leading_zeros returns the number of leading zero bits in u; the result is 128 for u == 0.

#fn (Uint128) trailing_zeros

fn (u Uint128) trailing_zeros() int

trailing_zeros returns the number of trailing zero bits in u; the result is 128 for u == 0.

#fn (Uint128) ones_count

fn (u Uint128) ones_count() int

ones_count returns the number of one bits ("population count" in u)

#fn (Uint128) rotate_left

fn (u Uint128) rotate_left(k int) Uint128

rotate_left returns the value of u rotated left by (k mod 128) bits.

#fn (Uint128) rotate_right

fn (u Uint128) rotate_right(k int) Uint128

rotate_right returns the value of u rotated right by (k mod 128) bits.

#fn (Uint128) reverse

fn (u Uint128) reverse() Uint128

reverse returns the value of u with its bits in reversed order.

#fn (Uint128) reverse_bytes

fn (u Uint128) reverse_bytes() Uint128

reverse_bytes returns the value of u with its bytes in reversed order.

#fn (Uint128) not

fn (u Uint128) not() Uint128

#fn (Uint128) len

fn (u Uint128) len() int

len returns the minimum number of bits required to represent u; the result is 0 for u == 0.

#fn (Uint128) str

fn (u_ Uint128) str() string

string returns the base-10 representation of u as a string

#fn (Uint128) put_bytes

fn (u Uint128) put_bytes(mut b &[]u8)

put_bytes stores u in b in little-endian order

#fn (Uint128) operator/

fn (u Uint128) / (v Uint128) Uint128

#fn (Uint128) operator%

fn (u Uint128) % (v Uint128) Uint128

#fn (Uint128) operator+

fn (u Uint128) + (v Uint128) Uint128

#fn (Uint128) operator-

fn (u Uint128) - (v Uint128) Uint128

#fn (Uint128) operator*

fn (u Uint128) * (v Uint128) Uint128

#fn (Uint128) operator<

fn (u Uint128) < (v Uint128) bool

#struct Uint256

pub struct Uint256 {
pub mut:
	lo Uint128 = uint128_zero // lower 128 bit half
	hi Uint128 = uint128_zero // upper 128 bit half
}

Uint256 is an unsigned 256-bit number

#fn (Uint256) is_zero

fn (u Uint256) is_zero() bool

is_zero checks if specified Uint256 is zero

#fn (Uint256) equals

fn (u Uint256) equals(v Uint256) bool

equals checks if the two Uint256 values match one another

#fn (Uint256) equals_128

fn (u Uint256) equals_128(v Uint128) bool

equals_128 checks if the Uint256 value matches the Uint128 value

#fn (Uint256) cmp

fn (u Uint256) cmp(v Uint256) int

cmp returns 1 if u is greater than v, -1 if u is less than v, or 0 if equal

#fn (Uint256) cmp_128

fn (u Uint256) cmp_128(v Uint128) int

cmp_128 returns 1 if u is greater than v (Uint128), -1 if u is less than v, or 0 if equal

#fn (Uint256) not

fn (u Uint256) not() Uint256

not returns a binary negation of the Uint256 value

#fn (Uint256) and

fn (u Uint256) and(v Uint256) Uint256

and returns a Uint256 value that is the bitwise and of u and v

#fn (Uint256) and_128

fn (u Uint256) and_128(v Uint128) Uint256

and_128 returns a Uint256 value that is the bitwise and of u and v, which is a Uint128

#fn (Uint256) or_

fn (u Uint256) or_(v Uint256) Uint256

or_ returns a Uint256 value that is the bitwise or of u and v

#fn (Uint256) or_128

fn (u Uint256) or_128(v Uint128) Uint256

or_128 returns a Uint256 value that is the bitwise or of u and v, which is a Uint128

#fn (Uint256) xor

fn (u Uint256) xor(v Uint256) Uint256

xor returns a Uint256 value that is the bitwise xor of u and v

#fn (Uint256) xor_128

fn (u Uint256) xor_128(v Uint128) Uint256

xor_128 returns a Uint256 value that is the bitwise xor of u and v, which is a Uint128

#fn (Uint256) add

fn (u Uint256) add(v Uint256) Uint256

add returns a Uint256 that is equal to u+v

#fn (Uint256) overflowing_add

fn (u Uint256) overflowing_add(v Uint256) (Uint256, u64)

overflowing_add - untested

#fn (Uint256) add_128

fn (u Uint256) add_128(v Uint128) Uint256

add_128 returns a Uint256 that is equal to u+v, v being a Uint128

#fn (Uint256) sub

fn (u Uint256) sub(v Uint256) Uint256

sub returns a Uint256 that is equal to u-v

#fn (Uint256) sub_128

fn (u Uint256) sub_128(v Uint128) Uint256

sub_128 returns a Uint256 that is equal to u-v, v being a Uint128

#fn (Uint256) mul

fn (u Uint256) mul(v Uint256) Uint256

mul returns a Uint256 that is eqal to u*v

#fn (Uint256) mul_128

fn (u Uint256) mul_128(v Uint128) Uint256

mul_128 returns a Uint256 that is eqal to u*v, v being a Uint128

#fn (Uint256) quo_rem

fn (u Uint256) quo_rem(v Uint256) (Uint256, Uint256)

quo_rem - untested

#fn (Uint256) quo_rem_128

fn (u Uint256) quo_rem_128(v Uint128) (Uint256, Uint128)

quo_rem_128 - untested

#fn (Uint256) quo_rem_64

fn (u Uint256) quo_rem_64(v u64) (Uint256, u64)

quo_rem_64 - untested

#fn (Uint256) rsh

fn (u Uint256) rsh(n_ u32) Uint256

rsh returns a new Uint256 that has been right bit shifted

#fn (Uint256) lsh

fn (u Uint256) lsh(n_ u32) Uint256

lsh returns a new Uint256 that has been left bit shifted

#fn (Uint256) div

fn (u Uint256) div(v Uint256) Uint256

div - untested

#fn (Uint256) div_128

fn (u Uint256) div_128(v Uint128) Uint256

div_128 - untested

#fn (Uint256) div_64

fn (u Uint256) div_64(v u64) Uint256

div_64 - untested

#fn (Uint256) mod

fn (u Uint256) mod(v Uint256) Uint256

mod - untested

#fn (Uint256) mod_128

fn (u Uint256) mod_128(v Uint128) Uint128

mod_128 - untested

#fn (Uint256) mod_64

fn (u Uint256) mod_64(v u64) u64

mod_64 - untested

#fn (Uint256) rotate_left

fn (u Uint256) rotate_left(k int) Uint256

rotate_left returns a new Uint256 that has been left bit shifted

#fn (Uint256) rotate_right

fn (u Uint256) rotate_right(k int) Uint256

rotate_right returns a new Uint256 that has been right bit shifted

#fn (Uint256) len

fn (u Uint256) len() int

len returns the length of the binary value without the leading zeros

#fn (Uint256) leading_zeros

fn (u Uint256) leading_zeros() int

leading_zeros returns the number of 0s at the beginning of the binary value of the Uint256 value [0, 256]

#fn (Uint256) trailing_zeros

fn (u Uint256) trailing_zeros() int

trailing_zeros returns the number of 0s at the end of the binary value of the Uint256 value [0,256]

#fn (Uint256) ones_count

fn (u Uint256) ones_count() int

ones_count returns the number of ones in the binary value of the Uint256 value

#fn (Uint256) str

fn (u_ Uint256) str() string

str returns the decimal representation of the unsigned integer

#fn (Uint256) operator/

fn (u Uint256) / (v Uint256) Uint256

#fn (Uint256) operator%

fn (u Uint256) % (v Uint256) Uint256

#fn (Uint256) operator+

fn (u Uint256) + (v Uint256) Uint256

#fn (Uint256) operator-

fn (u Uint256) - (v Uint256) Uint256

#fn (Uint256) operator*

fn (u Uint256) * (v Uint256) Uint256

Interfaces

This section is empty.

Enums

This section is empty.