Documentation

Overview

    Package math provides integer math utilities.

    Index

    Constants

    View Source
    const (
    	MaxInt8   = 1<<7 - 1
    	MinInt8   = -1 << 7
    	MaxInt16  = 1<<15 - 1
    	MinInt16  = -1 << 15
    	MaxInt32  = 1<<31 - 1
    	MinInt32  = -1 << 31
    	MaxInt64  = 1<<63 - 1
    	MinInt64  = -1 << 63
    	MaxUint8  = 1<<8 - 1
    	MaxUint16 = 1<<16 - 1
    	MaxUint32 = 1<<32 - 1
    	MaxUint64 = 1<<64 - 1
    )

      Integer limit values.

      Variables

      View Source
      var (
      	MaxBig256 = new(big.Int).Set(tt256m1)
      	MaxBig63  = new(big.Int).Sub(tt63, big.NewInt(1))
      )

        Various big integer limit values.

        Functions

        func BigMax

        func BigMax(x, y *big.Int) *big.Int

          BigMax returns the larger of x or y.

          func BigMin

          func BigMin(x, y *big.Int) *big.Int

            BigMin returns the smaller of x or y.

            func BigPow

            func BigPow(a, b int64) *big.Int

              BigPow returns a ** b as a big integer.

              func Byte

              func Byte(bigint *big.Int, padlength, n int) byte

                Byte returns the byte at position n, with the supplied padlength in Little-Endian encoding. n==0 returns the MSB Example: bigint '5', padlength 32, n=31 => 5

                func Exp

                func Exp(base, exponent *big.Int) *big.Int

                  Exp implements exponentiation by squaring. Exp returns a newly-allocated big integer and does not change base or exponent. The result is truncated to 256 bits.

                  Courtesy @karalabe and @chfast

                  func FirstBitSet

                  func FirstBitSet(v *big.Int) int

                    FirstBitSet returns the index of the first 1 bit in v, counting from LSB.

                    func MustParseBig256

                    func MustParseBig256(s string) *big.Int

                      MustParseBig256 parses s as a 256 bit big integer and panics if the string is invalid.

                      func MustParseUint64

                      func MustParseUint64(s string) uint64

                        MustParseUint64 parses s as an integer and panics if the string is invalid.

                        func PaddedBigBytes

                        func PaddedBigBytes(bigint *big.Int, n int) []byte

                          PaddedBigBytes encodes a big integer as a big-endian byte slice. The length of the slice is at least n bytes.

                          func ParseBig256

                          func ParseBig256(s string) (*big.Int, bool)

                            ParseBig256 parses s as a 256 bit integer in decimal or hexadecimal syntax. Leading zeros are accepted. The empty string parses as zero.

                            func ParseUint64

                            func ParseUint64(s string) (uint64, bool)

                              ParseUint64 parses s as an integer in decimal or hexadecimal syntax. Leading zeros are accepted. The empty string parses as zero.

                              func ReadBits

                              func ReadBits(bigint *big.Int, buf []byte)

                                ReadBits encodes the absolute value of bigint as big-endian bytes. Callers must ensure that buf has enough space. If buf is too short the result will be incomplete.

                                func S256

                                func S256(x *big.Int) *big.Int

                                  S256 interprets x as a two's complement number. x must not exceed 256 bits (the result is undefined if it does) and is not modified.

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

                                  func SafeAdd

                                  func SafeAdd(x, y uint64) (uint64, bool)

                                    SafeAdd returns x+y and checks for overflow.

                                    func SafeMul

                                    func SafeMul(x, y uint64) (uint64, bool)

                                      SafeMul returns x*y and checks for overflow.

                                      func SafeSub

                                      func SafeSub(x, y uint64) (uint64, bool)

                                        SafeSub returns x-y and checks for overflow.

                                        func U256

                                        func U256(x *big.Int) *big.Int

                                          U256 encodes as a 256 bit two's complement number. This operation is destructive.

                                          func U256Bytes

                                          func U256Bytes(n *big.Int) []byte

                                            U256Bytes converts a big Int into a 256bit EVM number. This operation is destructive.

                                            Types

                                            type Decimal256

                                            type Decimal256 big.Int

                                              Decimal256 unmarshals big.Int as a decimal string. When unmarshalling, it however accepts either "0x"-prefixed (hex encoded) or non-prefixed (decimal)

                                              func NewDecimal256

                                              func NewDecimal256(x int64) *Decimal256

                                                NewHexOrDecimal256 creates a new Decimal256

                                                func (*Decimal256) MarshalText

                                                func (i *Decimal256) MarshalText() ([]byte, error)

                                                  MarshalText implements encoding.TextMarshaler.

                                                  func (*Decimal256) String

                                                  func (i *Decimal256) String() string

                                                    String implements Stringer.

                                                    func (*Decimal256) UnmarshalText

                                                    func (i *Decimal256) UnmarshalText(input []byte) error

                                                      UnmarshalText implements encoding.TextUnmarshaler.

                                                      type HexOrDecimal256

                                                      type HexOrDecimal256 big.Int

                                                        HexOrDecimal256 marshals big.Int as hex or decimal.

                                                        func NewHexOrDecimal256

                                                        func NewHexOrDecimal256(x int64) *HexOrDecimal256

                                                          NewHexOrDecimal256 creates a new HexOrDecimal256

                                                          func (*HexOrDecimal256) MarshalText

                                                          func (i *HexOrDecimal256) MarshalText() ([]byte, error)

                                                            MarshalText implements encoding.TextMarshaler.

                                                            func (*HexOrDecimal256) UnmarshalText

                                                            func (i *HexOrDecimal256) UnmarshalText(input []byte) error

                                                              UnmarshalText implements encoding.TextUnmarshaler.

                                                              type HexOrDecimal64

                                                              type HexOrDecimal64 uint64

                                                                HexOrDecimal64 marshals uint64 as hex or decimal.

                                                                func (HexOrDecimal64) MarshalText

                                                                func (i HexOrDecimal64) MarshalText() ([]byte, error)

                                                                  MarshalText implements encoding.TextMarshaler.

                                                                  func (*HexOrDecimal64) UnmarshalText

                                                                  func (i *HexOrDecimal64) UnmarshalText(input []byte) error

                                                                    UnmarshalText implements encoding.TextUnmarshaler.

                                                                    Source Files