go-ethereum: github.com/ethereum/go-ethereum/common/math

## package math

`import "github.com/ethereum/go-ethereum/common/math"`

Package math provides integer math utilities.

### Constants ¶

```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 ¶

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

Various big integer limit values.

### func BigMax¶Uses

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

BigMax returns the larger of x or y.

### func BigMin¶Uses

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

BigMin returns the smaller of x or y.

### func BigPow¶Uses

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

BigPow returns a ** b as a big integer.

### func Byte¶Uses

`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¶Uses

`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¶Uses

`func FirstBitSet(v *big.Int) int`

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

### func MustParseBig256¶Uses

`func MustParseBig256(s string) *big.Int`

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

### func MustParseUint64¶Uses

`func MustParseUint64(s string) uint64`

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

`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¶Uses

`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¶Uses

`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(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¶Uses

`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(x, y uint64) (uint64, bool)`

SafeAdd returns x+y and checks for overflow.

### func SafeMul¶Uses

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

SafeMul returns x*y and checks for overflow.

### func SafeSub¶Uses

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

SafeSub returns x-y and checks for overflow.

### func U256¶Uses

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

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

### func U256Bytes¶Uses

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

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

### type Decimal256¶Uses

`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¶Uses

`func NewDecimal256(x int64) *Decimal256`

NewHexOrDecimal256 creates a new Decimal256

#### func (*Decimal256) MarshalText¶Uses

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

MarshalText implements encoding.TextMarshaler.

#### func (*Decimal256) String¶Uses

`func (i *Decimal256) String() string`

String implements Stringer.

#### func (*Decimal256) UnmarshalText¶Uses

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

UnmarshalText implements encoding.TextUnmarshaler.

### type HexOrDecimal256¶Uses

`type HexOrDecimal256 big.Int`

HexOrDecimal256 marshals big.Int as hex or decimal.

#### func NewHexOrDecimal256¶Uses

`func NewHexOrDecimal256(x int64) *HexOrDecimal256`

NewHexOrDecimal256 creates a new HexOrDecimal256

#### func (*HexOrDecimal256) MarshalText¶Uses

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

MarshalText implements encoding.TextMarshaler.

#### func (*HexOrDecimal256) UnmarshalText¶Uses

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

UnmarshalText implements encoding.TextUnmarshaler.

### type HexOrDecimal64¶Uses

`type HexOrDecimal64 uint64`

HexOrDecimal64 marshals uint64 as hex or decimal.

#### func (HexOrDecimal64) MarshalText¶Uses

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

MarshalText implements encoding.TextMarshaler.

#### func (*HexOrDecimal64) UnmarshalText¶Uses

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

UnmarshalText implements encoding.TextUnmarshaler.

Package math imports 4 packages (graph) and is imported by 2218 packages. Updated 2020-09-29. Refresh now. Tools for package owners.