package big

import "git.sr.ht/~shulhan/pakakeh.go/lib/math/big"

Package big extends the capabilities of standard "math/big" package by adding custom global precision to Float and Rat; and global rounding mode, and bits precision to Float.

Index

Examples

Variables 

var DefaultBitPrecision uint = 128

DefaultBitPrecision define the maximum number of mantissa bits available to represent the value.

In standard library this value is 24 for float32 or 53 for float64.

One should change this value before using the new extended Float in the program. 

var DefaultDigitPrecision = 8

DefaultDigitPrecision define the default number of digits after decimal point which affect the return of String() and MarshalJSON() methods.

A zero value of digit precision mean is it will use the default output of 'f' format.

One should change this value before using the new extended Float or Rat in the program. 

var DefaultRoundingMode = big.ToNearestAway

DefaultRoundingMode define the default rounding mode for all instance of Float.

One should change this value before using the new extended Float in the program. 

var MarshalJSONAsString = true

MarshalJSONAsString define the default return behaviour of MarshalJSON(). If its true (the default) the returned JSON format will encapsulated in double quote, as string instead of as numeric.

Types

type Float 

type Float struct {
	big.Float
}

Float extend the standard big.Float by setting each instance precision to DefaultBitPrecision, rounding mode to DefaultRoundingMode, and using DefaultDigitPrecision value after decimal point when converted to string.

func AddFloat 

func AddFloat(f ...any) *Float

AddFloat return the rounded sum `f[0]+f[1]+...`. It will return nil if the first parameter is not convertable to Float.

func CreateFloat 

func CreateFloat(v float64) Float

CreateFloat create Float with default bit precision and rounding mode.

func MulFloat 

func MulFloat(f, g any) *Float

MulFloat return the result of multiplication `f*g`. It will return nil if `f` or `g` is not convertible to Float.

func MustParseFloat 

func MustParseFloat(s string) (f *Float)

MustParseFloat convert the string `s` into Float or panic.

func NewFloat 

func NewFloat(v any) *Float

NewFloat create and initialize new Float with default bit precision, and rounding mode.

func ParseFloat 

func ParseFloat(s string) (f *Float, err error)

ParseFloat the string s into Float value.

func QuoFloat 

func QuoFloat(f, g any) *Float

QuoFloat return the quotient of `f/g` as new Float.

func SubFloat 

func SubFloat(f, g *Float) *Float

SubFloat return the result of subtraction `f-g` as new Float.

func (*Float) Add 

func (f *Float) Add(g any) *Float

Add sets f to `f+g` and return the f as the result.

func (*Float) Clone 

func (f *Float) Clone() *Float

Clone the instance to new Float.

func (*Float) Int64 

func (f *Float) Int64() int64

Int64 return the integer resulting from truncating x towards zero.

func (*Float) IsEqual 

func (f *Float) IsEqual(g any) bool

IsEqual will return true if `f == g`.

func (*Float) IsGreater 

func (f *Float) IsGreater(g any) bool

IsGreater will return true if `f > g`.

func (*Float) IsGreaterOrEqual 

func (f *Float) IsGreaterOrEqual(g any) bool

IsGreaterOrEqual will return true if `f >= g`.

func (*Float) IsLess 

func (f *Float) IsLess(g any) bool

IsLess will return true if `f < g`.

func (*Float) IsLessOrEqual 

func (f *Float) IsLessOrEqual(g any) bool

IsLessOrEqual will return true if `f <= g`.

func (*Float) IsZero 

func (f *Float) IsZero() bool

IsZero will return true if `f == 0`.

func (*Float) MarshalJSON 

func (f *Float) MarshalJSON() ([]byte, error)

MarshalJSON implement the json.Marshaler interface and return the output of String method.

func (*Float) Mul 

func (f *Float) Mul(g any) *Float

Mul sets f to product of `f * g` and return the result as f. If g is not convertible to Float it will return nil.

func (*Float) ParseFloat 

func (f *Float) ParseFloat(s string) (err error)

ParseFloat parse the string into Float value.

func (*Float) Quo 

func (f *Float) Quo(g any) *Float

Quo sets f to quotient of `f/g` and return the result as f. If g is not convertible to Float it will return nil.

func (*Float) String 

func (f *Float) String() string

String format the Float value into string with maximum mantissa is set by digit precision option.

Unlike standard String method, this method will trim trailing zero digit or decimal point at the end of mantissa.

