Arbitrary-precision decimal arithmetic, ported to Go

Install

go get github.com/iSundram/decimal-go

package main

import (
	"fmt"

	"github.com/iSundram/decimal-go"
)

func main() {
	// Money math without the float rounding surprises of float64.
	price := decimal.New("19.99")
	total := price.Times(decimal.New("3"))
	fmt.Println(total) // 59.97

	fmt.Println(decimal.New("0.1").Plus(decimal.New("0.2"))) // 0.3

	// Custom precision via a cloned constructor.
	c := decimal.Default.Clone(&decimal.Config{Precision: decimal.I64(50)})
	pi := c.New("3.14159265358979323846264338327950288419716939937510")
	fmt.Println(pi.ToFixed(30))
}

59.97
0.3
3.141592653589793238462643383280

Usage at a glance

Behavioral parity — proven, not claimed

Parity with the real decimal.js is checked mechanically, on every push:

• Ported test suite — all 61 decimal.js test modules, every assertion in the same order, run white-box in package decimal.
• Cross-validation — a shared corpus through both the Go port (go run) and the live decimal.js (node); outputs are byte-for-byte identical: 1518/1518 result lines (66 inputs × 23 ops, xvalidate/).
• Property tests — round-trip, commutativity, inverse add/sub & mul/div, sqrt/cbrt/exp-ln inverses, comparison antisymmetry, modulo range.
• Stress + race — precision 400–2048, int64/uint64 boundaries, NaN/∞, 64 concurrent clone-constructors under -race.
• Fuzzing — four targets; only [DecimalError] panics are permitted, anything else fails the build (fuzz_test.go).

Benchmarks — honestly

Same machine, Node v22 vs Go 1.25, op-only operands at the default precision 20. Ratio < 1 means the Go port is faster. Full table and methodology in bench/README.md.

23 of 25 directly comparable pairs are faster in Go (up to ~3× on multiplication/division). The two slower paths are string parsing and round trips that re-parse inputs — V8's JIT is extremely good at that workload, while Go pays per-parse allocation overhead. We disclose rather than hide this.

Documentation