simplebig

package module
v0.0.0-...-5e4b4f5 Latest Latest
Warning

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

 Go to latest Published: Mar 7, 2025 License: MIT Imports: 6 Imported by: 0

README

simplebig

simplebig is a wrapper around math/big built-in package and main goal is convient to use math/big.

Why?

trying to solve these with simple wrapper around math/big:

  • no need to pass first parameter in most functions:
numb := simplebig.NewInt(12).Add(simplebig.NewInt(13))
fmt.Println(numb) // 25
  • return new value for most methods instead of modify original value, it's thread-safe:
numb := simplebig.NewInt(12)
reuslt := numb.Sub(simplebig.NewInt(13))
fmt.Println(numb, result) // 12 -1

  • sql.Scanner and sql/driver.Valuer interfaces are implemented, Int and Float can be used directly for databases.

  • some helpers for convient like Pow or converting functions between simplebig.Float and simplebig.Int are added.

  • method chaining:

x := simplebig.NewInt(2)
result := x.Add(simplebig.NewInt(13)).Sub(simplebig.NewInt(5)).Mul(simplebig.NewInt(2)).Pow(simplebig.NewInt(3))
fmt.Println(result, x) // 8000 2
  • it's only a wrapper, so it does whatever math/big do and it's accurate as math/big is accurate.

Example

x := simplebig.NewInt(2).Add(simplebig.NewInt(-5)).Mul(simplebig.NewInt(-1))

// get copy of underlying big.Int
x.BigInt()

fmt.Println(x, x.BigInt())

// safe to use in gorm models
type User struct {
    Name string
    Balance simepleint.Int
}

Database Compatibile and Break Changes:

simplebig.Int implements two interface to compatibile types with using in databases, but this changes breaks one feature and only this one from math/big. math/big.Int implements fmt.Scanner but simplebig.Int implements sql.Scanner. due to conflict in names of these two interfaces, I decided to choose one of them which is database compatibility. because there is a workaround for fmt.Scanner but there is no workaround for database compatibility.

Todos

  • implement wrapper for ModInverse and ModSqrt on simplebig.Int
  • implement wrapper for math/big.Float
  • implement wrapper for math/big.Rat

LICENSE

MIT

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Jacobi 

func Jacobi(x, y Int) int

Jacobi returns the Jacobi symbol (x/y), either +1, -1, or 0. The y argument must be an odd integer.

Types

type Float 

type Float struct {
	// contains filtered or unexported fields
}

A nonzero finite Float represents a multi-precision floating point number 

sign × mantissa × 2**exponent

with 0.5 <= mantissa < 1.0, and MinExp <= exponent <= MaxExp. A Float may also be zero (+0, -0) or infinite (+Inf, -Inf). All Floats are ordered, and the ordering of two Floats x and y is defined by x.Cmp(y).

Each Float value also has a precision, rounding mode, and accuracy. The precision is the maximum number of mantissa bits available to represent the value. The rounding mode specifies how a result should be rounded to fit into the mantissa bits, and accuracy describes the rounding error with respect to the exact result.

Unless specified otherwise, all operations (including setters) that specify a *Float variable for the result (usually via the receiver with the exception of MantExp), round the numeric result according to the precision and rounding mode of the result variable.

If the provided result precision is 0 (see below), it is set to the precision of the argument with the largest precision value before any rounding takes place, and the rounding mode remains unchanged. Thus, uninitialized Floats provided as result arguments will have their precision set to a reasonable value determined by the operands, and their mode is the zero value for RoundingMode (ToNearestEven).

By setting the desired precision to 24 or 53 and using matching rounding mode (typically ToNearestEven), Float operations produce the same results as the corresponding float32 or float64 IEEE-754 arithmetic for operands that correspond to normal (i.e., not denormal) float32 or float64 numbers. Exponent underflow and overflow lead to a 0 or an Infinity for different values than IEEE-754 because Float exponents have a much larger range.

