uint256

package module
v0.0.0-...-0a81f5f Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 19, 2023 License: BSD-3-Clause Imports: 13 Imported by: 0

README

Fixed size 256-bit math library

This is a library specialized at replacing the big.Int library for math based on 256-bit types, used by both go-ethereum and turbo-geth.

Go Reference codecov DeepSource

Benchmarks

Current benchmarks, with tests ending with big being the standard big.Int library, and uint256 being this library.

Current status
  • As of 2020-03-18, uint256 wins over math/big in every single case, often with orders of magnitude.
  • And as of release 0.1.0, the uint256 library is alloc-free.
  • With the 1.0.0 release, it also has 100% test coverage.
Bitwise
benchmark u256 time/op big time/op time diff u256 B/op big B/op B diff u256 allocs/op big allocs/op allocs diff
And/single 2.03ns 8.46ns -76.04% 0 0 ~ 0 0 ~
Or/single 2.03ns 10.98ns -81.51% 0 0 ~ 0 0 ~
Xor/single 2.03ns 12.19ns -83.34% 0 0 ~ 0 0 ~
Rsh/n_eq_0 5.00ns 48.11ns -89.61% 0 64 -100.00% 0 1 -100.00%
Rsh/n_gt_0 10.42ns 48.41ns -78.48% 0 64 -100.00% 0 1 -100.00%
Rsh/n_gt_64 6.94ns 52.39ns -86.76% 0 64 -100.00% 0 1 -100.00%
Rsh/n_gt_128 5.49ns 44.21ns -87.59% 0 48 -100.00% 0 1 -100.00%
Rsh/n_gt_192 3.43ns 28.71ns -88.04% 0 8 -100.00% 0 1 -100.00%
Lsh/n_eq_0 4.89ns 40.49ns -87.92% 0 64 -100.00% 0 1 -100.00%
Lsh/n_gt_0 10.14ns 53.25ns -80.96% 0 80 -100.00% 0 1 -100.00%
Lsh/n_gt_64 7.50ns 53.92ns -86.08% 0 80 -100.00% 0 1 -100.00%
Lsh/n_gt_128 5.39ns 56.86ns -90.52% 0 96 -100.00% 0 1 -100.00%
Lsh/n_gt_192 3.90ns 57.61ns -93.23% 0 96 -100.00% 0 1 -100.00%
Conversions
benchmark u256 time/op big time/op time diff u256 B/op big B/op B diff u256 allocs/op big allocs/op allocs diff
FromHexString 116.70ns 861.30ns -86.45% 32 88 -63.64% 1 3 -66.67%
FromDecimalString 7973.00ns 32850.00ns -75.73% 0 2464 -100.00% 0 77 -100.00%
Float64/Float64 2366.00ns 28483.00ns -91.69% 0 23424 -100.00% 0 510 -100.00%
EncodeHex/large 95.26ns 184.30ns -48.31% 80 140 -42.86% 1 2 -50.00%
Decimal/ToDecimal 67384.00ns 83431.00ns -19.23% 11344 31920 -64.46% 248 594 -58.25%
Decimal/ToPrettyDecimal 84208.00ns 123953.00ns -32.06% 14720 61376 -76.02% 251 1100 -77.18%
Math
benchmark u256 time/op big time/op time diff u256 B/op big B/op B diff u256 allocs/op big allocs/op allocs diff
Add/single 1.99ns 18.11ns -89.02% 0 0 ~ 0 0 ~
Sub/single 2.00ns 17.19ns -88.35% 0 0 ~ 0 0 ~
Mul/single 12.10ns 57.69ns -79.03% 0 0 ~ 0 0 ~
SDiv/large 94.64ns 642.10ns -85.26% 0 312 -100.00% 0 6 -100.00%
Sqrt/single 594.90ns 1844.00ns -67.74% 0 528 -100.00% 0 7 -100.00%
Square/single 12.49ns 56.10ns -77.74% 0 0 ~ 0 0 ~
Cmp/single 4.78ns 12.79ns -62.61% 0 0 ~ 0 0 ~
Div/small 12.91ns 48.31ns -73.28% 0 8 -100.00% 0 1 -100.00%
Div/mod64 65.77ns 111.20ns -40.85% 0 8 -100.00% 0 1 -100.00%
Div/mod128 93.67ns 301.40ns -68.92% 0 80 -100.00% 0 1 -100.00%
Div/mod192 86.52ns 263.80ns -67.20% 0 80 -100.00% 0 1 -100.00%
Div/mod256 77.17ns 252.80ns -69.47% 0 80 -100.00% 0 1 -100.00%
AddMod/small 13.84ns 48.16ns -71.26% 0 4 -100.00% 0 0 ~
AddMod/mod64 22.83ns 57.58ns -60.35% 0 11 -100.00% 0 0 ~
AddMod/mod128 48.31ns 145.00ns -66.68% 0 12 -100.00% 0 0 ~
AddMod/mod192 47.26ns 160.00ns -70.46% 0 12 -100.00% 0 0 ~
AddMod/mod256 14.44ns 143.20ns -89.92% 0 12 -100.00% 0 0 ~
MulMod/small 40.81ns 63.14ns -35.37% 0 8 -100.00% 0 1 -100.00%
MulMod/mod64 91.66ns 112.60ns -18.60% 0 48 -100.00% 0 1 -100.00%
MulMod/mod128 136.00ns 362.70ns -62.50% 0 128 -100.00% 0 2 -100.00%
MulMod/mod192 151.70ns 421.20ns -63.98% 0 144 -100.00% 0 2 -100.00%
MulMod/mod256 188.80ns 489.20ns -61.41% 0 176 -100.00% 0 2 -100.00%
Exp/small 433.70ns 7490.00ns -94.21% 0 7392 -100.00% 0 77 -100.00%
Exp/large 5145.00ns 23043.00ns -77.67% 0 18144 -100.00% 0 189 -100.00%
Mod/mod64 70.94ns 118.90ns -40.34% 0 64 -100.00% 0 1 -100.00%
Mod/small 14.82ns 46.27ns -67.97% 0 8 -100.00% 0 1 -100.00%
Mod/mod128 99.58ns 286.90ns -65.29% 0 64 -100.00% 0 1 -100.00%
Mod/mod192 95.31ns 269.30ns -64.61% 0 48 -100.00% 0 1 -100.00%
Mod/mod256 84.13ns 222.90ns -62.26% 0 8 -100.00% 0 1 -100.00%
MulOverflow/single 27.68ns 57.52ns -51.88% 0 0 ~ 0 0 ~
MulDivOverflow/small 2.83ns 22.97ns -87.69% 0 0 ~ 0 0 ~
MulDivOverflow/div64 2.85ns 23.13ns -87.66% 0 0 ~ 0 0 ~
MulDivOverflow/div128 3.14ns 31.29ns -89.96% 0 2 -100.00% 0 0 ~
MulDivOverflow/div192 3.17ns 30.28ns -89.54% 0 2 -100.00% 0 0 ~
MulDivOverflow/div256 3.54ns 35.56ns -90.06% 0 5 -100.00% 0 0 ~
Lt/small 3.12ns 10.43ns -70.06% 0 0 ~ 0 0 ~
Lt/large 3.49ns 10.32ns -66.18% 0 0 ~ 0 0 ~
Other
benchmark u256 time/op u256 B/op u256 allocs/op
SetBytes/generic 104.30ns 0 0
Sub/single/uint256_of 1.99ns 0 0
SetFromBig/overflow 3.57ns 0 0
ToBig/2words 73.84ns 64 2
SetBytes/specific 45.81ns 0 0
ScanScientific 674.10ns 0 0
SetFromBig/4words 3.82ns 0 0
ToBig/4words 68.82ns 64 2
RLPEncoding 11917.00ns 11911 255
SetFromBig/1word 2.99ns 0 0
SetFromBig/3words 4.12ns 0 0
ToBig/3words 70.12ns 64 2
ToBig/1word 75.38ns 64 2
MulMod/mod256/uint256r 77.11ns 0 0
HashTreeRoot 11.27ns 0 0
SetFromBig/2words 3.90ns 0 0