func (*Float) Sub 

func (f *Float) Sub(g any) *Float

Sub sets f to rounded difference `f-g` and return f.

func (*Float) UnmarshalJSON 

func (f *Float) UnmarshalJSON(in []byte) (err error)

UnmarshalJSON convert the JSON byte value into Float.

type Int 

type Int struct {
	big.Int
}

Int extends the standard big.Int package.

func NewInt 

func NewInt(v any) (i *Int)

NewInt create and initialize new Int value from v or nil if v is invalid type that cannot be converted to Int.

func (*Int) Add 

func (i *Int) Add(v any) *Int

Add set the i value to i + v and return the i as the result.

func (*Int) IsGreater 

func (i *Int) IsGreater(v any) bool

IsGreater will return true if i > v.

func (*Int) IsLess 

func (i *Int) IsLess(v any) bool

IsLess will return true if i < v.

func (*Int) IsZero 

func (i *Int) IsZero() bool

IsZero will return true if `i == 0`.

func (*Int) MarshalJSON 

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

MarshalJSON implement the json.Marshaler interface and return the output of String method.

If the global variable MarshalJSONAsString is true, the Int value will be encoded as string.

func (*Int) Scan 

func (i *Int) Scan(src any) error

Scan implement the database's sql.Scan interface.

func (*Int) UnmarshalJSON 

func (i *Int) UnmarshalJSON(in []byte) (err error)

UnmarshalJSON convert the JSON byte value into Int.

func (*Int) Value 

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

Value implement the sql/driver.Valuer.

type Rat 

type Rat struct {
	big.Rat
}

Rat extend the standard big.Rat using rounding mode ToZero and without panic.

func AddRat 

func AddRat(f ...any) *Rat

AddRat return the sum of `f[0]+f[1]+...`. It will return nil if the first parameter is not convertable to Rat.

Example

Code: 

{
	fmt.Println(AddRat())
	fmt.Println(AddRat(nil))
	fmt.Println(AddRat("a"))
	fmt.Println(AddRat(0, 0.0001))
	fmt.Println(AddRat("1.007", "a", "2.003")) // Invalid parameter "a" is ignored.

	// Output:
	// 0
	// 0
	// 0
	// 0.0001
	// 3.01
}

Output:

0
0
0
0.0001
3.01

func MulRat 

func MulRat(f ...any) *Rat

MulRat return the result of multiplication `f[0]*f[1]*...`. It will return nil if the first parameter is not convertable to Rat.

Example

Code: 

{
	fmt.Println(MulRat())
	fmt.Println(MulRat(nil))
	fmt.Println(MulRat("a"))
	fmt.Println(MulRat(0, 1))
	fmt.Println(MulRat(6, "a", "0.3")) // Invalid parameter "a" is ignored.

	// Output:
	// 0
	// 0
	// 0
	// 0
	// 1.8
}

Output:

0
0
0
0
1.8

func NewRat 

func NewRat(v any) (r *Rat)

NewRat create and initialize new Rat value from v. It will return nil if v is not convertable to Rat.

Empty string or empty []byte still considered as valid, and it will return it as zero.

Example

Code: 

{
	var (
		stdNilInt *big.Int
		stdNilRat *big.Rat
		stdRat    big.Rat
		nilRat    *Rat
	)
	inputs := []any{
		nil,
		[]byte{},
		"",
		[]byte("a"),
		"0",
		"0.0000_0001",
		[]byte("14687233442.06916608"),
		"14_687_233_442.069_166_08",
		nilRat,
		NewRat("14687233442.06916608"),
		*NewRat("14687233442.06916608"),
		stdNilRat,
		stdRat,
		big.NewRat(14687233442, 100_000_000),
		*big.NewRat(14687233442, 100_000_000),
		uint16(math.MaxUint16),
		uint32(math.MaxUint32),
		uint64(math.MaxUint64),
		stdNilInt,
		big.NewInt(100_000_000),
	}

	for _, v := range inputs {
		fmt.Println(NewRat(v))
	}

	// Output:
	// 0
	// 0
	// 0
	// 0
	// 0
	// 0.00000001
	// 14687233442.06916608
	// 14687233442.06916608
	// 0
	// 14687233442.06916608
	// 14687233442.06916608
	// 0
	// 0
	// 146.87233442
	// 146.87233442
	// 65535
	// 4294967295
	// 18446744073709551615
	// 0
	// 100000000
}