The zero (uninitialized) value for a Float is ready to use and represents the number +0.0 exactly, with precision 0 and rounding mode ToNearestEven.

Operations always take pointer arguments (*Float) rather than Float values, and each unique Float value requires its own unique *Float pointer. To "copy" a Float value, an existing (or newly allocated) Float must be set to a new value using the Float.Set method; shallow copies of Floats are not supported and may lead to errors.

func NewFloat 

func NewFloat(x float64) Float

NewFloat allocates and returns a new Float sets to x.

func NewFloatFromBigFloat 

func NewFloatFromBigFloat(x *big.Float) Float

NewFloatFromBigFloat allocates a new Float sets to x.

func NewFloatFromString 

func NewFloatFromString(s string, base int) (Float, error)

NewIntFromString allocates and returns new Float and a boolean indicating of success.

func (Float) Abs 

func (x Float) Abs() Float

Abs returns the (possibly rounded) value |x| (the absolute value of x)

func (Float) Acc 

func (x Float) Acc() big.Accuracy

Acc returns the accuracy of x produced by the most recent operation, unless explicitly documented otherwise by that operation.

func (Float) Add 

func (x Float) Add(y Float) Float

Add returns the rounded sum x+y. If x's precision is 0, it is changed to the larger of x's or y's precision before the operation. Rounding is performed according to x's precision and rounding mode; and x's accuracy reports the result error relative to the exact (not rounded) result. Add panics with ErrNaN if x and y are infinities with opposite signs. The value of z is undefined in that case.

func (Float) Append 

func (x Float) Append(buf []byte, fmt byte, prec int) []byte

Append appends to buf the string form of the floating-point number x, as generated by x.Text, and returns the extended buffer.

func (Float) BigFloat 

func (x Float) BigFloat() *big.Float

BigFloat returns copy of underlying big.Float

func (Float) Cmp 

func (x Float) Cmp(y Float) int

Cmp compares x and y and returns: 

-1 if x <  y
 0 if x == y (incl. -0 == 0, -Inf == -Inf, and +Inf == +Inf)
+1 if x >  y

func (*Float) Copy 

func (x *Float) Copy(y Float) *Float

Copy sets x to y, with the same precision, rounding mode, and accuracy as x, and returns x. y is not changed even if x and y are the same.

func (Float) Float32 

func (x Float) Float32() (float32, big.Accuracy)

Float32 returns the float32 value nearest to x. If x is too small to be represented by a float32 (|x| < math.SmallestNonzeroFloat32), the result is (0, Below) or (-0, Above), respectively, depending on the sign of x. If x is too large to be represented by a float32 (|x| > math.MaxFloat32), the result is (+Inf, Above) or (-Inf, Below), depending on the sign of x.

func (Float) Float64 

func (x Float) Float64() (float64, big.Accuracy)

Float64 returns the float64 value nearest to x. If x is too small to be represented by a float64 (|x| < math.SmallestNonzeroFloat64), the result is (0, Below) or (-0, Above), respectively, depending on the sign of x. If x is too large to be represented by a float64 (|x| > math.MaxFloat64), the result is (+Inf, Above) or (-Inf, Below), depending on the sign of x.

func (*Float) Format 

func (x *Float) Format(s fmt.State, format rune)

Format implements fmt.Formatter. It accepts all the regular formats for floating-point numbers ('b', 'e', 'E', 'f', 'F', 'g', 'G', 'x') as well as 'p' and 'v'. See (*Float).Text for the interpretation of 'p'. The 'v' format is handled like 'g'. Format also supports specification of the minimum precision in digits, the output field width, as well as the format flags '+' and ' ' for sign control, '0' for space or zero padding, and '-' for left or right justification. See the fmt package for details.

func (*Float) GobDecode 

func (x *Float) GobDecode(buf []byte) error