Helping out

If you're interested in low-level algorithms and/or doing optimizations for shaving off nanoseconds, then this is certainly for you!

Implementation work

Choose an operation, and optimize the s**t out of it!

A few rules, though, to help your PR get approved:

  • Do not optimize for 'best-case'/'most common case' at the expense of worst-case.
  • We'll hold off on go assembly for a while, until the algos and interfaces are finished in a 'good enough' first version. After that, it's assembly time.
Doing benchmarks

To do a simple benchmark for everything, do

go test -run - -bench . -benchmem

To see the difference between a branch and master, for a particular benchmark, do

git checkout master
go test -run - -bench Benchmark_Lsh -benchmem -count=10 > old.txt

git checkout opt_branch
go test -run - -bench Benchmark_Lsh -benchmem -count=10 > new.txt

benchstat old.txt new.txt

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrEmptyString      = errors.New("empty hex string")
	ErrSyntax           = errors.New("invalid hex string")
	ErrMissingPrefix    = errors.New("hex string without 0x prefix")
	ErrEmptyNumber      = errors.New("hex string \"0x\"")
	ErrLeadingZero      = errors.New("hex number with leading zero digits")
	ErrBig256Range      = errors.New("hex number > 256 bits")
	ErrBadBufferLength  = errors.New("bad ssz buffer length")
	ErrBadEncodedLength = errors.New("bad ssz encoded length")
)