Output:

0
0
0
0
0
0.00000001
14687233442.06916608
14687233442.06916608
0
14687233442.06916608
14687233442.06916608
0
0
146.87233442
146.87233442
65535
4294967295
18446744073709551615
0
100000000

func QuoRat 

func QuoRat(f ...any) *Rat

QuoRat return the quotient of `f[0]/f[1]/...` as new Rat. It will return nil if the first parameter is not convertable to Rat. If the second or rest of parameters can not be converted to Rat or zero it will return nil instead of panic.

Example

Code: 

{
	fmt.Println(QuoRat())
	fmt.Println(QuoRat(nil))
	fmt.Println(QuoRat("a"))
	fmt.Println(QuoRat("0"))
	fmt.Println(QuoRat(2, 0, 2))
	fmt.Println(QuoRat(6, "a", "0.3"))
	fmt.Println(QuoRat(0, 1))
	fmt.Println(QuoRat(4651, 272))
	fmt.Println(QuoRat(int64(1815507979407), NewRat(100000000)))
	fmt.Println(QuoRat("25494300", "25394000000"))

	// Output:
	// 0
	// 0
	// 0
	// 0
	// 0
	// 0
	// 0
	// 17.0992647
	// 18155.07979407
	// 0.00100395
}

Output:

0
0
0
0
0
0
0
17.0992647
18155.07979407
0.00100395

func SubRat 

func SubRat(f ...any) *Rat

SubRat return the result of subtraction `f[0]-f[1]-...` as new Rat. It will return nil if the first parameter is not convertable to Rat.

Example

Code: 

{
	fmt.Println(SubRat())
	fmt.Println(SubRat(nil))
	fmt.Println(SubRat("a"))
	fmt.Println(SubRat(0, 1))
	fmt.Println(SubRat(6, "a", "0.3"))

	// Output:
	// 0
	// 0
	// 0
	// -1
	// 5.7
}

Output:

0
0
0
-1
5.7

func (*Rat) Abs 

func (r *Rat) Abs() *Rat

Abs sets r to |r| (the absolute value of r) and return it.

Example

Code: 

{
	fmt.Println(NewRat(nil).Abs())
	fmt.Println(NewRat("-1").Abs())
	fmt.Println(NewRat("-0.00001").Abs())
	fmt.Println(NewRat("1").Abs())

	// Output:
	// 0
	// 1
	// 0.00001
	// 1
}

Output:

0
1
0.00001
1

func (*Rat) Add 

func (r *Rat) Add(g any) *Rat

Add sets r to `r+g` and return the r as the result. If g is not convertable to Rat it will equal to r+0.

Example

Code: 

{
	fmt.Println(NewRat(nil).Add(nil))
	fmt.Println(NewRat(1).Add(nil))
	fmt.Println(NewRat(1).Add(1))

	// Output:
	// 0
	// 1
	// 2
}

Output:

0
1
2

func (*Rat) Humanize 

func (r *Rat) Humanize(thousandSep, decimalSep string) string

Humanize format the r into string with custom thousand and decimal separator.

Example

Code: 

{
	var (
		thousandSep = "."
		decimalSep  = ","
	)
	fmt.Printf("%s\n", NewRat(nil).Humanize(thousandSep, decimalSep))
	fmt.Printf("%s\n", NewRat("0").Humanize(thousandSep, decimalSep))
	fmt.Printf("%s\n", NewRat("0.1234").Humanize(thousandSep, decimalSep))
	fmt.Printf("%s\n", NewRat("100").Humanize(thousandSep, decimalSep))
	fmt.Printf("%s\n", NewRat("100.1234").Humanize(thousandSep, decimalSep))
	fmt.Printf("%s\n", NewRat("1000").Humanize(thousandSep, decimalSep))
	fmt.Printf("%s\n", NewRat("1000.2").Humanize(thousandSep, decimalSep))
	fmt.Printf("%s\n", NewRat("10000.23").Humanize(thousandSep, decimalSep))
	fmt.Printf("%s\n", NewRat("100000.234").Humanize(thousandSep, decimalSep))

	// Output:
	// 0
	// 0
	// 0,1234
	// 100
	// 100,1234
	// 1.000
	// 1.000,2
	// 10.000,23
	// 100.000,234
}

Output:

0
0
0,1234
100
100,1234
1.000
1.000,2
10.000,23
100.000,234

func (*Rat) Int64 

func (r *Rat) Int64() int64

Int64 return the integer resulting from truncating r towards zero. It will return math.MaxInt64, if the value is larger than MaxInt64. It will return math.MinInt64, if the value is lower than MinInt64.

Example

Code: 

{
	fmt.Printf("MaxInt64: %d\n", NewRat("9223372036854775807").Int64())
	fmt.Printf("MaxInt64+1: %d\n", NewRat("9223372036854775808").Int64())
	fmt.Printf("MinInt64: %d\n", NewRat("-9223372036854775808").Int64())
	fmt.Printf("MinInt64-1: %d\n", NewRat("-9223372036854775809").Int64())

	fmt.Println(NewRat(nil).Int64())
	fmt.Println(NewRat("0.000_000_001").Int64())
	fmt.Println(NewRat("0.5").Int64())
	fmt.Println(NewRat("0.6").Int64())
	fmt.Println(NewRat("4011144900.02438879").Mul(100000000).Int64())
	fmt.Println(QuoRat("128_900", "0.000_0322").Int64())
	fmt.Println(QuoRat(128900, 3220).Mul(100000000).Int64())
	fmt.Println(QuoRat(25494300, QuoRat(25394000000, 100000000)).Int64())

	// Output:
	// MaxInt64: 9223372036854775807
	// MaxInt64+1: 9223372036854775807
	// MinInt64: -9223372036854775808
	// MinInt64-1: -9223372036854775808
	// 0
	// 0
	// 0
	// 0
	// 401114490002438879
	// 4003105590
	// 4003105590
	// 100394
}

Output:

MaxInt64: 9223372036854775807
MaxInt64+1: 9223372036854775807
MinInt64: -9223372036854775808
MinInt64-1: -9223372036854775808
0
0
0
0
401114490002438879
4003105590
4003105590
100394

func (*Rat) IsEqual 

func (r *Rat) IsEqual(g any) bool

IsEqual will return true if `r == g`, including when r and g are both nil.

Unlike the standard Cmp(), if the first call to Cmp is not 0, it will try to compare the string values of r and g, truncated by DefaultDigitPrecision.

Example

Code: 

{
	f := NewRat(1)

	fmt.Println(NewRat(nil).IsEqual(0))
	fmt.Println(f.IsEqual("a"))
	fmt.Println(f.IsEqual("1"))
	fmt.Println(f.IsEqual(1.1))
	fmt.Println(f.IsEqual(byte(1)))
	fmt.Println(f.IsEqual(int(1)))
	fmt.Println(f.IsEqual(int32(1)))
	fmt.Println(f.IsEqual(float32(1)))
	fmt.Println(f.IsEqual(NewRat(1)))
	// Equal due to String() truncation to DefaultDigitPrecision (8) digits.
	fmt.Println(NewRat("0.1234567890123").IsEqual("0.12345678"))

	// Output:
	// false
	// false
	// true
	// false
	// true
	// true
	// true
	// true
	// true
	// true
}

Output:

false
false
true
false
true
true
true
true
true
true

func (*Rat) IsGreater 

func (r *Rat) IsGreater(g any) bool

IsGreater will return true if `r > g`. If g is not convertable to Rat it will return false.

Example

Code: 

{
	r := NewRat("0.000_000_5")

	fmt.Println(NewRat(nil).IsGreater(0))
	fmt.Println(r.IsGreater(nil))
	fmt.Println(r.IsGreater("0.000_000_5"))
	fmt.Println(r.IsGreater("0.000_000_49999"))

	// Output:
	// false
	// false
	// false
	// true
}

Output:

false
false
false
true

func (*Rat) IsGreaterOrEqual 

func (r *Rat) IsGreaterOrEqual(g any) bool

IsGreaterOrEqual will return true if `r >= g`. If g is not convertable to Rat it will return false.

Example

Code: 

{
	r := NewRat("0.000_000_5")

	fmt.Println(NewRat(nil).IsGreaterOrEqual(0))
	fmt.Println(r.IsGreaterOrEqual(nil))
	fmt.Println(r.IsGreaterOrEqual("0.000_000_500_000_000_001"))
	fmt.Println(r.IsGreaterOrEqual("0.000_000_5"))
	fmt.Println(r.IsGreaterOrEqual("0.000_000_49999"))

	// Output:
	// false
	// false
	// false
	// true
	// true
}