GobDecode implements the gob.GobDecoder interface. The result is rounded per the precision and rounding mode of z unless z's precision is 0, in which case z is set exactly to the decoded value.

func (*Float) GobEncode 

func (x *Float) GobEncode() ([]byte, error)

GobEncode implements the gob.GobEncoder interface. The Float value and all its attributes (precision, rounding mode, accuracy) are marshaled.

func (Float) Int 

func (x Float) Int() (Int, big.Accuracy)

Int returns the result of truncating x towards zero; or nil if x is an infinity. The result is Exact if x.IsInt(); otherwise it is Below for x > 0, and Above for x < 0.

func (Float) Int64 

func (x Float) Int64() (int64, big.Accuracy)

Int64 returns the integer resulting from truncating x towards zero. If math.MinInt64 <= x <= math.MaxInt64, the result is Exact if x is an integer, and Above (x < 0) or Below (x > 0) otherwise. The result is (math.MinInt64, Above) for x < math.MinInt64, and (math.MaxInt64, Below) for x > math.MaxInt64.

func (Float) IsInf 

func (x Float) IsInf() bool

IsInf reports whether x is +Inf or -Inf.

func (Float) IsInt 

func (x Float) IsInt() bool

IsInt reports whether x is an integer. ±Inf values are not integers.

func (Float) MantExp 

func (x Float) MantExp(mant Float) int

MantExp breaks x into its mantissa and exponent components and returns the exponent. If a non-nil mant argument is provided its value is set to the mantissa of x, with the same precision and rounding mode as x. The components satisfy x == mant × 2**exp, with 0.5 <= |mant| < 1.0. Calling MantExp with a nil argument is an efficient way to get the exponent of the receiver.

Special cases are: 

(  ±0).MantExp(mant) = 0, with mant set to   ±0
(±Inf).MantExp(mant) = 0, with mant set to ±Inf

x and mant may be the same in which case x is set to its mantissa value.

func (*Float) MarshalText 

func (x *Float) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface. Only the Float value is marshaled (in full precision), other attributes such as precision or accuracy are ignored.

func (*Float) MinPrec 

func (x *Float) MinPrec() uint

MinPrec returns the minimum precision required to represent x exactly (i.e., the smallest prec before x.SetPrec(prec) would start rounding x). The result is 0 for |x| == 0 and |x| == Inf.

func (*Float) Mode 

func (x *Float) Mode() big.RoundingMode

Mode returns the rounding mode of x.

func (Float) Mul 

func (x Float) Mul(y Float) Float

Mul returns the rounded product x*y. Precision, rounding, and accuracy reporting are as for Add. Mul panics with ErrNaN if one operand is zero and the other operand an infinity. The value of z is undefined in that case.

func (Float) Neg 

func (x Float) Neg() Float

Neg returns the (possibly rounded) value of x with its sign negated,

func (Float) Parse 

func (x Float) Parse(s string, base int) (Float, int, error)

Parse parses s which must contain a text representation of a floating- point number with a mantissa in the given conversion base (the exponent is always a decimal number), or a string representing an infinite value. check math/big.Float.Parse for more inforamtions.

func (Float) Quo 

func (x Float) Quo(y Float) Float

Quo returns the rounded quotient x/y. Precision, rounding, and accuracy reporting are as for Add. Quo panics with ErrNaN if both operands are zero or infinities. The value of z is undefined in that case.

func (Float) Rat 

func (x Float) Rat(z *big.Rat) (*big.Rat, big.Accuracy)

Rat returns the rational number corresponding to x; or nil if x is an infinity. The result is Exact if x is not an Inf. If a non-nil *Rat argument z is provided, Rat stores the result in z instead of allocating a new Rat.

func (*Float) Scan 

func (x *Float) Scan(dbValue interface{}) error

Scan implements sql.Scanner interface.

func (*Float) Set 

func (x *Float) Set(y *Float) *Float

