decimal

Package decimal implements immutable decimal floating-point numbers for Go. This package is designed specifically for use in transactional financial systems.

Key Features

• Immutability - Once set, a decimal remains constant, ensuring safe concurrent access across goroutines.
• Banker's Rounding - Uses half-to-even rounding, also known as "banker's rounding", to minimize cumulative rounding errors commonly seen in financial calculations.
• Accurate Artihmetic - All methods are precisely rounded to a 19-digit precision, ensuring results are as close as possible to the true mathematical value.
• No Panics - All methods are panic-free, returning errors instead of crashing your application in cases such as overflow or division by zero.
• No Heap Allocations - Optimized to avoid heap allocations, reducing garbage collector impact during arithmetic operations.
• Simple String Representation - Decimals are represented in a strightforward format avoiding the complexities of scientific or engineering notations.
• Rigorous Testing - All methods are cross-validated against the cockroachdb/apd and shopspring/decimal packages throught extensive fuzz testing.

Getting Started

Installation

To add the decimal package to your Go workspace:

go get github.com/govalues/decimal

Basic Usage

Create decimal values using one of the constructors. After creating a decimal, you can perform various operations as shown below:

package main

import (
    "fmt"
    "github.com/govalues/decimal"
)

func main() {
    // Constructors
    d, _ := decimal.New(8, 0)               // d = 8
    e, _ := decimal.Parse("12.5")           // e = 12.5
    f, _ := decimal.NewFromFloat64(2.567)   // f = 2.567
    g, _ := decimal.NewFromInt64(7, 896, 3) // g = 7.896

    // Arithmetic operations
    fmt.Println(d.Add(e))        // 8 + 12.5
    fmt.Println(d.Sub(e))        // 8 - 12.5
    fmt.Println(d.SubAbs(e))     // abs(8 - 12.5)

    fmt.Println(d.Mul(e))        // 8 * 12.5
    fmt.Println(d.AddMul(e, f))  // 8 + 12.5 * 2.567
    fmt.Println(d.SubMul(e, f))  // 8 - 12.5 * 2.567
    fmt.Println(d.PowInt(2))     // 8²

    fmt.Println(d.Quo(e))        // 8 / 12.5
    fmt.Println(d.AddQuo(e, f))  // 8 + 12.5 / 2.567
    fmt.Println(d.SubQuo(e, f))  // 8 - 12.5 / 2.567
    fmt.Println(d.QuoRem(e))     // 8 div 12.5, 8 mod 12.5
    fmt.Println(d.Inv())         // 1 / 8

    // Transcendental functions
    fmt.Println(d.Sqrt())        // √8
    fmt.Println(d.Exp())         // exp(8)
    fmt.Println(d.Log())         // ln(8)

    // Rounding to 2 decimal places
    fmt.Println(g.Round(2))      // 7.90
    fmt.Println(g.Ceil(2))       // 7.90
    fmt.Println(g.Floor(2))      // 7.89
    fmt.Println(g.Trunc(2))      // 7.89

    // Conversions
    fmt.Println(f.Int64(9))      // 2 567000000
    fmt.Println(f.Float64())     // 2.567
    fmt.Println(f.String())      // 2.567

    // Formatting
    fmt.Printf("%.2f", f)        // 2.57
    fmt.Printf("%.2k", f)        // 256.70%
}

Documentation

For detailed documentation and additional examples, visit the package documentation. For examples related to financial calculations, see the money package documentation.

Comparison

Comparison with other popular packages:

Benchmarks

goos: linux
goarch: amd64
pkg: github.com/govalues/decimal-tests
cpu: AMD Ryzen 7 3700C  with Radeon Vega Mobile Gfx 

The benchmark results shown in the table are provided for informational purposes only and may vary depending on your specific use case.