Output:

false
false
false
true
true

func (*Rat) IsGreaterThanZero 

func (r *Rat) IsGreaterThanZero() bool

IsGreaterThanZero will return true if `r > 0`.

Example

Code: 

{
	fmt.Println(NewRat(nil).IsGreaterThanZero())
	fmt.Println(NewRat(0).IsGreaterThanZero())
	fmt.Println(NewRat("-0.000_000_000_000_000_001").IsGreaterThanZero())
	fmt.Println(NewRat("0.000_000_000_000_000_001").IsGreaterThanZero())

	// Output:
	// false
	// false
	// false
	// true
}

Output:

false
false
false
true

func (*Rat) IsLess 

func (r *Rat) IsLess(g any) bool

IsLess will return true if `r < g`. If r is nill or g is not convertable to Rat it will return false.

Example

Code: 

{
	r := NewRat("0.000_000_5")

	fmt.Println(NewRat(nil).IsLess(0))
	fmt.Println(r.IsLess(nil))
	fmt.Println(r.IsLess("0.000_000_5"))
	fmt.Println(r.IsLess("0.000_000_49"))
	fmt.Println(r.IsLess("0.000_000_500_000_000_001"))

	// Output:
	// false
	// false
	// false
	// false
	// true
}

Output:

false
false
false
false
true

func (*Rat) IsLessOrEqual 

func (r *Rat) IsLessOrEqual(g any) bool

IsLessOrEqual will return true if `r <= g`. It r is nil or g is not convertable to Rat it will return false.

Example

Code: 

{
	r := NewRat("0.000_000_5")

	fmt.Println(NewRat(nil).IsLessOrEqual(r))
	fmt.Println(r.IsLessOrEqual(nil))
	fmt.Println(r.IsLessOrEqual("0.000_000_5"))
	fmt.Println(r.IsLessOrEqual("0.000_000_49"))
	fmt.Println(r.IsLessOrEqual("0.000_000_500_000_000_001"))

	// Output:
	// false
	// false
	// true
	// false
	// true
}

Output:

false
false
true
false
true

func (*Rat) IsLessThanZero 

func (r *Rat) IsLessThanZero() bool

IsLessThanZero return true if `r < 0`.

Example

Code: 

{
	fmt.Println(NewRat(nil).IsLessThanZero())
	fmt.Println(NewRat(byte(0)).IsLessThanZero())
	fmt.Println(NewRat("-0.000_000_000_000_000_001").IsLessThanZero())
	fmt.Println(NewRat("0.000_000_000_000_000_001").IsLessThanZero())

	// Output:
	// false
	// false
	// true
	// false
}

Output:

false
false
true
false

func (*Rat) IsZero 

func (r *Rat) IsZero() bool

IsZero will return true if `r == 0`.

Example

Code: 

{
	fmt.Println(NewRat(nil).IsZero())
	fmt.Println(NewRat(byte(0)).IsZero())
	fmt.Println(NewRat(byte(-0)).IsZero())
	fmt.Println(NewRat("-0.000_000_000_000_000_001").IsZero())
	fmt.Println(NewRat("0.000_000_000_000_000_001").IsZero())

	// Output:
	// false
	// true
	// true
	// false
	// false
}

Output:

false
true
true
false
false

func (*Rat) MarshalJSON 

func (r *Rat) MarshalJSON() ([]byte, error)

MarshalJSON implement the json.Marshaler interface. It will return the same result as String().

Example

Code: 

{
	inputs := []string{
		"",
		"a",
		"0.0000_0000",
		"0.1",
		"0.0000_0001",
		"0.0000_0000_1", // Truncated by DefaultDigitPrecision.
		"1234567890.0",
		"64.23738872403", // Truncated by DefaultDigitPrecision.
		"0.1234567890",
		"142660378.65368736",
		"9193394308.85771370",
		"14687233442.06916608",
	}

	MarshalJSONAsString = true
	for _, in := range inputs {
		out, _ := NewRat(in).MarshalJSON()
		fmt.Printf("%s\n", out)
	}

	// Setting this to false will make the JSON output become number.
	MarshalJSONAsString = false

	for _, in := range inputs {
		out, _ := NewRat(in).MarshalJSON()
		fmt.Printf("%s\n", out)
	}

	// Output:
	// "0"
	// "0"
	// "0"
	// "0.1"
	// "0.00000001"
	// "0"
	// "1234567890"
	// "64.23738872"
	// "0.12345678"
	// "142660378.65368736"
	// "9193394308.8577137"
	// "14687233442.06916608"
	// 0
	// 0
	// 0
	// 0.1
	// 0.00000001
	// 0
	// 1234567890
	// 64.23738872
	// 0.12345678
	// 142660378.65368736
	// 9193394308.8577137
	// 14687233442.06916608
}