Functions

func Reciprocal 

func Reciprocal(m *Int) (mu [5]uint64)

Reciprocal computes a 320-bit value representing 1/m

Notes: - specialized for m[3] != 0, hence limited to 2^192 <= m < 2^256 - returns zero if m[3] == 0 - starts with a 32-bit division, refines with newton-raphson iterations

Types

type Int 

type Int [4]uint64

Int is represented as an array of 4 uint64, in little-endian order, so that Int[3] is the most significant, and Int[0] is the least significant

func FromBig 

func FromBig(b *big.Int) (*Int, bool)

FromBig is a convenience-constructor from big.Int. Returns a new Int and whether overflow occurred. OBS: If b is `nil`, this method returns `nil, false`

func FromDecimal 

func FromDecimal(decimal string) (*Int, error)

FromDecimal is a convenience-constructor to create an Int from a decimal (base 10) string. Numbers larger than 256 bits are not accepted.

func FromHex 

func FromHex(hex string) (*Int, error)

FromHex is a convenience-constructor to create an Int from a hexadecimal string. The string is required to be '0x'-prefixed Numbers larger than 256 bits are not accepted.

func MustFromBig 

func MustFromBig(b *big.Int) *Int

MustFromBig is a convenience-constructor from big.Int. Returns a new Int and panics if overflow occurred. OBS: If b is `nil`, this method does _not_ panic, but instead returns `nil`

func MustFromDecimal 

func MustFromDecimal(decimal string) *Int

MustFromDecimal is a convenience-constructor to create an Int from a decimal (base 10) string. Returns a new Int and panics if any error occurred.

func MustFromHex 

func MustFromHex(hex string) *Int

MustFromHex is a convenience-constructor to create an Int from a hexadecimal string. Returns a new Int and panics if any error occurred.

func NewInt 

func NewInt(val uint64) *Int

NewInt returns a new initialized Int.

func (*Int) Abs 

func (z *Int) Abs(x *Int) *Int

Abs interprets x as a two's complement signed number, and sets z to the absolute value 

Abs(0)        = 0
Abs(1)        = 1
Abs(2**255)   = -2**255
Abs(2**256-1) = -1

func (*Int) Add 

func (z *Int) Add(x, y *Int) *Int

Add sets z to the sum x+y

func (*Int) AddMod 

func (z *Int) AddMod(x, y, m *Int) *Int

AddMod sets z to the sum ( x+y ) mod m, and returns z. If m == 0, z is set to 0 (OBS: differs from the big.Int)

func (*Int) AddOverflow 

func (z *Int) AddOverflow(x, y *Int) (*Int, bool)

AddOverflow sets z to the sum x+y, and returns z and whether overflow occurred

func (*Int) AddUint64 

func (z *Int) AddUint64(x *Int, y uint64) *Int

AddUint64 sets z to x + y, where y is a uint64, and returns z

func (*Int) And 

func (z *Int) And(x, y *Int) *Int

And sets z = x & y and returns z.

func (*Int) BitLen 

func (z *Int) BitLen() int

BitLen returns the number of bits required to represent z

func (*Int) Byte 

func (z *Int) Byte(n *Int) *Int

Byte sets z to the value of the byte at position n, with 'z' considered as a big-endian 32-byte integer if 'n' > 32, f is set to 0 Example: f = '5', n=31 => 5

func (*Int) ByteLen 

func (z *Int) ByteLen() int

ByteLen returns the number of bytes required to represent z

func (*Int) Bytes 

func (z *Int) Bytes() []byte

Bytes returns the value of z as a big-endian byte slice.

