service backend

api/pkg/decimal/rational.go

@@ -0,0 +1,161 @@
+package decimal
+
+import (
+	"math/big"
+	"strings"
+
+	"github.com/tech/sendico/pkg/merrors"
+)
+
+// RatFromString parses a decimal string into a big.Rat
+// Supports standard decimal notation like "123.45", "-0.001", etc.
+func RatFromString(value string) (*big.Rat, error) {
+	if strings.TrimSpace(value) == "" {
+		return nil, merrors.InvalidArgument("decimal: empty value")
+	}
+	r := new(big.Rat)
+	if _, ok := r.SetString(value); !ok {
+		return nil, merrors.InvalidArgument("decimal: invalid decimal value: " + value)
+	}
+	return r, nil
+}
+
+// MulRat multiplies two rational numbers
+func MulRat(a, b *big.Rat) *big.Rat {
+	return new(big.Rat).Mul(a, b)
+}
+
+// DivRat divides two rational numbers
+func DivRat(a, b *big.Rat) (*big.Rat, error) {
+	if b.Sign() == 0 {
+		return nil, merrors.InvalidArgument("decimal: division by zero")
+	}
+	return new(big.Rat).Quo(a, b), nil
+}
+
+// AddRat adds two rational numbers
+func AddRat(a, b *big.Rat) *big.Rat {
+	return new(big.Rat).Add(a, b)
+}
+
+// SubRat subtracts two rational numbers (a - b)
+func SubRat(a, b *big.Rat) *big.Rat {
+	return new(big.Rat).Sub(a, b)
+}
+
+// NegRat negates a rational number
+func NegRat(a *big.Rat) *big.Rat {
+	return new(big.Rat).Neg(a)
+}
+
+// RoundRatToScale rounds a rational number to a specific number of decimal places
+// using the specified rounding mode
+func RoundRatToScale(value *big.Rat, scale uint32, mode RoundingMode) (*big.Rat, error) {
+	scaleFactor := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(scale)), nil)
+	numerator := new(big.Int).Mul(new(big.Int).Set(value.Num()), scaleFactor)
+	denominator := value.Denom()
+
+	quotient := new(big.Int)
+	remainder := new(big.Int)
+	quotient.QuoRem(numerator, denominator, remainder)
+
+	// No remainder, already exact
+	if remainder.Sign() == 0 {
+		return new(big.Rat).SetFrac(quotient, scaleFactor), nil
+	}
+
+	sign := quotient.Sign()
+	absQuotient := new(big.Int).Abs(new(big.Int).Set(quotient))
+	absRemainder := new(big.Int).Abs(remainder)
+	absDenominator := new(big.Int).Abs(denominator)
+
+	doubledRemainder := new(big.Int).Mul(absRemainder, big.NewInt(2))
+	cmp := doubledRemainder.Cmp(absDenominator)
+
+	shouldIncrement := false
+
+	switch mode {
+	case RoundingModeDown:
+		shouldIncrement = false
+	case RoundingModeHalfUp:
+		if cmp >= 0 {
+			shouldIncrement = true
+		}
+	case RoundingModeHalfEven, RoundingModeUnspecified:
+		if cmp > 0 {
+			shouldIncrement = true
+		} else if cmp == 0 {
+			// Tie: round to even
+			if absQuotient.Bit(0) == 1 {
+				shouldIncrement = true
+			}
+		}
+	default:
+		// Default to HALF_EVEN
+		if cmp > 0 {
+			shouldIncrement = true
+		} else if cmp == 0 {
+			if absQuotient.Bit(0) == 1 {
+				shouldIncrement = true
+			}
+		}
+	}
+
+	if shouldIncrement {
+		if sign < 0 {
+			absQuotient.Add(absQuotient, big.NewInt(1))
+			quotient = absQuotient.Neg(absQuotient)
+		} else {
+			absQuotient.Add(absQuotient, big.NewInt(1))
+			quotient = absQuotient
+		}
+	}
+
+	return new(big.Rat).SetFrac(quotient, scaleFactor), nil
+}
+
+// FormatRat formats a rational number as a decimal string with the specified scale
+func FormatRat(r *big.Rat, scale uint32) string {
+	sign := ""
+	if r.Sign() < 0 {
+		sign = "-"
+	}
+
+	absRat := new(big.Rat).Abs(r)
+	scaleFactor := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(scale)), nil)
+	numerator := new(big.Int).Mul(absRat.Num(), scaleFactor)
+	numerator.Quo(numerator, absRat.Denom())
+
+	intStr := numerator.String()
+	if scale == 0 {
+		return sign + intStr
+	}
+
+	if len(intStr) <= int(scale) {
+		intStr = strings.Repeat("0", int(scale)-len(intStr)+1) + intStr
+	}
+
+	pointPos := len(intStr) - int(scale)
+	return sign + intStr[:pointPos] + "." + intStr[pointPos:]
+}
+
+// CmpRat compares two rational numbers
+// Returns -1 if a < b, 0 if a == b, 1 if a > b
+func CmpRat(a, b *big.Rat) int {
+	return a.Cmp(b)
+}
+
+// IsZero checks if a rational number is zero
+func IsZero(r *big.Rat) bool {
+	return r.Sign() == 0
+}
+
+// IsPositive checks if a rational number is positive
+func IsPositive(r *big.Rat) bool {
+	return r.Sign() > 0
+}
+
+// IsNegative checks if a rational number is negative
+func IsNegative(r *big.Rat) bool {
+	return r.Sign() < 0
+}