Output:

"0"
"0"
"0"
"0.1"
"0.00000001"
"0"
"1234567890"
"64.23738872"
"0.12345678"
"142660378.65368736"
"9193394308.8577137"
"14687233442.06916608"
0
0
0
0.1
0.00000001
0
1234567890
64.23738872
0.12345678
142660378.65368736
9193394308.8577137
14687233442.06916608
Example (WithStruct)

Code: 

{
	type T struct {
		V *Rat `json:"V"`
	}

	inputs := []T{
		{V: nil},
		{V: NewRat(0)},
		{V: NewRat("0.1234567890")},
	}

	var (
		in  T
		err error
		out []byte
	)
	MarshalJSONAsString = true
	for _, in = range inputs {
		out, err = json.Marshal(&in)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("%s\n", out)
	}

	MarshalJSONAsString = false
	for _, in = range inputs {
		out, err = json.Marshal(&in)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("%s\n", out)
	}

	// Output:
	// {"V":null}
	// {"V":"0"}
	// {"V":"0.12345678"}
	// {"V":null}
	// {"V":0}
	// {"V":0.12345678}
}

Output:

{"V":null}
{"V":"0"}
{"V":"0.12345678"}
{"V":null}
{"V":0}
{"V":0.12345678}

func (*Rat) Mul 

func (r *Rat) Mul(g any) *Rat

Mul sets r to product of `r * g` and return the result as r. If g is not convertible to Rat it will return nil.

Example

Code: 

{
	const (
		defValue = "14687233442.06916608"
	)

	fmt.Println(NewRat(defValue).Mul("a"))
	fmt.Println(NewRat(defValue).Mul("0"))
	fmt.Println(NewRat(defValue).Mul(defValue))
	fmt.Println(NewRat("1.06916608").Mul("1.06916608"))

	// Output:
	// 0
	// 0
	// 215714826181834884090.46087866
	// 1.1431161
}

Output:

0
0
215714826181834884090.46087866
1.1431161

func (*Rat) Quo 

func (r *Rat) Quo(g any) *Rat

Quo sets r to quotient of `r/g` and return the result as r. If r is nil or g is not convertible to Rat or zero it will return nil.

Example

Code: 

{
	const (
		defValue = "14687233442.06916608"
	)

	fmt.Println(NewRat(nil).Quo(1))
	fmt.Println(NewRat(defValue).Quo(nil))
	fmt.Println(NewRat(defValue).Quo("a"))
	fmt.Println(NewRat(defValue).Quo("100_000_000"))

	// Output:
	// 0
	// 0
	// 0
	// 146.87233442
}

Output:

0
0
0
146.87233442

func (*Rat) RoundNearestFraction 

func (r *Rat) RoundNearestFraction() *Rat

RoundNearestFraction round the fraction to the nearest non-zero value.

The RoundNearestFraction does not require precision parameter, like in other rounds function, but it will figure it out based on the last non-zero value from fraction.

See example for more information.

Example

Code: 

{
	fmt.Printf("nil: %s\n", NewRat(nil).RoundNearestFraction())
	fmt.Printf("0.000000001: %s\n", NewRat("0").RoundNearestFraction()) // Affected by DefaultDigitPrecision (8)
	fmt.Printf("0.00545: %s\n", NewRat("0.00545").RoundNearestFraction())
	fmt.Printf("0.00555: %s\n", NewRat("0.00555").RoundNearestFraction())
	fmt.Printf("0.0545: %s\n", NewRat("0.0545").RoundNearestFraction())
	fmt.Printf("0.0555: %s\n", NewRat("0.0555").RoundNearestFraction())
	fmt.Printf("0.545: %s\n", NewRat("0.545").RoundNearestFraction())
	fmt.Printf("0.555: %s\n", NewRat("0.555").RoundNearestFraction())
	fmt.Printf("0.5: %s\n", NewRat("0.5").RoundNearestFraction())
	fmt.Printf("-0.5: %s\n", NewRat("-0.5").RoundNearestFraction())
	fmt.Printf("-0.555: %s\n", NewRat("-0.555").RoundNearestFraction())
	fmt.Printf("-0.545: %s\n", NewRat("-0.545").RoundNearestFraction())

	// Output:
	// nil: 0
	// 0.000000001: 0
	// 0.00545: 0.005
	// 0.00555: 0.006
	// 0.0545: 0.05
	// 0.0555: 0.06
	// 0.545: 0.5
	// 0.555: 0.6
	// 0.5: 0.5
	// -0.5: -0.5
	// -0.555: -0.6
	// -0.545: -0.5
}