func (*Int) Bytes20 

func (z *Int) Bytes20() [20]byte

Bytes20 returns the value of z as a 20-byte big-endian array.

func (*Int) Bytes32 

func (z *Int) Bytes32() [32]byte

Bytes32 returns the value of z as a 32-byte big-endian array.

func (*Int) Clear 

func (z *Int) Clear() *Int

Clear sets z to 0

func (*Int) Clone 

func (z *Int) Clone() *Int

Clone creates a new Int identical to z

func (*Int) Cmp 

func (z *Int) Cmp(x *Int) (r int)

Cmp compares z and x and returns: 

-1 if z <  x
 0 if z == x
+1 if z >  x

func (*Int) CmpBig 

func (z *Int) CmpBig(x *big.Int) (r int)

CmpBig compares z and x and returns: 

-1 if z <  x
 0 if z == x
+1 if z >  x

func (*Int) CmpUint64 

func (z *Int) CmpUint64(x uint64) int

CmpUint64 compares z and x and returns: 

-1 if z <  x
 0 if z == x
+1 if z >  x

func (*Int) Dec 

func (z *Int) Dec() string

Dec returns the decimal representation of z.

func (*Int) Div 

func (z *Int) Div(x, y *Int) *Int

Div sets z to the quotient x/y for returns z. If y == 0, z is set to 0

func (*Int) DivMod 

func (z *Int) DivMod(x, y, m *Int) (*Int, *Int)

DivMod sets z to the quotient x div y and m to the modulus x mod y and returns the pair (z, m) for y != 0. If y == 0, both z and m are set to 0 (OBS: differs from the big.Int)

func (*Int) EncodeRLP 

func (z *Int) EncodeRLP(w io.Writer) error

EncodeRLP implements the rlp.Encoder interface from go-ethereum and writes the RLP encoding of z to w.

func (*Int) Eq 

func (z *Int) Eq(x *Int) bool

Eq returns true if z == x

func (*Int) Exp 

func (z *Int) Exp(base, exponent *Int) *Int

Exp sets z = base**exponent mod 2**256, and returns z.

func (*Int) ExtendSign 

func (z *Int) ExtendSign(x, byteNum *Int) *Int

ExtendSign extends length of two’s complement signed integer, sets z to

  • x if byteNum > 31
  • x interpreted as a signed number with sign-bit at (byteNum*8+7), extended to the full 256 bits

and returns z.

func (*Int) Float64 

func (z *Int) Float64() float64

Float64 returns the float64 value nearest to x.

Note: The `big.Float` version of `Float64` also returns an 'Accuracy', indicating whether the value was too small or too large to be represented by a `float64`. However, the `uint256` type is unable to represent values out of scope (|x| < math.SmallestNonzeroFloat64 or |x| > math.MaxFloat64), therefore this method does not return any accuracy.

func (*Int) Format 

func (z *Int) Format(s fmt.State, ch rune)

Format implements fmt.Formatter. It accepts the formats 'b' (binary), 'o' (octal with 0 prefix), 'O' (octal with 0o prefix), 'd' (decimal), 'x' (lowercase hexadecimal), and 'X' (uppercase hexadecimal). Also supported are the full suite of package fmt's format flags for integral types, including '+' and ' ' for sign control, '#' for leading zero in octal and for hexadecimal, a leading "0x" or "0X" for "%#x" and "%#X" respectively, specification of minimum digits precision, output field width, space or zero padding, and '-' for left or right justification.

func (*Int) Gt 

func (z *Int) Gt(x *Int) bool

Gt returns true if z > x

func (*Int) GtUint64 

func (z *Int) GtUint64(n uint64) bool

GtUint64 returns true if z is larger than n

func (*Int) HashTreeRoot 

func (z *Int) HashTreeRoot() ([32]byte, error)

HashTreeRoot implements the fastssz.HashRoot interface's non-dependent part.

func (*Int) Hex 

func (z *Int) Hex() string

Hex encodes z in 0x-prefixed hexadecimal form.

func (*Int) IsUint64 

func (z *Int) IsUint64() bool

IsUint64 reports whether z can be represented as a uint64.

func (*Int) IsZero 

func (z *Int) IsZero() bool

IsZero returns true if z == 0

func (*Int) Log10 

func (z *Int) Log10() uint

Log10 returns the log in base 10, floored to nearest integer. **OBS** This method returns '0' for '0', not `-Inf`.

