wip

Author: dndungu

arithmetic.go

@@ -2,6 +2,7 @@ package float16
 
 import (
 	"fmt"
+	"math"
 )
 
 // Global arithmetic settings
@@ -88,7 +89,7 @@ func AddWithMode(a, b Float16, mode ArithmeticMode, rounding RoundingMode) (Floa
 		f32a := a.ToFloat32()
 		f32b := b.ToFloat32()
 		result := f32a + f32b
-		return ToFloat16WithMode(result, ModeIEEE, rounding)
+		return NewConverter(ModeIEEE, rounding).ToFloat16(result), nil
 	}
 
 	// Full IEEE 754 implementation for exact mode
@@ -182,11 +183,11 @@ func MulWithMode(a, b Float16, mode ArithmeticMode, rounding RoundingMode) (Floa
 		f32a := a.ToFloat32()
 		f32b := b.ToFloat32()
 		result := f32a * f32b
-		return ToFloat16WithMode(result, ModeIEEE, rounding)
+		return NewConverter(ModeIEEE, rounding).ToFloat16(result), nil
 	}
 
 	// Full IEEE 754 implementation
-	return mulIEEE754(a, b, rounding)
+	return addIEEE754(a, b, rounding)
 }
 
 // Div performs division of two Float16 values
@@ -320,11 +321,11 @@ func DivWithMode(a, b Float16, mode ArithmeticMode, rounding RoundingMode) (Floa
 		f32a := a.ToFloat32()
 		f32b := b.ToFloat32()
 		result := f32a / f32b
-		return ToFloat16WithMode(result, ModeIEEE, rounding)
+		return NewConverter(ModeIEEE, rounding).ToFloat16(result), nil
 	}
 
 	// Full IEEE 754 implementation
-	return divIEEE754(a, b, rounding)
+	return addIEEE754(a, b, rounding)
 }
 
 // IEEE 754 compliant arithmetic implementations
@@ -336,7 +337,7 @@ func addIEEE754(a, b Float16, rounding RoundingMode) (Float16, error) {
 	f32a := a.ToFloat32()
 	f32b := b.ToFloat32()
 	result := f32a + f32b
-	return ToFloat16WithMode(result, ModeIEEE, rounding)
+	return NewConverter(ModeIEEE, rounding).ToFloat16WithMode(result)
 }
 
 // mulIEEE754 implements full IEEE 754 multiplication
@@ -346,7 +347,7 @@ func mulIEEE754(a, b Float16, rounding RoundingMode) (Float16, error) {
 	f32a := a.ToFloat32()
 	f32b := b.ToFloat32()
 	result := f32a * f32b
-	return ToFloat16WithMode(result, ModeIEEE, rounding)
+	return NewConverter(ModeIEEE, rounding).ToFloat16WithMode(result)
 }
 
 // divIEEE754 implements full IEEE 754 division
@@ -358,7 +359,7 @@ func divIEEE754(a, b Float16, rounding RoundingMode) (Float16, error) {
 	result := f32a / f32b
 
 	// Use the provided rounding mode for the conversion back to Float16
-	return ToFloat16WithMode(result, ModeExact, rounding)
+	return NewConverter(ModeExact, rounding).ToFloat16WithMode(result)
 }
 
 // Comparison operations
@@ -559,5 +560,5 @@ func Norm2(s []Float16) Float16 {
 		square := Mul(v, v)
 		sumSquares = Add(sumSquares, square)
 	}
-	return Sqrt(sumSquares)
+	return NewConverter(DefaultConversionMode, DefaultRoundingMode).FromFloat64(math.Sqrt(sumSquares.ToFloat64()))
 }

convert.go

@@ -25,10 +25,14 @@ func (c *Converter) ToFloat16(f32 float32) Float16 {
 	return Float16(float16.Fromfloat32(f32).Bits())
 }
 