Output:

nil: 0
0.000000001: 0
0.00545: 0.005
0.00555: 0.006
0.0545: 0.05
0.0555: 0.06
0.545: 0.5
0.555: 0.6
0.5: 0.5
-0.5: -0.5
-0.555: -0.6
-0.545: -0.5

func (*Rat) RoundToNearestAway 

func (r *Rat) RoundToNearestAway(prec int) *Rat

RoundToNearestAway round r to n digit precision using nearest away mode, where mantissa is accumulated by the last digit after precision. For example, using 2 digit precision, 0.555 would become 0.56.

Example

Code: 

{
	fmt.Printf("nil: %s\n", NewRat(nil).RoundToNearestAway(2))
	fmt.Printf("0.0054: %s\n", NewRat("0.0054").RoundToNearestAway(2))
	fmt.Printf("0.0054: %s\n", NewRat("0.0054").RoundToNearestAway(1))
	fmt.Printf("0.5455: %s\n", NewRat("0.5455").RoundToNearestAway(2))
	fmt.Printf("0.5555: %s\n", NewRat("0.5555").RoundToNearestAway(2))
	fmt.Printf("0.5566: %s\n", NewRat("0.5567").RoundToNearestAway(2))
	fmt.Printf("0.5566: %s\n", NewRat("0.5566").RoundToNearestAway(0))

	fmt.Printf("0.02514135: %s\n", NewRat("0.02514135").RoundToNearestAway(6))
	fmt.Printf("0.02514145: %s\n", NewRat("0.02514145").RoundToNearestAway(6))
	fmt.Printf("0.02514155: %s\n", NewRat("0.02514155").RoundToNearestAway(6))
	fmt.Printf("0.02514165: %s\n", NewRat("0.02514165").RoundToNearestAway(6))

	fmt.Printf("0.5: %s\n", NewRat("0.5").RoundToNearestAway(0))
	fmt.Printf("-0.5: %s\n", NewRat("-0.5").RoundToNearestAway(0))

	// Output:
	// nil: 0
	// 0.0054: 0.01
	// 0.0054: 0
	// 0.5455: 0.55
	// 0.5555: 0.56
	// 0.5566: 0.56
	// 0.5566: 1
	// 0.02514135: 0.025141
	// 0.02514145: 0.025141
	// 0.02514155: 0.025142
	// 0.02514165: 0.025142
	// 0.5: 1
	// -0.5: -1
}

Output:

nil: 0
0.0054: 0.01
0.0054: 0
0.5455: 0.55
0.5555: 0.56
0.5566: 0.56
0.5566: 1
0.02514135: 0.025141
0.02514145: 0.025141
0.02514155: 0.025142
0.02514165: 0.025142
0.5: 1
-0.5: -1

func (*Rat) RoundToZero 

func (r *Rat) RoundToZero(prec int) *Rat

RoundToZero round r to n digit precision using to zero mode. For example, using 2 digit precision, 0.555 would become 0.55.

Example

Code: 

{
	fmt.Println(NewRat(nil).RoundToZero(2))
	fmt.Println(NewRat("0.5455").RoundToZero(2))
	fmt.Println(NewRat("0.5555").RoundToZero(2))
	fmt.Println(NewRat("0.5566").RoundToZero(2))
	fmt.Println(NewRat("0.5566").RoundToZero(0))
	// In Go <= 1.18, this will print "-0", but on Go tip "0".
	// So to make test success on all versions, we multiple it to 1.
	fmt.Println(NewRat("-0.5").RoundToZero(0).Mul(1))

	// Output:
	// 0
	// 0.54
	// 0.55
	// 0.55
	// 0
	// 0
}