func (*Int) Lsh 

func (z *Int) Lsh(x *Int, n uint) *Int

Lsh sets z = x << n and returns z.

func (*Int) Lt 

func (z *Int) Lt(x *Int) bool

Lt returns true if z < x

func (*Int) LtUint64 

func (z *Int) LtUint64(n uint64) bool

LtUint64 returns true if z is smaller than n

func (*Int) MarshalJSON 

func (z *Int) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler.

func (*Int) MarshalSSZ 

func (z *Int) MarshalSSZ() ([]byte, error)

MarshalSSZ implements the fastssz.Marshaler interface and returns the integer marshalled into a newly allocated byte slice.

func (*Int) MarshalSSZTo 

func (z *Int) MarshalSSZTo(dst []byte) ([]byte, error)

MarshalSSZTo implements the fastssz.Marshaler interface and serializes the integer into an already pre-allocated buffer.

func (*Int) MarshalText 

func (z *Int) MarshalText() ([]byte, error)

MarshalText implements encoding.TextMarshaler

func (*Int) Mod 

func (z *Int) Mod(x, y *Int) *Int

Mod sets z to the modulus x%y for y != 0 and returns z. If y == 0, z is set to 0 (OBS: differs from the big.Int)

func (*Int) Mul 

func (z *Int) Mul(x, y *Int) *Int

Mul sets z to the product x*y

func (*Int) MulDivOverflow 

func (z *Int) MulDivOverflow(x, y, d *Int) (*Int, bool)

MulDivOverflow calculates (x*y)/d with full precision, returns z and whether overflow occurred in multiply process (result does not fit to 256-bit). computes 512-bit multiplication and 512 by 256 division.

func (*Int) MulMod 

func (z *Int) MulMod(x, y, m *Int) *Int

MulMod calculates the modulo-m multiplication of x and y and returns z. If m == 0, z is set to 0 (OBS: differs from the big.Int)

func (*Int) MulModWithReciprocal 

func (z *Int) MulModWithReciprocal(x, y, m *Int, mu *[5]uint64) *Int

MulModWithReciprocal calculates the modulo-m multiplication of x and y and returns z, using the reciprocal of m provided as the mu parameter. Use uint256.Reciprocal to calculate mu from m. If m == 0, z is set to 0 (OBS: differs from the big.Int)

func (*Int) MulOverflow 

func (z *Int) MulOverflow(x, y *Int) (*Int, bool)

MulOverflow sets z to the product x*y, and returns z and whether overflow occurred

func (*Int) Neg 

func (z *Int) Neg(x *Int) *Int

Neg returns -x mod 2**256.

func (*Int) Not 

func (z *Int) Not(x *Int) *Int

Not sets z = ^x and returns z.

func (*Int) Or 

func (z *Int) Or(x, y *Int) *Int

Or sets z = x | y and returns z.

func (*Int) PaddedBytes 

func (z *Int) PaddedBytes(n int) []byte

PaddedBytes encodes a Int as a 0-padded byte slice. The length of the slice is at least n bytes. Example, z =1, n = 20 => [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]

func (*Int) PrettyDec 

func (z *Int) PrettyDec(separator byte) string

PrettyDec returns the decimal representation of z, with thousands-separators.

func (*Int) Rsh 

func (z *Int) Rsh(x *Int, n uint) *Int

Rsh sets z = x >> n and returns z.

func (*Int) SDiv 

func (z *Int) SDiv(n, d *Int) *Int

SDiv interprets n and d as two's complement signed integers, does a signed division on the two operands and sets z to the result. If d == 0, z is set to 0

func (*Int) SMod 

func (z *Int) SMod(x, y *Int) *Int

SMod interprets x and y as two's complement signed integers, sets z to (sign x) * { abs(x) modulus abs(y) } If y == 0, z is set to 0 (OBS: differs from the big.Int)

func (*Int) SRsh 

func (z *Int) SRsh(x *Int, n uint) *Int

SRsh (Signed/Arithmetic right shift) considers z to be a signed integer, during right-shift and sets z = x >> n and returns z.

func (*Int) Scan 

func (dst *Int) Scan(src interface{}) error

Scan implements the database/sql Scanner interface. It decodes a string, because that is what postgres uses for its numeric type

func (*Int) Set 

func (z *Int) Set(x *Int) *Int

Set sets z to x and returns z.