Set sets x to the (possibly rounded) value of y and returns x. If x's precision is 0, it is changed to the precision of y before setting x (and rounding will have no effect). Rounding is performed according to x's precision and rounding mode; and x's accuracy reports the result error relative to the exact (not rounded) result.

func (*Float) SetFloat64 

func (x *Float) SetFloat64(y float64) *Float

SetFloat64 sets x to the (possibly rounded) value of y and returns x. If x's precision is 0, it is changed to 53 (and rounding will have no effect). SetFloat64 panics with ErrNaN if x is a NaN.

func (*Float) SetInf 

func (x *Float) SetInf(signbit bool) *Float

SetInf sets x to the infinite Float -Inf if signbit is set, or +Inf if signbit is not set, and returns x. The precision of x is unchanged and the result is always Exact.

func (*Float) SetInt 

func (x *Float) SetInt(y *big.Int) *Float

SetInt sets x to the (possibly rounded) value of y and returns x. If x's precision is 0, it is changed to the larger of x.BitLen() or 64 (and rounding will have no effect).

func (*Float) SetInt64 

func (x *Float) SetInt64(y int64) *Float

SetInt64 sets x to the (possibly rounded) value of y and returns x. If x's precision is 0, it is changed to 64 (and rounding will have no effect).

func (Float) SetMantExp 

func (x Float) SetMantExp(mant Float, exp int) Float

SetMantExp returns mant × 2**exp and returns new Float. The result has the same precision and rounding mode as mant. SetMantExp is an inverse of MantExp but does not require 0.5 <= |mant| < 1.0. Specifically, for a given x of type *Float, SetMantExp relates to MantExp as follows: 

mant := new(Float)
new(Float).SetMantExp(mant, x.MantExp(mant)).Cmp(x) == 0

Special cases are: 

x.SetMantExp(  ±0, exp) =   ±0
x.SetMantExp(±Inf, exp) = ±Inf

x and mant may be the same in which case x's exponent is set to exp.

func (*Float) SetString 

func (x *Float) SetString(s string) (*Float, bool)

SetString sets x to the value of s and returns x and a boolean indicating success. s must be a floating-point number of the same format as accepted by Parse, with base argument 0. The entire string (not just a prefix) must be valid for success. If the operation failed, the value of x is undefined but the returned value is nil.

func (*Float) SetUint64 

func (x *Float) SetUint64(y uint64) *Float

SetUint64 sets x to the (possibly rounded) value of y and returns x. If x's precision is 0, it is changed to 64 (and rounding will have no effect).

func (Float) Sign 

func (x Float) Sign() int

Sign returns: 

-1 if x <   0
 0 if x is ±0
+1 if x >   0

func (Float) Signbit 

func (x Float) Signbit() bool

Signbit reports whether x is negative or negative zero.

func (*Float) String 

func (x *Float) String() string

String formats x like x.Text('g', 10).

func (Float) Sub 

func (x Float) Sub(y Float) Float

Sub returns the rounded difference x-y. Precision, rounding, and accuracy reporting are as for Add. Sub panics with ErrNaN if x and y are infinities with equal signs. The value of z is undefined in that case.

func (Float) Uint64 

func (x Float) Uint64() (uint64, big.Accuracy)

Uint64 returns the unsigned integer resulting from truncating x towards zero. If 0 <= x <= math.MaxUint64, the result is Exact if x is an integer and Below otherwise. The result is (0, Above) for x < 0, and (math.MaxUint64, Below) for x > math.MaxUint64.

func (Float) Value 

func (x Float) Value() (driver.Value, error)

Value implements sql/driver.Valuer interface.

type Int 

type Int struct {
	// contains filtered or unexported fields
}

An Int represents a signed multi-precision integer. The zero value for an Int represents the value 0.

Operations always take pointer arguments (*Int) rather than Int values, and each unique Int value requires its own unique *Int pointer. To "copy" an Int value, an existing (or newly allocated) Int must be set to a new value using the Int.Set method; shallow copies of Ints are not supported and may lead to errors.