Output:

0
0.54
0.55
0.55
0
0

func (*Rat) Scan 

func (r *Rat) Scan(v any) error

Scan implement the database's sql.Scan interface.

Example

Code: 

{
	var (
		r   = &Rat{}
		err error
	)

	inputs := []any{
		1234,
		nil,
		"0.0001",
		float64(0.0001),
	}
	for _, in := range inputs {
		err = r.Scan(in)
		if err != nil {
			fmt.Printf("error: %s\n", err)
		}
		fmt.Println(r)
	}

	// Output:
	// 1234
	// error: Rat.Scan: unknown type <nil>
	// 1234
	// 0.0001
	// 0.0001
}

Output:

1234
error: Rat.Scan: unknown type <nil>
1234
0.0001
0.0001

func (*Rat) String 

func (r *Rat) String() string

String format the Rat value into string with maximum mantissa is set by digit precision option with rounding mode set to zero.

Unlike standard String method, this method will trim trailing zero digit or decimal point at the end of mantissa.

Example

Code: 

{
	inputs := []any{
		nil,
		"12345",
		"0.00000000",
		float64(0.00000000),
		"0.1",
		float64(0.1),
		"0.0000001",
		float64(0.0000001),
		"0.000000001", // Truncated due to rounding.
		"64.23738872403",
		float64(64.23738872403),
	}
	for _, in := range inputs {
		fmt.Println(NewRat(in).String())
	}

	// Output:
	// 0
	// 12345
	// 0
	// 0
	// 0.1
	// 0.1
	// 0.0000001
	// 0.0000001
	// 0
	// 64.23738872
	// 64.23738872
}

Output:

0
12345
0
0
0.1
0.1
0.0000001
0.0000001
0
64.23738872
64.23738872

func (*Rat) Sub 

func (r *Rat) Sub(g any) *Rat

Sub sets r to rounded difference `r-g` and return r. If g is not convertable to Rat, it will return as r-0.

Example

Code: 

{
	fmt.Println(NewRat(nil).Sub(1))
	fmt.Println(NewRat(1).Sub(nil))
	fmt.Println(NewRat(1).Sub(1))

	// Output:
	// 0
	// 1
	// 0
}

Output:

0
1
0

func (*Rat) UnmarshalJSON 

func (r *Rat) UnmarshalJSON(in []byte) (err error)

UnmarshalJSON convert the JSON byte value into Rat.

Example (WithStruct)

Code: 

{
	type T struct {
		V *Rat `json:"V"`
		W *Rat `json:"W,omitempty"`
	}

	inputs := []string{
		`{"V":"ab"}`,
		`{}`,
		`{"V":}`,
		`{"V":0,"W":0}`,
		`{"V":"1"}`,
		`{"V":0.123456789}`,
		`{"V":"0.1234", "W":0.5678}`,
	}
	for _, in := range inputs {
		t := T{}
		err := json.Unmarshal([]byte(in), &t)
		if err != nil {
			fmt.Println(err)
			continue
		}
		fmt.Printf("%s %s\n", t.V, t.W)
	}

	// Output:
	// Rat.UnmarshalJSON: cannot convert []uint8([97 98]) to Rat
	// 0 0
	// invalid character '}' looking for beginning of value
	// 0 0
	// 1 0
	// 0.12345678 0
	// 0.1234 0.5678
}

Output:

Rat.UnmarshalJSON: cannot convert []uint8([97 98]) to Rat
0 0
invalid character '}' looking for beginning of value
0 0
1 0
0.12345678 0
0.1234 0.5678

func (*Rat) Value 

func (r *Rat) Value() (driver.Value, error)

Value return the []byte value for database/sql, as defined in sql/driver.Valuer. It will return "0" if r is nil.

Example

Code: 

{
	inputs := []any{
		nil,
		0,
		1.2345,
		"12345.6789_1234_5678_9",
	}
	for _, in := range inputs {
		out, _ := NewRat(in).Value()
		fmt.Printf("%s\n", out)
	}

	// Output:
	// 0
	// 0
	// 1.2345
	// 12345.67891234
}

Output:

0
0
1.2345
12345.67891234

Source Files

big.go float.go int.go rat.go

Version
v0.60.0 (latest)
Published
Feb 1, 2025
Platform
linux/amd64
Imports
8 packages
Last checked
22 minutes ago –

Tools for package owners.