Implement rationalize

Signed-off-by: James Hamlin <jfhamlin@gmail.com>

Author: jfhamlin

pkg/lang/bigdecimal.go

@@ -7,9 +7,17 @@ import (
 	"bitbucket.org/pcastools/hash"
 )
 
-// BigDec is an arbitrary-precision decimal number. It wraps and has
-// the same semantics as big.Float. big.Float is not used directly
-// because it is mutable, and the core BigDecimal should not be.
+// BigDec is an arbitrary-precision floating point number. It wraps
+// and has the same semantics as big.Float. big.Float is not used
+// directly because it is mutable, and the core BigDecimal should not
+// be.
+//
+// TODO: swap out with a *decimal* representation. The go standard
+// library big.Float is a binary floating point representation,
+// which means that some decimal fractions cannot be represented
+// exactly. This can lead to unexpected results when doing
+// arithmetic with decimal fractions. A decimal representation
+// would avoid this problem.
 type BigDecimal struct {
 	val *big.Float
 }

pkg/lang/numbers.go

@@ -98,6 +98,26 @@ func (nm *NumberMethods) Remainder(x, y any) any {
 	return Ops(x).Combine(yops).Remainder(x, y)
 }
 
+func (nm *NumberMethods) Rationalize(x any) any {
+	switch x := x.(type) {
+	case float32:
+		return nm.Rationalize(NewBigDecimalFromFloat64(float64(x)))
+	case float64:
+		return nm.Rationalize(NewBigDecimalFromFloat64(x))
+	case *BigDecimal:
+		bx := x.val
+		rat, _ := bx.Rat(nil)
+		if rat.IsInt() {
+			return NewBigIntFromGoBigInt(rat.Num())
+		}
+		return &Ratio{val: rat}
+	}
+	if !IsNumber(x) {
+		panic(fmt.Errorf("cannot rationalize %T", x))
+	}
+	return x
+}
+
 func (nm *NumberMethods) And(x, y any) any {
 	return bitOpsCast(x) & bitOpsCast(y)
 }