func NewInt 

func NewInt(x int64) Int

NewInt allocates and returns a new Int set to x.

func NewIntFromBigInt 

func NewIntFromBigInt(x *big.Int) Int

NewIntFromBigInt allocates and returns new Int with value of x.

func NewIntFromFloat 

func NewIntFromFloat(x Float, decimals int) Int

NewIntFromFloat returns new Int set to int part of x which multiplied by 10**decimals

func NewIntFromString 

func NewIntFromString(s string, base int) (Int, bool)

NewIntFromString allocates and returns new Int and a boolean indicating of success.

func NewIntFromStringFloat 

func NewIntFromStringFloat(s string, decimals int) (Int, error)

NewIntFromStringFloat allocates and returns a Int with value of int part of s which multiplied by 10**decimals

func (Int) Abs 

func (x Int) Abs() Int

Abs returns the absolute value of x.

func (Int) Add 

func (x Int) Add(y Int) Int

Add returns sum x+y.

func (Int) And 

func (x Int) And(y Int) Int

And returns x & y.

func (Int) AndNot 

func (x Int) AndNot(y Int) Int

AndNot return x &^ y.

func (Int) Append 

func (x Int) Append(buf []byte, base int) []byte

func (Int) BigInt 

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

BigInt returns underlying bigInt it's a copy of BigInt so it's safe to modify or edit.

func (Int) Binomial 

func (n Int) Binomial(k int64) Int

Binomial returns the binomial coefficient of (n, k).

func (Int) Bit 

func (x Int) Bit(i int) uint

Bit returns the value of the i'th bit of x. That is, it returns (x>>i)&1. The bit index i must be >= 0.

func (Int) BitLen 

func (x Int) BitLen() int

BitLen returns the length of the absolute value of x in bits. The bit length of 0 is 0.

func (*Int) Bits 

func (x *Int) Bits() []big.Word

Bits provides raw (unchecked but fast) access to x by returning its absolute value as a little-endian Word slice. The result and x share the same underlying array. Bits is intended to support implementation of missing low-level Int functionality outside this package; it should be avoided otherwise.

func (Int) Bytes 

func (x Int) Bytes() []byte

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

To use a fixed length slice, or a preallocated one, use FillBytes.

func (Int) Cmp 

func (x Int) Cmp(y Int) int

Cmp compares x and y and returns: 

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

func (Int) CmpAbs 

func (x Int) CmpAbs(y Int) int

CmpAbs compares the absolute values of x and y and returns: 

-1 if |x| <  |y|
 0 if |x| == |y|
+1 if |x| >  |y|

func (Int) Div 

func (x Int) Div(y Int) Int

Div returns the quotient x/y for y != 0. If y == 0, a division-by-zero run-time panic occurs. Div implements Euclidean division (unlike Go); see DivMod for more details.

func (Int) DivMod 

func (x Int) DivMod(y Int) (Int, Int)

DivMod returns the quotient x div y and z to the modulus x mod y for more informations, go to big.Int

func (Int) Exp 

func (x Int) Exp(y, m Int) Int

Exp returns x**y mod |m| (i.e. the sign of m is ignored). If m == nil or m == 0, x = x**y unless y <= 0 then x = 1. If m != 0, y < 0, and y and m are not relatively prime, x is unchanged and nil is returned.

Modular exponentiation of inputs of a particular size is not a cryptographically constant-time operation.

func (Int) FillBytes 

func (x Int) FillBytes(buf []byte) []byte

FillBytes sets buf to the absolute value of x, storing it as a zero-extended big-endian byte slice, and returns buf.

If the absolute value of x doesn't fit in buf, FillBytes will panic.

func (Int) Floater 

func (x Int) Floater(decimals int) string

