Chore/linting issues (#132)

fredbi · web-flow · commit ebc624612f47 · 2025-08-20T16:29:39.000+02:00
* improve equality comparison for floats

Signed-off-by: Pavel Afanasev &lt;afansvme@yandex.ru&gt;

* IsFloat64JSONInteger check
* fixed short-circuit case
* added benchmark and verified that the new version is about 14% faster
* experimental code to compare rounding methods

Signed-off-by: Frédéric BIDON &lt;fredbi@yahoo.com&gt;
diff --git a/conv/convert.go b/conv/convert.go
@@ -32,23 +32,21 @@ func IsFloat64AJSONInteger(f float64) bool {
 	if math.IsNaN(f) || math.IsInf(f, 0) || f < minJSONFloat || f > maxJSONFloat {
 		return false
 	}
-	fa := math.Abs(f)
-	g := float64(uint64(f))
-	ga := math.Abs(g)
-
-	diff := math.Abs(f - g)
-
-	// more info: https://floating-point-gui.de/errors/comparison/#look-out-for-edge-cases
-	switch {
-	case f == g: // best case
+	rounded := math.Round(f)
+	if f == rounded {
 		return true
-	case f == float64(int64(f)) || f == float64(uint64(f)): // optimistic case
+	}
+	if rounded == 0 { // f = 0.0 exited above
+		return false
+	}
+
+	diff := math.Abs(f - rounded)
+	if diff == 0 {
 		return true
-	case f == 0 || g == 0 || diff < math.SmallestNonzeroFloat64: // very close to 0 values
-		return diff < (epsilon * math.SmallestNonzeroFloat64)
 	}
-	// check the relative error
-	return diff/math.Min(fa+ga, math.MaxFloat64) < epsilon
+
+	// relative error Abs{f - Round(f)) / Round(f)} < ε ; Round(f)
+	return diff < epsilon*math.Abs(rounded)
 }
 
 // ConvertFloat turns a string into a float numerical value.
diff --git a/conv/convert_format_test.go b/conv/convert_format_test.go
@@ -19,6 +19,7 @@ import (
 	"io"
 	"math"
 	"math/big"
+	"math/bits"
 	"slices"
 	"strconv"
 	"strings"
@@ -305,18 +306,302 @@ func TestConvertUinteger(t *testing.T) {
 }
 
 func TestIsFloat64AJSONInteger(t *testing.T) {
-	assert.False(t, IsFloat64AJSONInteger(math.Inf(1)))
-	assert.False(t, IsFloat64AJSONInteger(maxJSONFloat+1))
-	assert.False(t, IsFloat64AJSONInteger(minJSONFloat-1))
-	assert.False(t, IsFloat64AJSONInteger(math.SmallestNonzeroFloat64))
-
-	assert.True(t, IsFloat64AJSONInteger(1.0))
-	assert.True(t, IsFloat64AJSONInteger(maxJSONFloat))
-	assert.True(t, IsFloat64AJSONInteger(minJSONFloat))
-	assert.True(t, IsFloat64AJSONInteger(1/0.01*67.15000001))
-	assert.True(t, IsFloat64AJSONInteger(math.SmallestNonzeroFloat64/2))
-	assert.True(t, IsFloat64AJSONInteger(math.SmallestNonzeroFloat64/3))
-	assert.True(t, IsFloat64AJSONInteger(math.SmallestNonzeroFloat64/4))
+	t.Run("should not be integers", testNotIntegers(IsFloat64AJSONInteger, false))
+	t.Run("should be integers", testIntegers(IsFloat64AJSONInteger, false))
+}
+
+func TestPreviousIsFloat64AJSONInteger(t *testing.T) {
+	t.Run("should not be integers", testNotIntegers(previousIsFloat64JSONInteger, false))
+	t.Run("should be integers", testIntegers(previousIsFloat64JSONInteger, true))
+}
+
+func TestBitWiseIsFloat64AJSONInteger(t *testing.T) {
+	t.Run("should not be integers", testNotIntegers(bitwiseIsFloat64JSONInteger, false))
+	t.Run("should be integers", testIntegers(bitwiseIsFloat64JSONInteger, false))
+}
+
+func TestBitWise2IsFloat64AJSONInteger(t *testing.T) {
+	t.Run("should not be integers", testNotIntegers(bitwiseIsFloat64JSONInteger2, false))
+	t.Run("should be integers", testIntegers(bitwiseIsFloat64JSONInteger2, false))
+}
+
+func TestStdlib2IsFloat64AJSONInteger(t *testing.T) {
+	t.Run("should not be integers", testNotIntegers(stdlibIsFloat64JSONInteger, true))
+	t.Run("should be integers", testIntegers(stdlibIsFloat64JSONInteger, true))
+}
+
+func testNotIntegers(fn func(float64) bool, skipKnownFailure bool) func(*testing.T) {
+	_ = skipKnownFailure
+
+	return func(t *testing.T) {
+		assert.False(t, fn(math.Inf(1)))
+		assert.False(t, fn(maxJSONFloat+1))
+		assert.False(t, fn(minJSONFloat-1))
+		assert.False(t, fn(math.SmallestNonzeroFloat64))
+		assert.False(t, fn(0.5))
+		assert.False(t, fn(0.25))
+		assert.False(t, fn(1.00/func() float64 { return 2.00 }()))
+		assert.False(t, fn(1.00/func() float64 { return 4.00 }()))
+		assert.False(t, fn(epsilon))
+	}
+}
+
+func testIntegers(fn func(float64) bool, skipKnownFailure bool) func(*testing.T) {
+	// wrapping in a function forces non-constant evaluation to test float64 rounding behavior
+	return func(t *testing.T) {
+		assert.True(t, fn(0.0))
+		assert.True(t, fn(1.0))
+		assert.True(t, fn(maxJSONFloat))
+		assert.True(t, fn(minJSONFloat))
+		if !skipKnownFailure {
+			assert.True(t, fn(1/0.01*67.15000001))
+		}
+		if !skipKnownFailure {
+			assert.True(t, fn(1.00/func() float64 { return 0.01 }()*4643.4))
+		}
+		assert.True(t, fn(1.00/func() float64 { return 1.00 / 3.00 }()))
+		assert.True(t, fn(math.SmallestNonzeroFloat64/2))
+		assert.True(t, fn(math.SmallestNonzeroFloat64/3))
+		assert.True(t, fn(math.SmallestNonzeroFloat64/4))
+	}
+}
+
+func BenchmarkIsFloat64JSONInteger(b *testing.B) {
+	b.ResetTimer()
+	b.ReportAllocs()
+	b.SetBytes(0)
+
+	b.Run("new float vs integer comparison", benchmarkIsFloat64JSONInteger(IsFloat64AJSONInteger))
+	b.Run("previous float vs integer comparison", benchmarkIsFloat64JSONInteger(previousIsFloat64JSONInteger))
+	b.Run("bitwise float vs integer comparison", benchmarkIsFloat64JSONInteger(bitwiseIsFloat64JSONInteger))
+	b.Run("bitwise float vs integer comparison (2)", benchmarkIsFloat64JSONInteger(bitwiseIsFloat64JSONInteger2))
+	b.Run("stdlib float vs integer comparison (2)", benchmarkIsFloat64JSONInteger(stdlibIsFloat64JSONInteger))
+}
+
+func BenchmarkBitwise(b *testing.B) {
+	b.ResetTimer()
+	b.ReportAllocs()
+	b.SetBytes(0)
+
+	b.Run("bitwise float vs integer comparison (2)", benchmarkIsFloat64JSONInteger(bitwiseIsFloat64JSONInteger2))
+}
+
+func previousIsFloat64JSONInteger(f float64) bool {
+	if math.IsNaN(f) || math.IsInf(f, 0) || f < minJSONFloat || f > maxJSONFloat {
+		return false
+	}
+	fa := math.Abs(f)
+	g := float64(uint64(f))
+	ga := math.Abs(g)
+
+	diff := math.Abs(f - g)
+
+	// more info: https://floating-point-gui.de/errors/comparison/#look-out-for-edge-cases
+	switch {
+	case f == g: // best case
+		return true
+	case f == float64(int64(f)) || f == float64(uint64(f)): // optimistic case
+		return true
+	case f == 0 || g == 0 || diff < math.SmallestNonzeroFloat64: // very close to 0 values
+		return diff < (epsilon * math.SmallestNonzeroFloat64)
+	}
+	// check the relative error
+	return diff/math.Min(fa+ga, math.MaxFloat64) < epsilon
+}
+
+func stdlibIsFloat64JSONInteger(f float64) bool {
+	if f < minJSONFloat || f > maxJSONFloat {
+		return false
+	}
+	var bf big.Float
+	bf.SetFloat64(f)
+
+	return bf.IsInt()
+}
+
+func bitwiseIsFloat64JSONInteger(f float64) bool {
+	if math.IsNaN(f) || math.IsInf(f, 0) || f < minJSONFloat || f > maxJSONFloat {
+		return false
+	}
+
+	mant, exp := math.Frexp(f) // get normalized mantissa
+	if exp == 0 && mant == 0 {
+		return true
+	}
+	if exp <= 0 {
+		return false
+	}
+
+	zeros := bits.TrailingZeros64(uint64(mant))
+
+	return bits.UintSize-zeros <= exp
+}
+
+func bitwiseIsFloat64JSONInteger2(f float64) bool {
+	if f == 0 {
+		return true
+	}
+
+	if f < minJSONFloat || f > maxJSONFloat || f != f || f < -math.MaxFloat64 || f > math.MaxFloat64 {
+		return false
+	}
+
+	// inlined
+	var (
+		mant uint64
+		exp  int
+	)
+	{
+		const smallestNormal = 2.2250738585072014e-308 // 2**-1022
+
+		if math.Abs(f) < smallestNormal {
+			f *= (1 << shift) // x 2^52
+			exp = -shift
+		}
+
+		x := math.Float64bits(f)
+		exp += int((x>>shift)&mask) - bias + 1 //nolint:gosec // x>>12 & 0x7FF - 1022 : extract exp, recentered from bias
+
+		x &^= mask << shift       // x= x &^ 0x7FF << 12 (clear 11 exp bits then shift 12)
+		x |= (-1 + bias) << shift // x = x | 1022 << 12 ==> or with 1022 as exp location
+		mant = uint64(math.Float64frombits(x))
+	}
+	/*
+		{
+			x := math.Float64bits(f)
+			exp = int(x>>shift) & mask
+
+			if exp < bias {
+			} else if exp < bias+shift { // 1023 + 12
+				exp -= bias
+			}
+		}
+	*/
+	/*
+		e := uint(bits>>shift) & mask
+		if e < bias {
+			// Round abs(x) < 1 including denormals.
+			bits &= signMask // +-0
+			if e == bias-1 {
+				bits |= uvone // +-1
+			}
+		} else if e < bias+shift {
+			// Round any abs(x) >= 1 containing a fractional component [0,1).
+			//
+			// Numbers with larger exponents are returned unchanged since they
+			// must be either an integer, infinity, or NaN.
+			const half = 1 << (shift - 1)
+			e -= bias
+			bits += half >> e
+			bits &^= fracMask >> e
+		}
+	*/
+
+	// It returns frac and exp satisfying f == frac × 2**exp,
+	// with the absolute value of frac in the interval [½, 1).
+	if exp <= 0 {
+		return false
+	}
+
+	zeros := bits.TrailingZeros64(mant)
+
+	return bits.UintSize-zeros <= exp
+}
+
+const (
+	mask  = 0x7FF
+	shift = 64 - 11 - 1
+	// uvinf    = 0x7FF0000000000000
+	// uvneginf = 0xFFF0000000000000
+	bias     = 1023
+	fracMask = 1<<shift - 1
+)
+
+/*
+func isNaN(x uint64) bool { // f != f
+	return uint32(x>>shift)&mask == mask // && x != uvinf && x != uvneginf
+}
+
+func isInf(x uint64) bool { // f < - math.MaxFloat || f > math.MaxFloat
+	return x == uvinf || x == uvneginf
+}
+*/
+
+/*
+func frexp(f float64) (frac uint64, exp int) {
+	const smallestNormal = 2.2250738585072014e-308 // 2**-1022
+	g := f
+
+	if math.Abs(f) < smallestNormal {
+		g *= (1 << 52)
+		exp = -52
+	}
+
+	x := math.Float64bits(g)
+	exp += int((x>>shift)&mask) - bias + 1
+	x &^= mask << shift
+	x |= (-1 + bias) << shift
+	frac = uint64(math.Float64frombits(x))
+
+	return
+}
+*/
+
+func benchmarkIsFloat64JSONInteger(fn func(float64) bool) func(*testing.B) {
+	assertCode := func() {
+		panic("unexpected result during benchmark")
+	}
+
+	return func(b *testing.B) {
+		testFunc := func() {
+			if fn(math.Inf(1)) {
+				assertCode()
+			}
+			if fn(maxJSONFloat + 1) {
+				assertCode()
+			}
+			if fn(minJSONFloat - 1) {
+				assertCode()
+			}
+			if fn(math.SmallestNonzeroFloat64) {
+				assertCode()
+			}
+			if fn(0.5) {
+				assertCode()
+			}
+
+			if !fn(1.0) {
+				assertCode()
+			}
+			if !fn(maxJSONFloat) {
+				assertCode()
+			}
+			if !fn(minJSONFloat) {
+				assertCode()
+			}
+			if !fn(1 / 0.01 * 67.15000001) {
+				assertCode()
+			}
+			/* can't compare both versions on this test case
+			if !fn(1 / func() float64 { return 0.01 }() * 4643.4) {
+				assertCode()
+			}
+			*/
+			if !fn(math.SmallestNonzeroFloat64 / 2) {
+				assertCode()
+			}
+			if !fn(math.SmallestNonzeroFloat64 / 3) {
+				assertCode()
+			}
+			if !fn(math.SmallestNonzeroFloat64 / 4) {
+				assertCode()
+			}
+		}
+
+		for n := 0; n < b.N; n++ {
+			testFunc()
+		}
+	}
 }
 
 // test utilities