func (*Int) SetAllOne 

func (z *Int) SetAllOne() *Int

SetAllOne sets all the bits of z to 1

func (*Int) SetBytes 

func (z *Int) SetBytes(buf []byte) *Int

SetBytes interprets buf as the bytes of a big-endian unsigned integer, sets z to that value, and returns z. If buf is larger than 32 bytes, the last 32 bytes is used. This operation is semantically equivalent to `FromBig(new(big.Int).SetBytes(buf))`

func (*Int) SetBytes1 

func (z *Int) SetBytes1(in []byte) *Int

func (*Int) SetBytes10 

func (z *Int) SetBytes10(in []byte) *Int

func (*Int) SetBytes11 

func (z *Int) SetBytes11(in []byte) *Int

func (*Int) SetBytes12 

func (z *Int) SetBytes12(in []byte) *Int

func (*Int) SetBytes13 

func (z *Int) SetBytes13(in []byte) *Int

func (*Int) SetBytes14 

func (z *Int) SetBytes14(in []byte) *Int

func (*Int) SetBytes15 

func (z *Int) SetBytes15(in []byte) *Int

func (*Int) SetBytes16 

func (z *Int) SetBytes16(in []byte) *Int

SetBytes16 is identical to SetBytes(in[:16]), but panics is input is too short

func (*Int) SetBytes17 

func (z *Int) SetBytes17(in []byte) *Int

func (*Int) SetBytes18 

func (z *Int) SetBytes18(in []byte) *Int

func (*Int) SetBytes19 

func (z *Int) SetBytes19(in []byte) *Int

func (*Int) SetBytes2 

func (z *Int) SetBytes2(in []byte) *Int

func (*Int) SetBytes20 

func (z *Int) SetBytes20(in []byte) *Int

func (*Int) SetBytes21 

func (z *Int) SetBytes21(in []byte) *Int

func (*Int) SetBytes22 

func (z *Int) SetBytes22(in []byte) *Int

func (*Int) SetBytes23 

func (z *Int) SetBytes23(in []byte) *Int

func (*Int) SetBytes24 

func (z *Int) SetBytes24(in []byte) *Int

SetBytes16 is identical to SetBytes(in[:24]), but panics is input is too short

func (*Int) SetBytes25 

func (z *Int) SetBytes25(in []byte) *Int

func (*Int) SetBytes26 

func (z *Int) SetBytes26(in []byte) *Int

func (*Int) SetBytes27 

func (z *Int) SetBytes27(in []byte) *Int

func (*Int) SetBytes28 

func (z *Int) SetBytes28(in []byte) *Int

func (*Int) SetBytes29 

func (z *Int) SetBytes29(in []byte) *Int

func (*Int) SetBytes3 

func (z *Int) SetBytes3(in []byte) *Int

func (*Int) SetBytes30 

func (z *Int) SetBytes30(in []byte) *Int

func (*Int) SetBytes31 

func (z *Int) SetBytes31(in []byte) *Int

func (*Int) SetBytes32 

func (z *Int) SetBytes32(in []byte) *Int

func (*Int) SetBytes4 

func (z *Int) SetBytes4(in []byte) *Int

func (*Int) SetBytes5 

func (z *Int) SetBytes5(in []byte) *Int

func (*Int) SetBytes6 

func (z *Int) SetBytes6(in []byte) *Int

func (*Int) SetBytes7 

func (z *Int) SetBytes7(in []byte) *Int

func (*Int) SetBytes8 

func (z *Int) SetBytes8(in []byte) *Int

SetBytes8 is identical to SetBytes(in[:8]), but panics is input is too short

func (*Int) SetBytes9 

func (z *Int) SetBytes9(in []byte) *Int

func (*Int) SetFromBig 

func (z *Int) SetFromBig(b *big.Int) bool

SetFromBig converts a big.Int to Int and sets the value to z. TODO: Ensure we have sufficient testing, esp for negative bigints.

func (*Int) SetFromDecimal 

func (z *Int) SetFromDecimal(s string) (err error)

SetFromDecimal sets z from the given string, interpreted as a decimal number. OBS! This method is _not_ strictly identical to the (*big.Int).SetString(..., 10) method. Notable differences: - This method does not accept underscore input, e.g. "100_000", - This method does not accept negative zero as valid, e.g "-0",

  • (this method does not accept any negative input as valid))

func (*Int) SetFromHex 