Floater returns strings representation of x in format of float. for example if you a number 101 which it has 1 decimal, you can convert it to float string, `x.StringFloat(1) == "10.1"` it is like to StringFloat but using strings instead casting to big float

func (*Int) Format 

func (x *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) GCD 

func (z Int) GCD(x, y, a, b Int) Int

GCD sets x to the greatest common divisor of a and b and returns z. for more informations, check big.Int GCD method.

func (*Int) GobDecode 

func (x *Int) GobDecode(buf []byte) error

GobDecode implements the gob.GobDecoder interface.

func (*Int) GobEncode 

func (x *Int) GobEncode() ([]byte, error)

GobEncode implements the gob.GobEncoder interface.

func (Int) Int64 

func (x Int) Int64() int64

Int64 returns the int64 representation of x. If x cannot be represented in an int64, the result is undefined.

func (Int) IsInt64 

func (x Int) IsInt64() bool

IsInt64 reports whether x can be represented as an int64.

func (Int) IsUint64 

func (x Int) IsUint64() bool

IsUint64 reports whether x can be represented as a uint64.

func (Int) Lsh 

func (x Int) Lsh(n uint) Int

Lsh returns x << n.

func (*Int) MarshalJSON 

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

MarshalJSON implements the json.Marshaler interface.

func (*Int) MarshalText 

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

MarshalText implements the encoding.TextMarshaler interface.

func (Int) Mod 

func (x Int) Mod(y Int) Int

Mod returns the modulus x%y for y != 0. If y == 0, a division-by-zero run-time panic occurs. Mod implements Euclidean modulus (unlike Go); see DivMod for more details.

func (Int) Mul 

func (x Int) Mul(y Int) Int

Mul returns the product x*y.

func (Int) MulRange 

func (a Int) MulRange(b int64) Int

MulRange returns the product of all integers in the range [a, b] inclusively. If a > b (empty range), the result is 1.

func (Int) Neg 

func (x Int) Neg() Int

Neg returns -x.

func (Int) Not 

func (x Int) Not() Int

Not returns ^x.

func (Int) Or 

func (x Int) Or(y Int) Int

Or returns x | y.

func (Int) Pow 

func (x Int) Pow(y Int) Int

Pow shorthand of Exp without passing second parameter for convenient.

func (Int) Quo 

func (x Int) Quo(y Int) Int

Quo returns the quotient x/y for y != 0. If y == 0, a division-by-zero run-time panic occurs. Quo implements truncated division (like Go); see QuoRem for more details.

func (Int) QuoRem 

func (x Int) QuoRem(y Int) (Int, Int)

QuoRem return the quotient x/y and the remainder x%y for more informations, check big.Int QuoRem method

func (*Int) Rand 

func (x *Int) Rand(rnd *rand.Rand, n *Int) *Int

Rand sets x to a pseudo-random number in [0, n) and returns x.

As this uses the math/rand package, it must not be used for security-sensitive work. Use crypto/rand.Int instead.

func (Int) Rem 

func (x Int) Rem(y Int) Int

Rem returns the remainder x%y for y != 0. If y == 0, a division-by-zero run-time panic occurs. Rem implements truncated modulus (like Go); see QuoRem for more details.

func (Int) Rsh 

func (x Int) Rsh(n uint) Int

Rsh returns x >> n.

func (*Int) Scan 

func (x *Int) Scan(dbValue interface{}) error

Scan implements sql.Scanner interface.

func (*Int) Set 

func (x *Int) Set(y Int) *Int

Set sets x to y returns x.

func (*Int) SetBit 

func (x *Int) SetBit(i int, b uint) *Int

SetBit set i'th bit to b (0 or 1). That is, if b is 1 SetBit sets x = y | (1 << i); if b is 0 SetBit sets x = y &^ (1 << i). If b is not 0 or 1, SetBit will panic.

func (*Int) SetBits 

func (x *Int) SetBits(abs []big.Word) *Int

