refactor(format): Apply formatting and incorporate developer changes

Author: dndungu

Makefile

@@ -21,9 +21,15 @@ race:
 vet:
 	GOWORK=off go vet $(PKG)
 
-# Auto-format code
-fmt:
-	gofmt -s -w .
+format:
+	@echo "🎨 Applying code formatters..."
+	@echo "  - Standard Go formatting..."
+	@gofmt -w .
+	@echo "  - Organizing imports..."
+	@goimports -w .
+	@echo "  - Strict formatting with gofumpt..."
+	@gofumpt -w . 2>/dev/null || echo "    (gofumpt not available, skipping)"
+	@echo "✅ Code formatting complete"
 
 # Check formatting without modifying files; fails if formatting needed
 fmt-check:

arithmetic.go

@@ -525,7 +525,7 @@ func ScaleSlice(s []Float16, scalar Float16) []Float16 {
 
 // SumSlice returns the sum of all elements in the slice
 func SumSlice(s []Float16) Float16 {
-	var sum Float16 = PositiveZero
+	sum := PositiveZero
 	for _, v := range s {
 		sum = Add(sum, v)
 	}
@@ -538,7 +538,7 @@ func DotProduct(a, b []Float16) Float16 {
 		panic("float16: slice length mismatch")
 	}
 
-	var sum Float16 = PositiveZero
+	sum := PositiveZero
 	for i := range a {
 		product := Mul(a[i], b[i])
 		sum = Add(sum, product)
@@ -548,7 +548,7 @@ func DotProduct(a, b []Float16) Float16 {
 
 // Norm2 computes the L2 norm (Euclidean norm) of a Float16 slice
 func Norm2(s []Float16) Float16 {
-	var sumSquares Float16 = PositiveZero
+	sumSquares := PositiveZero
 	for _, v := range s {
 		square := Mul(v, v)
 		sumSquares = Add(sumSquares, square)

arithmetic_rounding_test.go

@@ -18,10 +18,10 @@ func modes() []RoundingMode {
 
 func TestAddWithMode_RoundingMatchesConverter(t *testing.T) {
 	cases := [][2]float32{
-		{1.0, float32(math.Pow(2, -11))},     // halfway between 1.0 and next
-		{1.0, 1e-3},                          // general positive
-		{-1.0, float32(math.Pow(2, -11))},    // negative with halfway increment
-		{-0.75, 0.125},                       // mixed signs, exact binary fractions
+		{1.0, float32(math.Pow(2, -11))},  // halfway between 1.0 and next
+		{1.0, 1e-3},                       // general positive
+		{-1.0, float32(math.Pow(2, -11))}, // negative with halfway increment
+		{-0.75, 0.125},                    // mixed signs, exact binary fractions
 	}
 
 	for _, c := range cases {
@@ -47,10 +47,10 @@ func TestAddWithMode_RoundingMatchesConverter(t *testing.T) {
 
 func TestMulWithMode_RoundingMatchesConverter(t *testing.T) {
 	cases := [][2]float32{
-		{1.25, 0.2},          // positive * positive
-		{-1.25, 0.2},         // negative * positive
-		{1.5, -0.75},         // positive * negative
-		{-0.5, -0.125},       // negative * negative
+		{1.25, 0.2},    // positive * positive
+		{-1.25, 0.2},   // negative * positive
+		{1.5, -0.75},   // positive * negative
+		{-0.5, -0.125}, // negative * negative
 		{float32(math.Pow(2, -3)), float32(math.Pow(2, -8))}, // exact powers of two
 	}
 
@@ -77,11 +77,11 @@ func TestMulWithMode_RoundingMatchesConverter(t *testing.T) {
 
 func TestDivWithMode_RoundingMatchesConverter(t *testing.T) {
 	cases := [][2]float32{
-		{1.25, 0.2},          // positive / positive
-		{-1.25, 0.2},         // negative / positive
-		{1.5, -0.75},         // positive / negative
-		{-0.5, -0.125},       // negative / negative
-		{7.0, 3.0},           // non-terminating in binary
+		{1.25, 0.2},    // positive / positive
+		{-1.25, 0.2},   // negative / positive
+		{1.5, -0.75},   // positive / negative
+		{-0.5, -0.125}, // negative / negative
+		{7.0, 3.0},     // non-terminating in binary
 	}
 
 	for _, c := range cases {

bfloat16.go

@@ -86,10 +86,10 @@ func BFloat16FromFloat32WithRounding(f float32, mode RoundingMode) BFloat16 {
 
 	// Extract the high 16 bits (sign, exponent, and 7 MSBs of mantissa)
 	bfloat16Bits := bits >> 16
-	
+
 	// Check the bit at position 15 of the original float32 bits (the first bit to be truncated)
 	roundBit := (bits >> 15) & 0x1
-	
+
 	// Check if any of the bits from position 0 to 14 are non-zero
 	stickyBits := bits & 0x7FFF
 
@@ -133,7 +133,6 @@ func BFloat16FromFloat32WithRounding(f float32, mode RoundingMode) BFloat16 {
 	return BFloat16(bfloat16Bits)
 }
 
-
 // ToFloat32 converts BFloat16 to float32
 func (b BFloat16) ToFloat32() float32 {
 	// Expand back to 32 bits by shifting left 16 positions
@@ -152,7 +151,6 @@ func BFloat16FromFloat64WithRounding(f float64, mode RoundingMode) BFloat16 {
 	return BFloat16FromFloat32WithRounding(float32(f), mode)
 }
 
-
 // BFloat16FromFloat32WithMode converts a float32 to BFloat16 with specified conversion and rounding modes.
 func BFloat16FromFloat32WithMode(f32 float32, convMode ConversionMode, roundMode RoundingMode) (BFloat16, error) {
 	// First, perform the rounding conversion

bfloat16_conversion_test.go

@@ -272,4 +272,4 @@ func TestBFloat16FromFloat32WithMode(t *testing.T) {
 			}
 		})
 	}
-}
+}

convert.go

@@ -212,44 +212,44 @@ func (f Float16) ToFloat64() float64 {
 // shouldRound determines whether to round up during conversion
 // This is a helper function used in conversion algorithms
 func shouldRound(mantissa uint32, shift int, sign uint16) bool {
-    if shift <= 0 {
-        return false
-    }
-
-    // Bits about to be discarded
-    guard := (mantissa >> uint(shift-1)) & 1
-    sticky := mantissa & ((1 << uint(shift-1)) - 1)
-    lsb := (mantissa >> uint(shift)) & 1
-    anyDiscarded := (guard | (boolToUint(sticky != 0))) == 1
-
-    switch DefaultRoundingMode {
-    case RoundNearestEven:
-        // Round up if guard=1 and (sticky!=0 or LSB is 1) => ties to even
-        return guard == 1 && (sticky != 0 || lsb == 1)
-    case RoundNearestAway:
-        // Round up on half or more (guard=1). If less than half (guard=0), do not round.
-        // sticky doesn't affect decision except that if sticky>0, it's strictly more than half.
-        return guard == 1 || sticky != 0
-    case RoundTowardZero:
-        return false
-    case RoundTowardPositive:
-        // Round up for positive numbers if any discarded bits are non-zero
-        return (sign&SignMask) == 0 && anyDiscarded
-    case RoundTowardNegative:
-        // Round up (i.e., toward -inf increases magnitude) for negative numbers if discarded bits
-        return (sign&SignMask) != 0 && anyDiscarded
-    default:
-        // Invalid rounding mode: do not round
-        return false
-    }
+	if shift <= 0 {
+		return false
+	}
+
+	// Bits about to be discarded
+	guard := (mantissa >> uint(shift-1)) & 1
+	sticky := mantissa & ((1 << uint(shift-1)) - 1)
+	lsb := (mantissa >> uint(shift)) & 1
+	anyDiscarded := (guard | (boolToUint(sticky != 0))) == 1
+
+	switch DefaultRoundingMode {
+	case RoundNearestEven:
+		// Round up if guard=1 and (sticky!=0 or LSB is 1) => ties to even
+		return guard == 1 && (sticky != 0 || lsb == 1)
+	case RoundNearestAway:
+		// Round up on half or more (guard=1). If less than half (guard=0), do not round.
+		// sticky doesn't affect decision except that if sticky>0, it's strictly more than half.
+		return guard == 1 || sticky != 0
+	case RoundTowardZero:
+		return false
+	case RoundTowardPositive:
+		// Round up for positive numbers if any discarded bits are non-zero
+		return (sign&SignMask) == 0 && anyDiscarded
+	case RoundTowardNegative:
+		// Round up (i.e., toward -inf increases magnitude) for negative numbers if discarded bits
+		return (sign&SignMask) != 0 && anyDiscarded
+	default:
+		// Invalid rounding mode: do not round
+		return false
+	}
 }
 
 // boolToUint converts a bool to 0/1 as uint32
 func boolToUint(b bool) uint32 {
-    if b {
-        return 1
-    }
-    return 0
+	if b {
+		return 1
+	}
+	return 0
 }
 
 // Parse converts a string to a Float16 value
@@ -355,4 +355,3 @@ func ParseFloat(s string, precision int) (Float16, error) {
 	}
 	return FromFloat32(float32(f32)), nil
 }
-

float16.go

@@ -1,6 +1,8 @@
-// Package float16 implements the 16-bit floating point data type (IEEE 754-2008).
+// Package float16 implements both 16-bit floating point data types:
+// - Float16: IEEE 754-2008 half-precision (1 sign, 5 exponent, 10 mantissa bits)
+// - BFloat16: "Brain Floating Point" format (1 sign, 8 exponent, 7 mantissa bits)
 //
-// This implementation provides conversion between float16 and other floating-point types
+// This implementation provides conversion between both types and other floating-point types
 // (float32 and float64) with support for various rounding modes and error handling.
 //
 // # Special Values

math.go

@@ -458,7 +458,7 @@ func Remainder(f, divisor Float16) Float16 {
 
 // Mathematical constants as Float16 values
 var (
-		E       = FromFloat32(float32(math.E))       // Euler's number
+	E       = FromFloat32(float32(math.E))       // Euler's number
 	Pi      = FromFloat32(float32(math.Pi))      // Pi
 	Phi     = FromFloat32(float32(math.Phi))     // Golden ratio
 	Sqrt2   = FromFloat32(float32(math.Sqrt2))   // Square root of 2

math_extra_test.go

@@ -11,7 +11,7 @@ func TestAsin(t *testing.T) {
 		want Float16
 	}{
 		{"Asin(0)", PositiveZero, PositiveZero},
-		{"Asin(1)", FromFloat32(1.0), FromBits(0x3E48)}, // Approx. Pi/2
+		{"Asin(1)", FromFloat32(1.0), FromBits(0x3E48)},   // Approx. Pi/2
 		{"Asin(-1)", FromFloat32(-1.0), FromBits(0xBE48)}, // Approx. -Pi/2
 		{"Asin(NaN)", QuietNaN, QuietNaN},
 		{"Asin(2)", FromFloat32(2.0), QuietNaN},
@@ -55,7 +55,7 @@ func TestAtan(t *testing.T) {
 		want Float16
 	}{
 		{"Atan(0)", PositiveZero, PositiveZero},
-		{"Atan(inf)", PositiveInfinity, FromBits(0x3E48)}, // Approx. Pi/2
+		{"Atan(inf)", PositiveInfinity, FromBits(0x3E48)},  // Approx. Pi/2
 		{"Atan(-inf)", NegativeInfinity, FromBits(0xBE48)}, // Approx. -Pi/2
 		{"Atan(NaN)", QuietNaN, QuietNaN},
 	}
@@ -333,4 +333,4 @@ func TestY1(t *testing.T) {
 		})
 	}
 }
-*/
+*/

types.go

@@ -280,6 +280,7 @@ func (f Float16) String() string {
 func (f Float16) GoString() string {
 	return fmt.Sprintf("float16.FromBits(0x%04x)", uint16(f))
 }
+
 func (f Float16) ToInt32() int32 {
 	return int32(f.ToFloat32())
 }