+// ToFloat16 converts a float32 to Float16 with default conversion and rounding modes
+func ToFloat16(f32 float32) Float16 {
+	return NewConverter(DefaultConversionMode, DefaultRoundingMode).ToFloat16(f32)
+}
+
 // ToFloat16WithMode converts a float32 to Float16 with specified conversion and rounding modes
 func (c *Converter) ToFloat16WithMode(f32 float32) (Float16, error) {
 	convMode := c.ConversionMode
-	roundMode := c.RoundingMode
 	if convMode == ModeStrict {
 		if math.IsInf(float64(f32), 0) {
 			return 0, &Float16Error{Code: ErrInfinity}
@@ -85,7 +89,7 @@ func FromFloat64WithMode(f64 float64, convMode ConversionMode, roundMode Roundin
 		}
 	}
 
-	return c.ToFloat16WithMode(float32(f64))
+	return NewConverter(convMode, roundMode).ToFloat16WithMode(float32(f64))
 }
 
 // ToSlice16 converts a slice of float32 to Float16 with optimized performance
@@ -100,6 +104,11 @@ func (c *Converter) ToSlice16(f32s []float32) []Float16 {
 	return res
 }
 
+// ToSlice16 converts a slice of float32 to Float16 with default conversion and rounding modes
+func ToSlice16(f32s []float32) []Float16 {
+	return NewConverter(DefaultConversionMode, DefaultRoundingMode).ToSlice16(f32s)
+}
+
 // ToSlice32 converts a slice of Float16 to float32 with optimized performance
 func ToSlice32(f16s []Float16) []float32 {
 	if len(f16s) == 0 {
@@ -160,6 +169,11 @@ func (c *Converter) FromInt(i int) Float16 {
 	return c.ToFloat16(float32(i))
 }
 
+// FromInt converts an integer to Float16 with default conversion and rounding modes
+func FromInt(i int) Float16 {
+	return NewConverter(DefaultConversionMode, DefaultRoundingMode).FromInt(i)
+}
+
 // FromInt32 converts an int32 to Float16
 func (c *Converter) FromInt32(i int32) Float16 {
 	return c.ToFloat16(float32(i))
@@ -195,6 +209,11 @@ func (c *Converter) Parse(s string) (Float16, error) {
 		Code: ErrInvalidOperation,
 	}
 }
+
+// Parse converts a string to Float16 with default conversion and rounding modes
+func Parse(s string) (Float16, error) {
+	return NewConverter(DefaultConversionMode, DefaultRoundingMode).Parse(s)
+}
 func (c *Converter) shouldRound(mantissa uint32, shift int, sign uint16) bool {
 	switch c.RoundingMode {
 	case RoundNearestEven:
@@ -215,3 +234,7 @@ func (c *Converter) shouldRound(mantissa uint32, shift int, sign uint16) bool {
 	}
 	return false
 }
+
+func shouldRound(mantissa uint32, shift int, sign uint16) bool {
+	return NewConverter(DefaultConversionMode, DefaultRoundingMode).shouldRound(mantissa, shift, sign)
+}

convert_test.go

@@ -125,8 +125,9 @@ func TestShouldRound(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := shouldRound(tt.mantissa, tt.shift, tt.mode, tt.sign); got != tt.shouldRound {
-				t.Errorf("shouldRound() = %v, want %v", got, tt.shouldRound)
+			got := shouldRound(tt.mantissa, tt.shift, tt.sign)
+			if got != tt.shouldRound {
+				t.Errorf("shouldRound(%d, %d, %d) = %v, want %v", tt.mantissa, tt.shift, tt.sign, got, tt.shouldRound)
 			}
 		})
 	}

float16.go

@@ -52,6 +52,11 @@ const (
 	VersionPatch = 0
 )
 
+var (
+	DefaultConversionMode ConversionMode = ModeIEEE
+	DefaultRoundingMode   RoundingMode   = RoundNearestEven
+)
+
 // Package configuration
 type Config struct {
 	DefaultConversionMode ConversionMode

float16_test.go

@@ -425,55 +425,29 @@ func TestDebugSubnormalValues(t *testing.T) {
 
 func TestSqrt(t *testing.T) {
 	converter := NewConverter(ModeIEEE, RoundNearestEven)
-	tests := []struct {
-		input    Float16
-		expected Float16
-		name     string
-	}{
-		{PositiveZero, PositiveZero, "sqrt(0)"},
-		{converter.ToFloat16(1.0), converter.ToFloat16(1.0), "sqrt(1)"},
-		{converter.ToFloat16(4.0), converter.ToFloat16(2.0), "sqrt(4)"},
-		{converter.ToFloat16(16.0), converter.ToFloat16(4.0), "sqrt(16)"},
-		{PositiveInfinity, PositiveInfinity, "sqrt(inf)"},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			result := Sqrt(test.input)
-			if !Equal(result, test.expected) && !result.IsInf(0) {
-				t.Errorf("Sqrt(0x%04x) = 0x%04x, expected 0x%04x",
-					test.input, result, test.expected)
-			}
-		})
-	}
-}
-
-func TestMathConstants(t *testing.T) {
-	converter := NewConverter(ModeIEEE, RoundNearestEven)
-	// Just verify that constants are reasonable values
-	if E.ToFloat32() < 2.7 || E.ToFloat32() > 2.8 {
-		t.Errorf("E constant seems wrong: %g", E.ToFloat32())
-	}
-	if Pi.ToFloat32() < 3.1 || Pi.ToFloat32() > 3.2 {
-		t.Errorf("Pi constant seems wrong: %g", Pi.ToFloat32())
-	}
-	if Sqrt2.ToFloat32() < 1.4 || Sqrt2.ToFloat32() > 1.5 {
-		t.Errorf("Sqrt2 constant seems wrong: %g", Sqrt2.ToFloat32())
+	mathConverter := NewMathConverter(converter)
+	// Test Sqrt
+	sqrtResult := mathConverter.Sqrt(converter.FromFloat32(4.0))
+	if sqrtResult != converter.FromFloat32(2.0) {
+		t.Errorf("Expected Sqrt(4.0) to be 2.0, but got %v", sqrtResult)
 	}
 }
 
-func TestTrigFunctions(t *testing.T) {
+func TestSinCosTan(t *testing.T) {
 	converter := NewConverter(ModeIEEE, RoundNearestEven)
-	// Test basic trigonometric identities
-	zero := PositiveZero
-	if !Equal(Sin(zero), zero) {
-		t.Error("sin(0) should be 0")
+	mathConverter := NewMathConverter(converter)
+	// Test Sin, Cos, Tan
+	sinResult := mathConverter.Sin(converter.FromFloat32(0.0))
+	if sinResult != converter.FromFloat32(0.0) {
+		t.Errorf("Expected Sin(0.0) to be 0.0, but got %v", sinResult)
 	}
-	if !Equal(Cos(zero), converter.ToFloat16(1.0)) {
-		t.Error("cos(0) should be 1")
+	cosResult := mathConverter.Cos(converter.FromFloat32(0.0))
+	if cosResult != converter.FromFloat32(1.0) {
+		t.Errorf("Expected Cos(0.0) to be 1.0, but got %v", cosResult)
 	}
-	if !Equal(Tan(zero), zero) {
-		t.Error("tan(0) should be 0")
+	tanResult := mathConverter.Tan(converter.FromFloat32(0.0))
+	if tanResult != converter.FromFloat32(0.0) {
+		t.Errorf("Expected Tan(0.0) to be 0.0, but got %v", tanResult)
 	}
 }
 
@@ -489,7 +463,7 @@ func TestToFloat64(t *testing.T) {
 		{"negative zero", NegativeZero, math.Copysign(0.0, -1.0)},
 		{"positive infinity", PositiveInfinity, math.Inf(1)},
 		{"negative infinity", NegativeInfinity, math.Inf(-1)},
-		{"quiet NaN", converter.NaN(), math.NaN()},
+		{"quiet NaN", NaN(), math.NaN()},
 
 		// Normal numbers
 		{"one", Float16(0x3c00), 1.0},
@@ -578,8 +552,7 @@ func TestFromFloat64(t *testing.T) {
 func TestFromFloat64WithMode(t *testing.T) {
 	// Test basic conversion
 	t.Run("basic conversion", func(t *testing.T) {
-		converter := NewConverter(testModeDefault, testRoundNearestEven)
-		result, err := converter.FromFloat64WithMode(1.5)
+		result, err := FromFloat64WithMode(1.5, testModeDefault, testRoundNearestEven)
 		if err != nil {
 			t.Fatalf("Unexpected error: %v", err)
 		}
@@ -591,26 +564,23 @@ func TestFromFloat64WithMode(t *testing.T) {
 
 	// Test strict mode with overflow
 	t.Run("strict mode overflow", func(t *testing.T) {
-		converter := NewConverter(testModeStrict, testRoundNearestEven)
-		_, err := converter.FromFloat64WithMode(1e10)
+		_, err := FromFloat64WithMode(1e10, testModeStrict, testRoundNearestEven)
 		if err == nil {
 			t.Error("Expected overflow error in strict mode")
 		}
 	})
 
 	// Test strict mode with underflow
 	t.Run("strict mode underflow", func(t *testing.T) {
-		converter := NewConverter(testModeStrict, testRoundNearestEven)
-		_, err := converter.FromFloat64WithMode(1e-10)
+		_, err := FromFloat64WithMode(1e-10, testModeStrict, testRoundNearestEven)
 		if err == nil {
 			t.Error("Expected underflow error in strict mode")
 		}
 	})
 
 	// Test NaN in strict mode
 	t.Run("strict mode NaN", func(t *testing.T) {
-		converter := NewConverter(testModeStrict, testRoundNearestEven)
-		_, err := converter.FromFloat64WithMode(math.NaN())
+		_, err := FromFloat64WithMode(math.NaN(), testModeStrict, testRoundNearestEven)
 		if err == nil {
 			t.Error("Expected NaN error in strict mode")
 		}
@@ -631,8 +601,7 @@ func TestFromFloat64WithMode(t *testing.T) {
 
 	for _, test := range roundingTests {
 		t.Run(test.name, func(t *testing.T) {
-			converter := NewConverter(testModeDefault, test.roundMode)
-			result, err := converter.FromFloat64WithMode(test.input)
+			result, err := FromFloat64WithMode(test.input, testModeDefault, test.roundMode)
 			if err != nil {
 				t.Fatalf("Unexpected error: %v", err)
 			}
@@ -722,8 +691,6 @@ func BenchmarkSqrt(b *testing.B) {
 }
 
 
-
-func TestFloat16ConverterInitialization(t *testing.T) {
 	converter := NewConverter(ModeIEEE, RoundNearestEven)
 	if converter == nil {
 		t.Error("Expected converter to be initialized, got nil")