Add Coerce functions to Number (#404)

* Add `Coerse` functions to `Number`

Expands/replaces #143

Author: klauspost

msgp/number.go

@@ -2,6 +2,7 @@ package msgp
 
 import (
 	"math"
+	"math/bits"
 	"strconv"
 )
 
@@ -77,7 +78,7 @@ func (n *Number) Uint() (uint64, bool) {
 }
 
 // Float casts the number to a float64, and
-// returns whether or not that was the underlying
+// returns whether that was the underlying
 // type (either a float64 or a float32).
 func (n *Number) Float() (float64, bool) {
 	switch n.typ {
@@ -208,6 +209,111 @@ func (n *Number) EncodeMsg(w *Writer) error {
 	}
 }
 
+// CoerceInt attempts to coerce the value of
+// the number into a signed integer and returns
+// whether it was successful.
+// "Success" implies that no precision in the value of
+// the number was lost, which means that the number was an integer or
+// a floating point that mapped exactly to an integer without rounding.
+func (n *Number) CoerceInt() (int64, bool) {
+	switch n.typ {
+	case InvalidType, IntType:
+		// InvalidType just means un-initialized.
+		return int64(n.bits), true
+	case UintType:
+		return int64(n.bits), n.bits <= math.MaxInt64
+	case Float32Type:
+		f := math.Float32frombits(uint32(n.bits))
+		if n.isExactInt() && f <= math.MaxInt64 && f >= math.MinInt64 {
+			return int64(f), true
+		}
+		if n.bits == 0 || n.bits == 1<<31 {
+			return 0, true
+		}
+	case Float64Type:
+		f := math.Float64frombits(n.bits)
+		if n.isExactInt() && f <= math.MaxInt64 && f >= math.MinInt64 {
+			return int64(f), true
+		}
+		return 0, n.bits == 0 || n.bits == 1<<63
+	}
+	return 0, false
+}
+
+// CoerceUInt attempts to coerce the value of
+// the number into an unsigned integer and returns
+// whether it was successful.
+// "Success" implies that no precision in the value of
+// the number was lost, which means that the number was an integer or
+// a floating point that mapped exactly to an integer without rounding.
+func (n *Number) CoerceUInt() (uint64, bool) {
+	switch n.typ {
+	case InvalidType, IntType:
+		// InvalidType just means un-initialized.
+		if int64(n.bits) >= 0 {
+			return n.bits, true
+		}
+	case UintType:
+		return n.bits, true
+	case Float32Type:
+		f := math.Float32frombits(uint32(n.bits))
+		if f >= 0 && f <= math.MaxUint64 && n.isExactInt() {
+			return uint64(f), true
+		}
+		if n.bits == 0 || n.bits == 1<<31 {
+			return 0, true
+		}
+	case Float64Type:
+		f := math.Float64frombits(n.bits)
+		if f >= 0 && f <= math.MaxUint64 && n.isExactInt() {
+			return uint64(f), true
+		}
+		return 0, n.bits == 0 || n.bits == 1<<63
+	}
+	return 0, false
+}
+
+// isExactInt will return true if the number represents an integer value.
+// NaN, Inf returns false.
+func (n *Number) isExactInt() bool {
+	var eBits int // Exponent bits
+	var mBits int // Mantissa bits
+
+	switch n.typ {
+	case InvalidType, IntType, UintType:
+		return true
+	case Float32Type:
+		eBits = 8
+		mBits = 23
+	case Float64Type:
+		eBits = 11
+		mBits = 52
+	default:
+		return false
+	}
+	// Calculate float parts
+	exp := int(n.bits>>mBits) & ((1 << eBits) - 1)
+	mant := n.bits & ((1 << mBits) - 1)
+	if exp == 0 && mant == 0 {
+		// Handle zero value.
+		return true
+	}
+
+	exp -= (1 << (eBits - 1)) - 1
+	if exp < 0 || exp == 1<<(eBits-1) {
+		// Negative exponent is never integer (except zero handled above)
+		// Handles NaN (exp all 1s)
+		return false
+	}
+
+	if exp >= mBits {
+		// If we have more exponent than mantissa bits it is always an integer.
+		return true
+	}
+	// Check if all bits below the exponent are zero.
+	return bits.TrailingZeros64(mant) >= mBits-exp
+}
+
 // Msgsize implements msgp.Sizer
 func (n *Number) Msgsize() int {
 	switch n.typ {

msgp/number_test.go

@@ -2,6 +2,7 @@ package msgp
 
 import (
 	"bytes"
+	"math"
 	"testing"
 )
 
@@ -93,3 +94,67 @@ func TestNumber(t *testing.T) {
 		t.Errorf("encode: expected output %#v; got %#v", dat, buf.Bytes())
 	}
 }
+
+func TestConv32(t *testing.T) {
+	for i := -1 << 24; i < 1<<25; i++ {
+		x := math.Float32bits(float32(i))
+		exp := int(x>>23)&255 - 127
+		mant := x & ((1 << 23) - 1)
+		isExact := false
+		if exp >= 23 || (exp == -127 && mant == 0) {
+			isExact = true
+		}
+		// Only exp >= 0 can be exact integer
+		if exp >= 0 && exp <= 23 {
+			mantissaMask := uint32((1 << (23 - exp)) - 1)
+			isExact = (mant & mantissaMask) == 0
+		}
+
+		n := Number{bits: uint64(x), typ: Float32Type}
+		got := n.isExactInt()
+		if got != isExact {
+			t.Errorf("n.IsExactInt(): got %t, want %t", got, isExact)
+		}
+		n = Number{bits: uint64(math.Float32bits(float32(i) + 0.1)), typ: Float32Type}
+		got = n.isExactInt()
+		if got != false && i > -2097152 && i < 2097152 {
+			val, ok := n.Float()
+			t.Fatalf("n.IsExactInt(%f): got %t, want %t, ok: %v", val, got, false, ok)
+		}
+	}
+}
+
+func TestConv64(t *testing.T) {
+	for i := -1 << 30; i < 1<<30; i++ {
+		if testing.Short() {
+			i += 8
+		}
+		x := math.Float64bits(float64(i))
+		exp := int(x>>52)&2047 - 1023
+		mant := x & ((1 << 52) - 1)
+
+		isExact := false
+		if exp >= 52 || (exp == -1023 && mant == 0) {
+			isExact = true
+		}
+		// Only exp >= 0 can be exact integer
+		if exp >= 0 && exp <= 52 {
+			mantissaMask := uint64((1 << (52 - exp)) - 1)
+			isExact = (mant & mantissaMask) == 0
+		}
+		n := Number{bits: uint64(x), typ: Float64Type}
+		got := n.isExactInt()
+		if got != isExact {
+			t.Errorf("n.IsExactInt(): got %t, want %t", got, isExact)
+		}
+		if !got {
+			t.Fatal(i)
+		}
+		n = Number{bits: uint64(math.Float64bits(float64(i) + 0.1)), typ: Float64Type}
+		got = n.isExactInt()
+		if got != false {
+			val, ok := n.Float()
+			t.Fatalf("n.IsExactInt(%f): got %t, want %t, ok: %v", val, got, false, ok)
+		}
+	}
+}