Made .Mul() and .Div() more robust in the face of overflows in intermediate operations

Author: richardwilkes

fixed/fixed128/fixed128.go

@@ -39,11 +39,6 @@ func Minimum[T fixed.Dx]() Int[T] {
 	return Int[T]{data: num128.MinInt}
 }
 
-// MaxSafeMultiply returns the maximum value that can be safely multiplied without overflow.
-func MaxSafeMultiply[T fixed.Dx]() Int[T] {
-	return Maximum[T]().Div(Multiplier[T]())
-}
-
 // MaxDecimalDigits returns the maximum number of digits after the decimal that will be used.
 func MaxDecimalDigits[T fixed.Dx]() int {
 	var t T

fixed/fixed128/fixed128_test.go

@@ -422,11 +422,6 @@ func testBoundaryValues[T fixed.Dx](t *testing.T) {
 	minValue := fixed128.Minimum[T]()
 	c.True(maxValue.GreaterThan(minValue))
 	c.True(minValue.LessThan(maxValue))
-
-	// Test MaxSafeMultiply
-	maxSafe := fixed128.MaxSafeMultiply[T]()
-	c.True(maxSafe.LessThan(maxValue))
-	c.True(maxSafe.GreaterThan(minValue))
 }
 
 func TestMinMax(t *testing.T) {

fixed/fixed64/int.go

@@ -18,25 +18,24 @@ import (
 
 	"github.com/richardwilkes/toolbox/v2/errs"
 	"github.com/richardwilkes/toolbox/v2/fixed"
+	"github.com/richardwilkes/toolbox/v2/num128"
 	"github.com/richardwilkes/toolbox/v2/xstrings"
 	"golang.org/x/exp/constraints"
 	"gopkg.in/yaml.v3"
 )
 
-const (
-	// Max holds the maximum value.
-	Max = math.MaxInt64
-	// Min holds the minimum value.
-	Min = math.MinInt64
-)
-
 // Int holds a fixed-point value. Values are truncated, not rounded. Values can be added and subtracted directly. For
 // multiplication and division, the provided Mul() and Div() methods should be used.
 type Int[T fixed.Dx] int64
 
-// MaxSafeMultiply returns the maximum value that can be safely multiplied without overflow.
-func MaxSafeMultiply[T fixed.Dx]() Int[T] {
-	return Int[T](Max / Multiplier[T]())
+// Maximum returns the maximum possible value the type can hold.
+func Maximum[T fixed.Dx]() Int[T] {
+	return Int[T](math.MaxInt64)
+}
+
+// Minimum returns the minimum possible value the type can hold.
+func Minimum[T fixed.Dx]() Int[T] {
+	return Int[T](math.MinInt64)
 }
 
 // MaxDecimalDigits returns the maximum number of digits after the decimal that will be used.
@@ -156,12 +155,32 @@ func AsFloatChecked[T fixed.Dx, TO constraints.Float](f Int[T]) (TO, error) {
 
 // Mul multiplies this value by the passed-in value, returning a new value.
 func (f Int[T]) Mul(value Int[T]) Int[T] {
-	return f * value / Int[T](Multiplier[T]())
+	return f.mul64(value, Int[T](Multiplier[T]()))
+}
+
+func (f Int[T]) mul64(value, div Int[T]) Int[T] {
+	if f == 0 || value == 0 {
+		return 0
+	}
+	if f == 1 {
+		return value
+	}
+	if value == 1 {
+		return f
+	}
+	result := f * value
+	if f != math.MinInt64 && value != math.MinInt64 && result/value == f {
+		return result / div
+	}
+	return Int[T](num128.IntFrom64(int64(f)).
+		Mul(num128.IntFrom64(int64(value))).
+		Div(num128.IntFrom64(int64(div))).
+		AsInt64())
 }
 
 // Div divides this value by the passed-in value, returning a new value.
 func (f Int[T]) Div(value Int[T]) Int[T] {
-	return f * Int[T](Multiplier[T]()) / value
+	return f.mul64(Int[T](Multiplier[T]()), value)
 }
 
 // Mod returns the remainder after subtracting all full multiples of the passed-in value.

fixed/fixed64/int_test.go

@@ -12,12 +12,14 @@ package fixed64_test
 import (
 	"encoding/json"
 	"fmt"
+	"math"
 	"strings"
 	"testing"
 
 	"github.com/richardwilkes/toolbox/v2/check"
 	"github.com/richardwilkes/toolbox/v2/fixed"
 	"github.com/richardwilkes/toolbox/v2/fixed/fixed64"
+	"github.com/richardwilkes/toolbox/v2/num128"
 	"gopkg.in/yaml.v3"
 )
 
@@ -283,24 +285,6 @@ func testYAMLActual[T fixed.Dx](t *testing.T, v fixed64.Int[T]) {
 	c.Equal(e1, e2)
 }
 
-func TestMaxSafeMultiply(t *testing.T) {
-	testMaxSafeMultiply[fixed.D1](t)
-	testMaxSafeMultiply[fixed.D2](t)
-	testMaxSafeMultiply[fixed.D3](t)
-	testMaxSafeMultiply[fixed.D4](t)
-	testMaxSafeMultiply[fixed.D5](t)
-	testMaxSafeMultiply[fixed.D6](t)
-}
-
-func testMaxSafeMultiply[T fixed.Dx](t *testing.T) {
-	c := check.New(t)
-
-	// Test MaxSafeMultiply
-	maxSafe := fixed64.MaxSafeMultiply[T]()
-	c.True(maxSafe > 0)
-	c.True(int64(maxSafe) < fixed64.Max)
-}
-
 func TestMinMax(t *testing.T) {
 	testMinMax[fixed.D1](t)
 	testMinMax[fixed.D2](t)
@@ -687,3 +671,17 @@ func testAdditionalEdgeCases[T fixed.Dx](t *testing.T) {
 	})
 	c.HasError(err)
 }
+
+func TestMulOverflow(t *testing.T) {
+	c := check.New(t)
+	v1 := int64(math.MaxInt64 / 10000)
+	v1 -= v1 / 10
+	m1 := int64(110)
+	d1 := int64(100)
+	expected := num128.IntFrom64(v1).Mul(num128.IntFrom64(m1)).Div(num128.IntFrom64(d1)).AsInt64()
+	v2 := fixed64.FromInteger[fixed.D4](v1)
+	m2 := fixed64.FromInteger[fixed.D4](m1)
+	d2 := fixed64.FromInteger[fixed.D4](d1)
+	result := fixed64.AsInteger[fixed.D4, int64](v2.Mul(m2.Div(d2)))
+	c.Equal(expected, result)
+}