func (z *Int) SetFromHex(hex string) error

SetFromHex sets z from the given string, interpreted as a hexadecimal number. OBS! This method is _not_ strictly identical to the (*big.Int).SetString(..., 16) method. Notable differences: - This method _require_ "0x" or "0X" prefix. - This method does not accept zero-prefixed hex, e.g. "0x0001" - This method does not accept underscore input, e.g. "100_000", - This method does not accept negative zero as valid, e.g "-0x0",

  • (this method does not accept any negative input as valid)

func (*Int) SetOne 

func (z *Int) SetOne() *Int

SetOne sets z to 1

func (*Int) SetUint64 

func (z *Int) SetUint64(x uint64) *Int

SetUint64 sets z to the value x

func (*Int) Sgt 

func (z *Int) Sgt(x *Int) bool

Sgt interprets z and x as signed integers, and returns true if z > x

func (*Int) Sign 

func (z *Int) Sign() int

Sign returns: 

-1 if z <  0
 0 if z == 0
+1 if z >  0

Where z is interpreted as a two's complement signed number

func (*Int) SizeSSZ 

func (*Int) SizeSSZ() int

SizeSSZ implements the fastssz.Marshaler interface and returns the byte size of the 256 bit int.

func (*Int) Slt 

func (z *Int) Slt(x *Int) bool

Slt interprets z and x as signed integers, and returns true if z < x

func (*Int) Sqrt 

func (z *Int) Sqrt(x *Int) *Int

Sqrt sets z to ⌊√x⌋, the largest integer such that z² ≤ x, and returns z.

func (*Int) String 

func (z *Int) String() string

String returns the hex encoding of b.

func (*Int) Sub 

func (z *Int) Sub(x, y *Int) *Int

Sub sets z to the difference x-y

func (*Int) SubOverflow 

func (z *Int) SubOverflow(x, y *Int) (*Int, bool)

SubOverflow sets z to the difference x-y and returns z and true if the operation underflowed

func (*Int) SubUint64 

func (z *Int) SubUint64(x *Int, y uint64) *Int

SubUint64 set z to the difference x - y, where y is a uint64, and returns z

func (*Int) ToBig 

func (z *Int) ToBig() *big.Int

ToBig returns a big.Int version of z. Return `nil` if z is nil

func (*Int) Uint64 

func (z *Int) Uint64() uint64

Uint64 returns the lower 64-bits of z

func (*Int) Uint64WithOverflow 

func (z *Int) Uint64WithOverflow() (uint64, bool)

Uint64WithOverflow returns the lower 64-bits of z and bool whether overflow occurred

func (*Int) UnmarshalJSON 

func (z *Int) UnmarshalJSON(input []byte) error

UnmarshalJSON implements json.Unmarshaler. Improvement: Unmarshal for int field, string of decimal.

func (*Int) UnmarshalSSZ 

func (z *Int) UnmarshalSSZ(buf []byte) error

UnmarshalSSZ implements the fastssz.Unmarshaler interface and parses an encoded integer into the local struct.

func (*Int) UnmarshalText 

func (z *Int) UnmarshalText(input []byte) error

UnmarshalText implements encoding.TextUnmarshaler

func (*Int) Value 

func (src *Int) Value() (driver.Value, error)

Value implements the database/sql/driver Valuer interface. It encodes a base 10 string. In Postgres, this will work with both integer and the Numeric/Decimal types In MariaDB/MySQL, this will work with the Numeric/Decimal types up to 65 digits, however any more and you should use either VarChar or Char(79) In SqLite, use TEXT

func (*Int) WriteToArray20 

func (z *Int) WriteToArray20(dest *[20]byte)

WriteToArray20 writes the last 20 bytes of z to the destination array, including zero-bytes

func (*Int) WriteToArray32 

func (z *Int) WriteToArray32(dest *[32]byte)

WriteToArray32 writes all 32 bytes of z to the destination array, including zero-bytes

func (*Int) WriteToSlice 

func (z *Int) WriteToSlice(dest []byte)

WriteToSlice writes the content of z into the given byteslice. If dest is larger than 32 bytes, z will fill the first parts, and leave the end untouched. OBS! If dest is smaller than 32 bytes, only the end parts of z will be used for filling the array, making it useful for filling an Address object

func (*Int) Xor 

func (z *Int) Xor(x, y *Int) *Int

Xor sets z = x ^ y and returns z.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.