SetBits provides raw (unchecked but fast) access to z by setting its value to abs, interpreted as a little-endian Word slice, and returning z. The result and abs share the same underlying array. SetBits is intended to support implementation of missing low-level Int functionality outside this package; it should be avoided otherwise.

func (*Int) SetBytes 

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

SetBytes interprets buf as the bytes of a big-endian unsigned integer, sets x to that value, and returns x.

func (*Int) SetFloat 

func (x *Int) SetFloat(y Float, decimals int) *Int

SetFloat sets x to int part of y which multplied by 10**decimals

func (*Int) SetInt64 

func (x *Int) SetInt64(y int64) *Int

SetInt64 sets x to y and returns x.

func (*Int) SetString 

func (x *Int) SetString(s string, base int) (*Int, bool)

SetString sets x to the value of s, interpreted in the given base, and returns x and a boolean indicating success. The entire string (not just a prefix) must be valid for success.

The base argument must be 0 or a value between 2 and MaxBase. For base 0, the number prefix determines the actual base: A prefix of “0b” or “0B” selects base 2, “0”, “0o” or “0O” selects base 8, and “0x” or “0X” selects base 16. Otherwise, the selected base is 10 and no prefix is accepted.

For bases <= 36, lower and upper case letters are considered the same: The letters 'a' to 'z' and 'A' to 'Z' represent digit values 10 to 35. For bases > 36, the upper case letters 'A' to 'Z' represent the digit values 36 to 61.

For base 0, an underscore character “_” may appear between a base prefix and an adjacent digit, and between successive digits; such underscores do not change the value of the number. Incorrect placement of underscores is reported as an error if there are no other errors. If base != 0, underscores are not recognized and act like any other character that is not a valid digit.

func (*Int) SetStringFloat 

func (x *Int) SetStringFloat(s string, decimals int) (*Int, error)

SetStringFloat sets x to int part s which multplied by 10**decimals and an error

func (*Int) SetUint64 

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

SetUint64 sets x to y returns x.

func (Int) Sign 

func (x Int) Sign() int

Sign returns: 

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

func (Int) Sqrt 

func (x Int) Sqrt() Int

Sqrt returns ⌊√x⌋, the largest integer such that z² ≤ x,. It panics if x is negative.

func (Int) String 

func (x Int) String() string

String returns the decimal representation of x as generated by x.Text(10).

func (Int) StringFloat 

func (x Int) StringFloat(decimals int) string

StringFloat returns strings representation of x in format of float. for example if you a number 101 which it has 1 decimal, you can convert it to float string, `x.StringFloat(1) == "10.1"`

func (Int) Sub 

func (x Int) Sub(y Int) Int

Sub returns the difference x-y.

func (Int) Text 

func (x Int) Text(base int) string

Text returns the string representation of x in the given base. Base must be between 2 and 62, inclusive. The result uses the lower-case letters 'a' to 'z' for digit values 10 to 35, and the upper-case letters 'A' to 'Z' for digit values 36 to 61. No prefix (such as "0x") is added to the string. If x is a nil pointer it returns "<nil>".

func (Int) TrailingZeroBits 

func (x Int) TrailingZeroBits() uint

TrailingZeroBits returns the number of consecutive least significant zero bits of |x|.

func (Int) Uint64 

func (x Int) Uint64() uint64

Uint64 returns the uint64 representation of x. If x cannot be represented in a uint64, the result is undefined.

func (*Int) UnmarshalJSON 

func (x *Int) UnmarshalJSON(text []byte) error

UnmarshalJSON implements the json.Unmarshaler interface.

func (*Int) UnmarshalText 

func (x *Int) UnmarshalText(text []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface.

func (Int) Value 

func (x Int) Value() (driver.Value, error)

Value implements sql/driver.Valuer interface.

func (Int) Xor 

func (x Int) Xor(y Int) Int

Xor returns x ^ y.

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.