// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package big
import (
"flag"
"fmt"
"math"
"strconv"
"strings"
"testing"
)
// Verify that ErrNaN implements the error interface.
var _ error = ErrNaN{}
func (x *Float) uint64() uint64 {
u, acc := x.Uint64()
if acc != Exact {
panic(fmt.Sprintf("%s is not a uint64", x.Text('g', 10)))
}
return u
}
func (x *Float) int64() int64 {
i, acc := x.Int64()
if acc != Exact {
panic(fmt.Sprintf("%s is not an int64", x.Text('g', 10)))
}
return i
}
func TestFloatZeroValue(t *testing.T) {
// zero (uninitialized) value is a ready-to-use 0.0
var x Float
if s := x.Text('f', 1); s != "0.0" {
t.Errorf("zero value = %s; want 0.0", s)
}
// zero value has precision 0
if prec := x.Prec(); prec != 0 {
t.Errorf("prec = %d; want 0", prec)
}
// zero value can be used in any and all positions of binary operations
make := func(x int) *Float {
var f Float
if x != 0 {
f.SetInt64(int64(x))
}
// x == 0 translates into the zero value
return &f
}
for _, test := range []struct {
z, x, y, want int
opname rune
op func(z, x, y *Float) *Float
}{
{0, 0, 0, 0, '+', (*Float).Add},
{0, 1, 2, 3, '+', (*Float).Add},
{1, 2, 0, 2, '+', (*Float).Add},
{2, 0, 1, 1, '+', (*Float).Add},
{0, 0, 0, 0, '-', (*Float).Sub},
{0, 1, 2, -1, '-', (*Float).Sub},
{1, 2, 0, 2, '-', (*Float).Sub},
{2, 0, 1, -1, '-', (*Float).Sub},
{0, 0, 0, 0, '*', (*Float).Mul},
{0, 1, 2, 2, '*', (*Float).Mul},
{1, 2, 0, 0, '*', (*Float).Mul},
{2, 0, 1, 0, '*', (*Float).Mul},
// {0, 0, 0, 0, '/', (*Float).Quo}, // panics
{0, 2, 1, 2, '/', (*Float).Quo},
{1, 2, 0, 0, '/', (*Float).Quo}, // = +Inf
{2, 0, 1, 0, '/', (*Float).Quo},
} {
z := make(test.z)
test.op(z, make(test.x), make(test.y))
got := 0
if !z.IsInf() {
got = int(z.int64())
}
if got != test.want {
t.Errorf("%d %c %d = %d; want %d", test.x, test.opname, test.y, got, test.want)
}
}
// TODO(gri) test how precision is set for zero value results
}
func makeFloat(s string) *Float {
x, _, err := ParseFloat(s, 0, 1000, ToNearestEven)
if err != nil {
panic(err)
}
return x
}
func TestFloatSetPrec(t *testing.T) {
for _, test := range []struct {
x string
prec uint
want string
acc Accuracy
}{
// prec 0
{"0", 0, "0", Exact},
{"-0", 0, "-0", Exact},
{"-Inf", 0, "-Inf", Exact},
{"+Inf", 0, "+Inf", Exact},
{"123", 0, "0", Below},
{"-123", 0, "-0", Above},
// prec at upper limit
{"0", MaxPrec, "0", Exact},
{"-0", MaxPrec, "-0", Exact},
{"-Inf", MaxPrec, "-Inf", Exact},
{"+Inf", MaxPrec, "+Inf", Exact},
// just a few regular cases - general rounding is tested elsewhere
{"1.5", 1, "2", Above},
{"-1.5", 1, "-2", Below},
{"123", 1e6, "123", Exact},
{"-123", 1e6, "-123", Exact},
} {
x := makeFloat(test.x).SetPrec(test.prec)
prec := test.prec
if prec > MaxPrec {
prec = MaxPrec
}
if got := x.Prec(); got != prec {
t.Errorf("%s.SetPrec(%d).Prec() == %d; want %d", test.x, test.prec, got, prec)
}
if got, acc := x.String(), x.Acc(); got != test.want || acc != test.acc {
t.Errorf("%s.SetPrec(%d) = %s (%s); want %s (%s)", test.x, test.prec, got, acc, test.want, test.acc)
}
}
}
func TestFloatMinPrec(t *testing.T) {
const max = 100
for _, test := range []struct {
x string
want uint
}{
{"0", 0},
{"-0", 0},
{"+Inf", 0},
{"-Inf", 0},
{"1", 1},
{"2", 1},
{"3", 2},
{"0x8001", 16},
{"0x8001p-1000", 16},
{"0x8001p+1000", 16},
{"0.1", max},
} {
x := makeFloat(test.x).SetPrec(max)
if got := x.MinPrec(); got != test.want {
t.Errorf("%s.MinPrec() = %d; want %d", test.x, got, test.want)
}
}
}
func TestFloatSign(t *testing.T) {
for _, test := range []struct {
x string
s int
}{
{"-Inf", -1},
{"-1", -1},
{"-0", 0},
{"+0", 0},
{"+1", +1},
{"+Inf", +1},
} {
x := makeFloat(test.x)
s := x.Sign()
if s != test.s {
t.Errorf("%s.Sign() = %d; want %d", test.x, s, test.s)
}
}
}
// alike(x, y) is like x.Cmp(y) == 0 but also considers the sign of 0 (0 != -0).
func alike(x, y *Float) bool {
return x.Cmp(y) == 0 && x.Signbit() == y.Signbit()
}
func alike32(x, y float32) bool {
// we can ignore NaNs
return x == y && math.Signbit(float64(x)) == math.Signbit(float64(y))
}
func alike64(x, y float64) bool {
// we can ignore NaNs
return x == y && math.Signbit(x) == math.Signbit(y)
}
func TestFloatMantExp(t *testing.T) {
for _, test := range []struct {
x string
mant string
exp int
}{
{"0", "0", 0},
{"+0", "0", 0},
{"-0", "-0", 0},
{"Inf", "+Inf", 0},
{"+Inf", "+Inf", 0},
{"-Inf", "-Inf", 0},
{"1.5", "0.75", 1},
{"1.024e3", "0.5", 11},
{"-0.125", "-0.5", -2},
} {
x := makeFloat(test.x)
mant := makeFloat(test.mant)
m := new(Float)
e := x.MantExp(m)
if !alike(m, mant) || e != test.exp {
t.Errorf("%s.MantExp() = %s, %d; want %s, %d", test.x, m.Text('g', 10), e, test.mant, test.exp)
}
}
}
func TestFloatMantExpAliasing(t *testing.T) {
x := makeFloat("0.5p10")
if e := x.MantExp(x); e != 10 {
t.Fatalf("Float.MantExp aliasing error: got %d; want 10", e)
}
if want := makeFloat("0.5"); !alike(x, want) {
t.Fatalf("Float.MantExp aliasing error: got %s; want %s", x.Text('g', 10), want.Text('g', 10))
}
}
func TestFloatSetMantExp(t *testing.T) {
for _, test := range []struct {
frac string
exp int
z string
}{
{"0", 0, "0"},
{"+0", 0, "0"},
{"-0", 0, "-0"},
{"Inf", 1234, "+Inf"},
{"+Inf", -1234, "+Inf"},
{"-Inf", -1234, "-Inf"},
{"0", MinExp, "0"},
{"0.25", MinExp, "+0"}, // exponent underflow
{"-0.25", MinExp, "-0"}, // exponent underflow
{"1", MaxExp, "+Inf"}, // exponent overflow
{"2", MaxExp - 1, "+Inf"}, // exponent overflow
{"0.75", 1, "1.5"},
{"0.5", 11, "1024"},
{"-0.5", -2, "-0.125"},
{"32", 5, "1024"},
{"1024", -10, "1"},
} {
frac := makeFloat(test.frac)
want := makeFloat(test.z)
var z Float
z.SetMantExp(frac, test.exp)
if !alike(&z, want) {
t.Errorf("SetMantExp(%s, %d) = %s; want %s", test.frac, test.exp, z.Text('g', 10), test.z)
}
// test inverse property
mant := new(Float)
if z.SetMantExp(mant, want.MantExp(mant)).Cmp(want) != 0 {
t.Errorf("Inverse property not satisfied: got %s; want %s", z.Text('g', 10), test.z)
}
}
}
func TestFloatPredicates(t *testing.T) {
for _, test := range []struct {
x string
sign int
signbit, inf bool
}{
{x: "-Inf", sign: -1, signbit: true, inf: true},
{x: "-1", sign: -1, signbit: true},
{x: "-0", signbit: true},
{x: "0"},
{x: "1", sign: 1},
{x: "+Inf", sign: 1, inf: true},
} {
x := makeFloat(test.x)
if got := x.Signbit(); got != test.signbit {
t.Errorf("(%s).Signbit() = %v; want %v", test.x, got, test.signbit)
}
if got := x.Sign(); got != test.sign {
t.Errorf("(%s).Sign() = %d; want %d", test.x, got, test.sign)
}
if got := x.IsInf(); got != test.inf {
t.Errorf("(%s).IsInf() = %v; want %v", test.x, got, test.inf)
}
}
}
func TestFloatIsInt(t *testing.T) {
for _, test := range []string{
"0 int",
"-0 int",
"1 int",
"-1 int",
"0.5",
"1.23",
"1.23e1",
"1.23e2 int",
"0.000000001e+8",
"0.000000001e+9 int",
"1.2345e200 int",
"Inf",
"+Inf",
"-Inf",
} {
s := strings.TrimSuffix(test, " int")
want := s != test
if got := makeFloat(s).IsInt(); got != want {
t.Errorf("%s.IsInt() == %t", s, got)
}
}
}
func fromBinary(s string) int64 {
x, err := strconv.ParseInt(s, 2, 64)
if err != nil {
panic(err)
}
return x
}
func toBinary(x int64) string {
return strconv.FormatInt(x, 2)
}
func testFloatRound(t *testing.T, x, r int64, prec uint, mode RoundingMode) {
// verify test data
var ok bool
switch mode {
case ToNearestEven, ToNearestAway:
ok = true // nothing to do for now
case ToZero:
if x < 0 {
ok = r >= x
} else {
ok = r <= x
}
case AwayFromZero:
if x < 0 {
ok = r <= x
} else {
ok = r >= x
}
case ToNegativeInf:
ok = r <= x
case ToPositiveInf:
ok = r >= x
default:
panic("unreachable")
}
if !ok {
t.Fatalf("incorrect test data for prec = %d, %s: x = %s, r = %s", prec, mode, toBinary(x), toBinary(r))
}
// compute expected accuracy
a := Exact
switch {
case r < x:
a = Below
case r > x:
a = Above
}
// round
f := new(Float).SetMode(mode).SetInt64(x).SetPrec(prec)
// check result
r1 := f.int64()
p1 := f.Prec()
a1 := f.Acc()
if r1 != r || p1 != prec || a1 != a {
t.Errorf("round %s (%d bits, %s) incorrect: got %s (%d bits, %s); want %s (%d bits, %s)",
toBinary(x), prec, mode,
toBinary(r1), p1, a1,
toBinary(r), prec, a)
return
}
// g and f should be the same
// (rounding by SetPrec after SetInt64 using default precision
// should be the same as rounding by SetInt64 after setting the
// precision)
g := new(Float).SetMode(mode).SetPrec(prec).SetInt64(x)
if !alike(g, f) {
t.Errorf("round %s (%d bits, %s) not symmetric: got %s and %s; want %s",
toBinary(x), prec, mode,
toBinary(g.int64()),
toBinary(r1),
toBinary(r),
)
return
}
// h and f should be the same
// (repeated rounding should be idempotent)
h := new(Float).SetMode(mode).SetPrec(prec).Set(f)
if !alike(h, f) {
t.Errorf("round %s (%d bits, %s) not idempotent: got %s and %s; want %s",
toBinary(x), prec, mode,
toBinary(h.int64()),
toBinary(r1),
toBinary(r),
)
return
}
}
// TestFloatRound tests basic rounding.
func TestFloatRound(t *testing.T) {
for _, test := range []struct {
prec uint
x, zero, neven, naway, away string // input, results rounded to prec bits
}{
{5, "1000", "1000", "1000", "1000", "1000"},
{5, "1001", "1001", "1001", "1001", "1001"},
{5, "1010", "1010", "1010", "1010", "1010"},
{5, "1011", "1011", "1011", "1011", "1011"},
{5, "1100", "1100", "1100", "1100", "1100"},
{5, "1101", "1101", "1101", "1101", "1101"},
{5, "1110", "1110", "1110", "1110", "1110"},
{5, "1111", "1111", "1111", "1111", "1111"},
{4, "1000", "1000", "1000", "1000", "1000"},
{4, "1001", "1001", "1001", "1001", "1001"},
{4, "1010", "1010", "1010", "1010", "1010"},
{4, "1011", "1011", "1011", "1011", "1011"},
{4, "1100", "1100", "1100", "1100", "1100"},
{4, "1101", "1101", "1101", "1101", "1101"},
{4, "1110", "1110", "1110", "1110", "1110"},
{4, "1111", "1111", "1111", "1111", "1111"},
{3, "1000", "1000", "1000", "1000", "1000"},
{3, "1001", "1000", "1000", "1010", "1010"},
{3, "1010", "1010", "1010", "1010", "1010"},
{3, "1011", "1010", "1100", "1100", "1100"},
{3, "1100", "1100", "1100", "1100", "1100"},
{3, "1101", "1100", "1100", "1110", "1110"},
{3, "1110", "1110", "1110", "1110", "1110"},
{3, "1111", "1110", "10000", "10000", "10000"},
{3, "1000001", "1000000", "1000000", "1000000", "1010000"},
{3, "1001001", "1000000", "1010000", "1010000", "1010000"},
{3, "1010001", "1010000", "1010000", "1010000", "1100000"},
{3, "1011001", "1010000", "1100000", "1100000", "1100000"},
{3, "1100001", "1100000", "1100000", "1100000", "1110000"},
{3, "1101001", "1100000", "1110000", "1110000", "1110000"},
{3, "1110001", "1110000", "1110000", "1110000", "10000000"},
{3, "1111001", "1110000", "10000000", "10000000", "10000000"},
{2, "1000", "1000", "1000", "1000", "1000"},
{2, "1001", "1000", "1000", "1000", "1100"},
{2, "1010", "1000", "1000", "1100", "1100"},
{2, "1011", "1000", "1100", "1100", "1100"},
{2, "1100", "1100", "1100", "1100", "1100"},
{2, "1101", "1100", "1100", "1100", "10000"},
{2, "1110", "1100", "10000", "10000", "10000"},
{2, "1111", "1100", "10000", "10000", "10000"},
{2, "1000001", "1000000", "1000000", "1000000", "1100000"},
{2, "1001001", "1000000", "1000000", "1000000", "1100000"},
{2, "1010001", "1000000", "1100000", "1100000", "1100000"},
{2, "1011001", "1000000", "1100000", "1100000", "1100000"},
{2, "1100001", "1100000", "1100000", "1100000", "10000000"},
{2, "1101001", "1100000", "1100000", "1100000", "10000000"},
{2, "1110001", "1100000", "10000000", "10000000", "10000000"},
{2, "1111001", "1100000", "10000000", "10000000", "10000000"},
{1, "1000", "1000", "1000", "1000", "1000"},
{1, "1001", "1000", "1000", "1000", "10000"},
{1, "1010", "1000", "1000", "1000", "10000"},
{1, "1011", "1000", "1000", "1000", "10000"},
{1, "1100", "1000", "10000", "10000", "10000"},
{1, "1101", "1000", "10000", "10000", "10000"},
{1, "1110", "1000", "10000", "10000", "10000"},
{1, "1111", "1000", "10000", "10000", "10000"},
{1, "1000001", "1000000", "1000000", "1000000", "10000000"},
{1, "1001001", "1000000", "1000000", "1000000", "10000000"},
{1, "1010001", "1000000", "1000000", "1000000", "10000000"},
{1, "1011001", "1000000", "1000000", "1000000", "10000000"},
{1, "1100001", "1000000", "10000000", "10000000", "10000000"},
{1, "1101001", "1000000", "10000000", "10000000", "10000000"},
{1, "1110001", "1000000", "10000000", "10000000", "10000000"},
{1, "1111001", "1000000", "10000000", "10000000", "10000000"},
} {
x := fromBinary(test.x)
z := fromBinary(test.zero)
e := fromBinary(test.neven)
n := fromBinary(test.naway)
a := fromBinary(test.away)
prec := test.prec
testFloatRound(t, x, z, prec, ToZero)
testFloatRound(t, x, e, prec, ToNearestEven)
testFloatRound(t, x, n, prec, ToNearestAway)
testFloatRound(t, x, a, prec, AwayFromZero)
testFloatRound(t, x, z, prec, ToNegativeInf)
testFloatRound(t, x, a, prec, ToPositiveInf)
testFloatRound(t, -x, -a, prec, ToNegativeInf)
testFloatRound(t, -x, -z, prec, ToPositiveInf)
}
}
// TestFloatRound24 tests that rounding a float64 to 24 bits
// matches IEEE-754 rounding to nearest when converting a
// float64 to a float32 (excluding denormal numbers).
func TestFloatRound24(t *testing.T) {
const x0 = 1<<26 - 0x10 // 11...110000 (26 bits)
for d := 0; d <= 0x10; d++ {
x := float64(x0 + d)
f := new(Float).SetPrec(24).SetFloat64(x)
got, _ := f.Float32()
want := float32(x)
if got != want {
t.Errorf("Round(%g, 24) = %g; want %g", x, got, want)
}
}
}
func TestFloatSetUint64(t *testing.T) {
for _, want := range []uint64{
0,
1,
2,
10,
100,
1<<32 - 1,
1 << 32,
1<<64 - 1,
} {
var f Float
f.SetUint64(want)
if got := f.uint64(); got != want {
t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
}
}
// test basic rounding behavior (exhaustive rounding testing is done elsewhere)
const x uint64 = 0x8765432187654321 // 64 bits needed
for prec := uint(1); prec <= 64; prec++ {
f := new(Float).SetPrec(prec).SetMode(ToZero).SetUint64(x)
got := f.uint64()
want := x &^ (1<<(64-prec) - 1) // cut off (round to zero) low 64-prec bits
if got != want {
t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
}
}
}
func TestFloatSetInt64(t *testing.T) {
for _, want := range []int64{
0,
1,
2,
10,
100,
1<<32 - 1,
1 << 32,
1<<63 - 1,
} {
for i := range [2]int{} {
if i&1 != 0 {
want = -want
}
var f Float
f.SetInt64(want)
if got := f.int64(); got != want {
t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
}
}
}
// test basic rounding behavior (exhaustive rounding testing is done elsewhere)
const x int64 = 0x7654321076543210 // 63 bits needed
for prec := uint(1); prec <= 63; prec++ {
f := new(Float).SetPrec(prec).SetMode(ToZero).SetInt64(x)
got := f.int64()
want := x &^ (1<<(63-prec) - 1) // cut off (round to zero) low 63-prec bits
if got != want {
t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
}
}
}
func TestFloatSetFloat64(t *testing.T) {
for _, want := range []float64{
0,
1,
2,
12345,
1e10,
1e100,
3.14159265e10,
2.718281828e-123,
1.0 / 3,
math.MaxFloat32,
math.MaxFloat64,
math.SmallestNonzeroFloat32,
math.SmallestNonzeroFloat64,
math.Inf(-1),
math.Inf(0),
-math.Inf(1),
} {
for i := range [2]int{} {
if i&1 != 0 {
want = -want
}
var f Float
f.SetFloat64(want)
if got, acc := f.Float64(); got != want || acc != Exact {
t.Errorf("got %g (%s, %s); want %g (Exact)", got, f.Text('p', 0), acc, want)
}
}
}
// test basic rounding behavior (exhaustive rounding testing is done elsewhere)
const x uint64 = 0x8765432143218 // 53 bits needed
for prec := uint(1); prec <= 52; prec++ {
f := new(Float).SetPrec(prec).SetMode(ToZero).SetFloat64(float64(x))
got, _ := f.Float64()
want := float64(x &^ (1<<(52-prec) - 1)) // cut off (round to zero) low 53-prec bits
if got != want {
t.Errorf("got %g (%s); want %g", got, f.Text('p', 0), want)
}
}
// test NaN
defer func() {
if p, ok := recover().(ErrNaN); !ok {
t.Errorf("got %v; want ErrNaN panic", p)
}
}()
var f Float
f.SetFloat64(math.NaN())
// should not reach here
t.Errorf("got %s; want ErrNaN panic", f.Text('p', 0))
}
func TestFloatSetInt(t *testing.T) {
for _, want := range []string{
"0",
"1",
"-1",
"1234567890",
"123456789012345678901234567890",
"123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
} {
var x Int
_, ok := x.SetString(want, 0)
if !ok {
t.Errorf("invalid integer %s", want)
continue
}
n := x.BitLen()
var f Float
f.SetInt(&x)
// check precision
if n < 64 {
n = 64
}
if prec := f.Prec(); prec != uint(n) {
t.Errorf("got prec = %d; want %d", prec, n)
}
// check value
got := f.Text('g', 100)
if got != want {
t.Errorf("got %s (%s); want %s", got, f.Text('p', 0), want)
}
}
// TODO(gri) test basic rounding behavior
}
func TestFloatSetRat(t *testing.T) {
for _, want := range []string{
"0",
"1",
"-1",
"1234567890",
"123456789012345678901234567890",
"123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
"1.2",
"3.14159265",
// TODO(gri) expand
} {
var x Rat
_, ok := x.SetString(want)
if !ok {
t.Errorf("invalid fraction %s", want)
continue
}
n := max(x.Num().BitLen(), x.Denom().BitLen())
var f1, f2 Float
f2.SetPrec(1000)
f1.SetRat(&x)
f2.SetRat(&x)
// check precision when set automatically
if n < 64 {
n = 64
}
if prec := f1.Prec(); prec != uint(n) {
t.Errorf("got prec = %d; want %d", prec, n)
}
got := f2.Text('g', 100)
if got != want {
t.Errorf("got %s (%s); want %s", got, f2.Text('p', 0), want)
}
}
}
func TestFloatSetInf(t *testing.T) {
var f Float
for _, test := range []struct {
signbit bool
prec uint
want string
}{
{false, 0, "+Inf"},
{true, 0, "-Inf"},
{false, 10, "+Inf"},
{true, 30, "-Inf"},
} {
x := f.SetPrec(test.prec).SetInf(test.signbit)
if got := x.String(); got != test.want || x.Prec() != test.prec {
t.Errorf("SetInf(%v) = %s (prec = %d); want %s (prec = %d)", test.signbit, got, x.Prec(), test.want, test.prec)
}
}
}
func TestFloatUint64(t *testing.T) {
for _, test := range []struct {
x string
out uint64
acc Accuracy
}{
{"-Inf", 0, Above},
{"-1", 0, Above},
{"-1e-1000", 0, Above},
{"-0", 0, Exact},
{"0", 0, Exact},
{"1e-1000", 0, Below},
{"1", 1, Exact},
{"1.000000000000000000001", 1, Below},
{"12345.0", 12345, Exact},
{"12345.000000000000000000001", 12345, Below},
{"18446744073709551615", 18446744073709551615, Exact},
{"18446744073709551615.000000000000000000001", math.MaxUint64, Below},
{"18446744073709551616", math.MaxUint64, Below},
{"1e10000", math.MaxUint64, Below},
{"+Inf", math.MaxUint64, Below},
} {
x := makeFloat(test.x)
out, acc := x.Uint64()
if out != test.out || acc != test.acc {
t.Errorf("%s: got %d (%s); want %d (%s)", test.x, out, acc, test.out, test.acc)
}
}
}
func TestFloatInt64(t *testing.T) {
for _, test := range []struct {
x string
out int64
acc Accuracy
}{
{"-Inf", math.MinInt64, Above},
{"-1e10000", math.MinInt64, Above},
{"-9223372036854775809", math.MinInt64, Above},
{"-9223372036854775808.000000000000000000001", math.MinInt64, Above},
{"-9223372036854775808", -9223372036854775808, Exact},
{"-9223372036854775807.000000000000000000001", -9223372036854775807, Above},
{"-9223372036854775807", -9223372036854775807, Exact},
{"-12345.000000000000000000001", -12345, Above},
{"-12345.0", -12345, Exact},
{"-1.000000000000000000001", -1, Above},
{"-1.5", -1, Above},
{"-1", -1, Exact},
{"-1e-1000", 0, Above},
{"0", 0, Exact},
{"1e-1000", 0, Below},
{"1", 1, Exact},
{"1.000000000000000000001", 1, Below},
{"1.5", 1, Below},
{"12345.0", 12345, Exact},
{"12345.000000000000000000001", 12345, Below},
{"9223372036854775807", 9223372036854775807, Exact},
{"9223372036854775807.000000000000000000001", math.MaxInt64, Below},
{"9223372036854775808", math.MaxInt64, Below},
{"1e10000", math.MaxInt64, Below},
{"+Inf", math.MaxInt64, Below},
} {
x := makeFloat(test.x)
out, acc := x.Int64()
if out != test.out || acc != test.acc {
t.Errorf("%s: got %d (%s); want %d (%s)", test.x, out, acc, test.out, test.acc)
}
}
}
func TestFloatFloat32(t *testing.T) {
for _, test := range []struct {
x string
out float32
acc Accuracy
}{
{"0", 0, Exact},
// underflow to zero
{"1e-1000", 0, Below},
{"0x0.000002p-127", 0, Below},
{"0x.0000010p-126", 0, Below},
// denormals
{"1.401298464e-45", math.SmallestNonzeroFloat32, Above}, // rounded up to smallest denormal
{"0x.ffffff8p-149", math.SmallestNonzeroFloat32, Above}, // rounded up to smallest denormal
{"0x.0000018p-126", math.SmallestNonzeroFloat32, Above}, // rounded up to smallest denormal
{"0x.0000020p-126", math.SmallestNonzeroFloat32, Exact},
{"0x.8p-148", math.SmallestNonzeroFloat32, Exact},
{"1p-149", math.SmallestNonzeroFloat32, Exact},
{"0x.fffffep-126", math.Float32frombits(0x7fffff), Exact}, // largest denormal
// special denormal cases (see issues 14553, 14651)
{"0x0.0000001p-126", math.Float32frombits(0x00000000), Below}, // underflow to zero
{"0x0.0000008p-126", math.Float32frombits(0x00000000), Below}, // underflow to zero
{"0x0.0000010p-126", math.Float32frombits(0x00000000), Below}, // rounded down to even
{"0x0.0000011p-126", math.Float32frombits(0x00000001), Above}, // rounded up to smallest denormal
{"0x0.0000018p-126", math.Float32frombits(0x00000001), Above}, // rounded up to smallest denormal
{"0x1.0000000p-149", math.Float32frombits(0x00000001), Exact}, // smallest denormal
{"0x0.0000020p-126", math.Float32frombits(0x00000001), Exact}, // smallest denormal
{"0x0.fffffe0p-126", math.Float32frombits(0x007fffff), Exact}, // largest denormal
{"0x1.0000000p-126", math.Float32frombits(0x00800000), Exact}, // smallest normal
{"0x0.8p-149", math.Float32frombits(0x000000000), Below}, // rounded down to even
{"0x0.9p-149", math.Float32frombits(0x000000001), Above}, // rounded up to smallest denormal
{"0x0.ap-149", math.Float32frombits(0x000000001), Above}, // rounded up to smallest denormal
{"0x0.bp-149", math.Float32frombits(0x000000001), Above}, // rounded up to smallest denormal
{"0x0.cp-149", math.Float32frombits(0x000000001), Above}, // rounded up to smallest denormal
{"0x1.0p-149", math.Float32frombits(0x000000001), Exact}, // smallest denormal
{"0x1.7p-149", math.Float32frombits(0x000000001), Below},
{"0x1.8p-149", math.Float32frombits(0x000000002), Above},
{"0x1.9p-149", math.Float32frombits(0x000000002), Above},
{"0x2.0p-149", math.Float32frombits(0x000000002), Exact},
{"0x2.8p-149", math.Float32frombits(0x000000002), Below}, // rounded down to even
{"0x2.9p-149", math.Float32frombits(0x000000003), Above},
{"0x3.0p-149", math.Float32frombits(0x000000003), Exact},
{"0x3.7p-149", math.Float32frombits(0x000000003), Below},
{"0x3.8p-149", math.Float32frombits(0x000000004), Above}, // rounded up to even
{"0x4.0p-149", math.Float32frombits(0x000000004), Exact},
{"0x4.8p-149", math.Float32frombits(0x000000004), Below}, // rounded down to even
{"0x4.9p-149", math.Float32frombits(0x000000005), Above},
// specific case from issue 14553
{"0x7.7p-149", math.Float32frombits(0x000000007), Below},
{"0x7.8p-149", math.Float32frombits(0x000000008), Above},
{"0x7.9p-149", math.Float32frombits(0x000000008), Above},
// normals
{"0x.ffffffp-126", math.Float32frombits(0x00800000), Above}, // rounded up to smallest normal
{"1p-126", math.Float32frombits(0x00800000), Exact}, // smallest normal
{"0x1.fffffep-126", math.Float32frombits(0x00ffffff), Exact},
{"0x1.ffffffp-126", math.Float32frombits(0x01000000), Above}, // rounded up
{"1", 1, Exact},
{"1.000000000000000000001", 1, Below},
{"12345.0", 12345, Exact},
{"12345.000000000000000000001", 12345, Below},
{"0x1.fffffe0p127", math.MaxFloat32, Exact},
{"0x1.fffffe8p127", math.MaxFloat32, Below},
// overflow
{"0x1.ffffff0p127", float32(math.Inf(+1)), Above},
{"0x1p128", float32(math.Inf(+1)), Above},
{"1e10000", float32(math.Inf(+1)), Above},
{"0x1.ffffff0p2147483646", float32(math.Inf(+1)), Above}, // overflow in rounding
// inf
{"Inf", float32(math.Inf(+1)), Exact},
} {
for i := 0; i < 2; i++ {
// test both signs
tx, tout, tacc := test.x, test.out, test.acc
if i != 0 {
tx = "-" + tx
tout = -tout
tacc = -tacc
}
// conversion should match strconv where syntax is agreeable
if f, err := strconv.ParseFloat(tx, 32); err == nil && !alike32(float32(f), tout) {
t.Errorf("%s: got %g; want %g (incorrect test data)", tx, f, tout)
}
x := makeFloat(tx)
out, acc := x.Float32()
if !alike32(out, tout) || acc != tacc {
t.Errorf("%s: got %g (%#08x, %s); want %g (%#08x, %s)", tx, out, math.Float32bits(out), acc, test.out, math.Float32bits(test.out), tacc)
}
// test that x.SetFloat64(float64(f)).Float32() == f
var x2 Float
out2, acc2 := x2.SetFloat64(float64(out)).Float32()
if !alike32(out2, out) || acc2 != Exact {
t.Errorf("idempotency test: got %g (%s); want %g (Exact)", out2, acc2, out)
}
}
}
}
func TestFloatFloat64(t *testing.T) {
const smallestNormalFloat64 = 2.2250738585072014e-308 // 1p-1022
for _, test := range []struct {
x string
out float64
acc Accuracy
}{
{"0", 0, Exact},
// underflow to zero
{"1e-1000", 0, Below},
{"0x0.0000000000001p-1023", 0, Below},
{"0x0.00000000000008p-1022", 0, Below},
// denormals
{"0x0.0000000000000cp-1022", math.SmallestNonzeroFloat64, Above}, // rounded up to smallest denormal
{"0x0.00000000000010p-1022", math.SmallestNonzeroFloat64, Exact}, // smallest denormal
{"0x.8p-1073", math.SmallestNonzeroFloat64, Exact},
{"1p-1074", math.SmallestNonzeroFloat64, Exact},
{"0x.fffffffffffffp-1022", math.Float64frombits(0x000fffffffffffff), Exact}, // largest denormal
// special denormal cases (see issues 14553, 14651)
{"0x0.00000000000001p-1022", math.Float64frombits(0x00000000000000000), Below}, // underflow to zero
{"0x0.00000000000004p-1022", math.Float64frombits(0x00000000000000000), Below}, // underflow to zero
{"0x0.00000000000008p-1022", math.Float64frombits(0x00000000000000000), Below}, // rounded down to even
{"0x0.00000000000009p-1022", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
{"0x0.0000000000000ap-1022", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
{"0x0.8p-1074", math.Float64frombits(0x00000000000000000), Below}, // rounded down to even
{"0x0.9p-1074", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
{"0x0.ap-1074", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
{"0x0.bp-1074", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
{"0x0.cp-1074", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
{"0x1.0p-1074", math.Float64frombits(0x00000000000000001), Exact},
{"0x1.7p-1074", math.Float64frombits(0x00000000000000001), Below},
{"0x1.8p-1074", math.Float64frombits(0x00000000000000002), Above},
{"0x1.9p-1074", math.Float64frombits(0x00000000000000002), Above},
{"0x2.0p-1074", math.Float64frombits(0x00000000000000002), Exact},
{"0x2.8p-1074", math.Float64frombits(0x00000000000000002), Below}, // rounded down to even
{"0x2.9p-1074", math.Float64frombits(0x00000000000000003), Above},
{"0x3.0p-1074", math.Float64frombits(0x00000000000000003), Exact},
{"0x3.7p-1074", math.Float64frombits(0x00000000000000003), Below},
{"0x3.8p-1074", math.Float64frombits(0x00000000000000004), Above}, // rounded up to even
{"0x4.0p-1074", math.Float64frombits(0x00000000000000004), Exact},
{"0x4.8p-1074", math.Float64frombits(0x00000000000000004), Below}, // rounded down to even
{"0x4.9p-1074", math.Float64frombits(0x00000000000000005), Above},
// normals
{"0x.fffffffffffff8p-1022", math.Float64frombits(0x0010000000000000), Above}, // rounded up to smallest normal
{"1p-1022", math.Float64frombits(0x0010000000000000), Exact}, // smallest normal
{"1", 1, Exact},
{"1.000000000000000000001", 1, Below},
{"12345.0", 12345, Exact},
{"12345.000000000000000000001", 12345, Below},
{"0x1.fffffffffffff0p1023", math.MaxFloat64, Exact},
{"0x1.fffffffffffff4p1023", math.MaxFloat64, Below},
// overflow
{"0x1.fffffffffffff8p1023", math.Inf(+1), Above},
{"0x1p1024", math.Inf(+1), Above},
{"1e10000", math.Inf(+1), Above},
{"0x1.fffffffffffff8p2147483646", math.Inf(+1), Above}, // overflow in rounding
{"Inf", math.Inf(+1), Exact},
// selected denormalized values that were handled incorrectly in the past
{"0x.fffffffffffffp-1022", smallestNormalFloat64 - math.SmallestNonzeroFloat64, Exact},
{"4503599627370495p-1074", smallestNormalFloat64 - math.SmallestNonzeroFloat64, Exact},
// https://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
{"2.2250738585072011e-308", 2.225073858507201e-308, Below},
// https://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
{"2.2250738585072012e-308", 2.2250738585072014e-308, Above},
} {
for i := 0; i < 2; i++ {
// test both signs
tx, tout, tacc := test.x, test.out, test.acc
if i != 0 {
tx = "-" + tx
tout = -tout
tacc = -tacc
}
// conversion should match strconv where syntax is agreeable
if f, err := strconv.ParseFloat(tx, 64); err == nil && !alike64(f, tout) {
t.Errorf("%s: got %g; want %g (incorrect test data)", tx, f, tout)
}
x := makeFloat(tx)
out, acc := x.Float64()
if !alike64(out, tout) || acc != tacc {
t.Errorf("%s: got %g (%#016x, %s); want %g (%#016x, %s)", tx, out, math.Float64bits(out), acc, test.out, math.Float64bits(test.out), tacc)
}
// test that x.SetFloat64(f).Float64() == f
var x2 Float
out2, acc2 := x2.SetFloat64(out).Float64()
if !alike64(out2, out) || acc2 != Exact {
t.Errorf("idempotency test: got %g (%s); want %g (Exact)", out2, acc2, out)
}
}
}
}
func TestFloatInt(t *testing.T) {
for _, test := range []struct {
x string
want string
acc Accuracy
}{
{"0", "0", Exact},
{"+0", "0", Exact},
{"-0", "0", Exact},
{"Inf", "nil", Below},
{"+Inf", "nil", Below},
{"-Inf", "nil", Above},
{"1", "1", Exact},
{"-1", "-1", Exact},
{"1.23", "1", Below},
{"-1.23", "-1", Above},
{"123e-2", "1", Below},
{"123e-3", "0", Below},
{"123e-4", "0", Below},
{"1e-1000", "0", Below},
{"-1e-1000", "0", Above},
{"1e+10", "10000000000", Exact},
{"1e+100", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Exact},
} {
x := makeFloat(test.x)
res, acc := x.Int(nil)
got := "nil"
if res != nil {
got = res.String()
}
if got != test.want || acc != test.acc {
t.Errorf("%s: got %s (%s); want %s (%s)", test.x, got, acc, test.want, test.acc)
}
}
// check that supplied *Int is used
for _, f := range []string{"0", "1", "-1", "1234"} {
x := makeFloat(f)
i := new(Int)
if res, _ := x.Int(i); res != i {
t.Errorf("(%s).Int is not using supplied *Int", f)
}
}
}
func TestFloatRat(t *testing.T) {
for _, test := range []struct {
x, want string
acc Accuracy
}{
{"0", "0/1", Exact},
{"+0", "0/1", Exact},
{"-0", "0/1", Exact},
{"Inf", "nil", Below},
{"+Inf", "nil", Below},
{"-Inf", "nil", Above},
{"1", "1/1", Exact},
{"-1", "-1/1", Exact},
{"1.25", "5/4", Exact},
{"-1.25", "-5/4", Exact},
{"1e10", "10000000000/1", Exact},
{"1p10", "1024/1", Exact},
{"-1p-10", "-1/1024", Exact},
{"3.14159265", "7244019449799623199/2305843009213693952", Exact},
} {
x := makeFloat(test.x).SetPrec(64)
res, acc := x.Rat(nil)
got := "nil"
if res != nil {
got = res.String()
}
if got != test.want {
t.Errorf("%s: got %s; want %s", test.x, got, test.want)
continue
}
if acc != test.acc {
t.Errorf("%s: got %s; want %s", test.x, acc, test.acc)
continue
}
// inverse conversion
if res != nil {
got := new(Float).SetPrec(64).SetRat(res)
if got.Cmp(x) != 0 {
t.Errorf("%s: got %s; want %s", test.x, got, x)
}
}
}
// check that supplied *Rat is used
for _, f := range []string{"0", "1", "-1", "1234"} {
x := makeFloat(f)
r := new(Rat)
if res, _ := x.Rat(r); res != r {
t.Errorf("(%s).Rat is not using supplied *Rat", f)
}
}
}
func TestFloatAbs(t *testing.T) {
for _, test := range []string{
"0",
"1",
"1234",
"1.23e-2",
"1e-1000",
"1e1000",
"Inf",
} {
p := makeFloat(test)
a := new(Float).Abs(p)
if !alike(a, p) {
t.Errorf("%s: got %s; want %s", test, a.Text('g', 10), test)
}
n := makeFloat("-" + test)
a.Abs(n)
if !alike(a, p) {
t.Errorf("-%s: got %s; want %s", test, a.Text('g', 10), test)
}
}
}
func TestFloatNeg(t *testing.T) {
for _, test := range []string{
"0",
"1",
"1234",
"1.23e-2",
"1e-1000",
"1e1000",
"Inf",
} {
p1 := makeFloat(test)
n1 := makeFloat("-" + test)
n2 := new(Float).Neg(p1)
p2 := new(Float).Neg(n2)
if !alike(n2, n1) {
t.Errorf("%s: got %s; want %s", test, n2.Text('g', 10), n1.Text('g', 10))
}
if !alike(p2, p1) {
t.Errorf("%s: got %s; want %s", test, p2.Text('g', 10), p1.Text('g', 10))
}
}
}
func TestFloatInc(t *testing.T) {
const n = 10
for _, prec := range precList {
if 1<<prec < n {
continue // prec must be large enough to hold all numbers from 0 to n
}
var x, one Float
x.SetPrec(prec)
one.SetInt64(1)
for i := 0; i < n; i++ {
x.Add(&x, &one)
}
if x.Cmp(new(Float).SetInt64(n)) != 0 {
t.Errorf("prec = %d: got %s; want %d", prec, &x, n)
}
}
}
// Selected precisions with which to run various tests.
var precList = [...]uint{1, 2, 5, 8, 10, 16, 23, 24, 32, 50, 53, 64, 100, 128, 500, 511, 512, 513, 1000, 10000}
// Selected bits with which to run various tests.
// Each entry is a list of bits representing a floating-point number (see fromBits).
var bitsList = [...]Bits{
{}, // = 0
{0}, // = 1
{1}, // = 2
{-1}, // = 1/2
{10}, // = 2**10 == 1024
{-10}, // = 2**-10 == 1/1024
{100, 10, 1}, // = 2**100 + 2**10 + 2**1
{0, -1, -2, -10},
// TODO(gri) add more test cases
}
// TestFloatAdd tests Float.Add/Sub by comparing the result of a "manual"
// addition/subtraction of arguments represented by Bits values with the
// respective Float addition/subtraction for a variety of precisions
// and rounding modes.
func TestFloatAdd(t *testing.T) {
for _, xbits := range bitsList {
for _, ybits := range bitsList {
// exact values
x := xbits.Float()
y := ybits.Float()
zbits := xbits.add(ybits)
z := zbits.Float()
for i, mode := range [...]RoundingMode{ToZero, ToNearestEven, AwayFromZero} {
for _, prec := range precList {
got := new(Float).SetPrec(prec).SetMode(mode)
got.Add(x, y)
want := zbits.round(prec, mode)
if got.Cmp(want) != 0 {
t.Errorf("i = %d, prec = %d, %s:\n\t %s %v\n\t+ %s %v\n\t= %s\n\twant %s",
i, prec, mode, x, xbits, y, ybits, got, want)
}
got.Sub(z, x)
want = ybits.round(prec, mode)
if got.Cmp(want) != 0 {
t.Errorf("i = %d, prec = %d, %s:\n\t %s %v\n\t- %s %v\n\t= %s\n\twant %s",
i, prec, mode, z, zbits, x, xbits, got, want)
}
}
}
}
}
}
// TestFloatAddRoundZero tests Float.Add/Sub rounding when the result is exactly zero.
// x + (-x) or x - x for non-zero x should be +0 in all cases except when
// the rounding mode is ToNegativeInf in which case it should be -0.
func TestFloatAddRoundZero(t *testing.T) {
for _, mode := range [...]RoundingMode{ToNearestEven, ToNearestAway, ToZero, AwayFromZero, ToPositiveInf, ToNegativeInf} {
x := NewFloat(5.0)
y := new(Float).Neg(x)
want := NewFloat(0.0)
if mode == ToNegativeInf {
want.Neg(want)
}
got := new(Float).SetMode(mode)
got.Add(x, y)
if got.Cmp(want) != 0 || got.neg != (mode == ToNegativeInf) {
t.Errorf("%s:\n\t %v\n\t+ %v\n\t= %v\n\twant %v",
mode, x, y, got, want)
}
got.Sub(x, x)
if got.Cmp(want) != 0 || got.neg != (mode == ToNegativeInf) {
t.Errorf("%v:\n\t %v\n\t- %v\n\t= %v\n\twant %v",
mode, x, x, got, want)
}
}
}
// TestFloatAdd32 tests that Float.Add/Sub of numbers with
// 24bit mantissa behaves like float32 addition/subtraction
// (excluding denormal numbers).
func TestFloatAdd32(t *testing.T) {
// chose base such that we cross the mantissa precision limit
const base = 1<<26 - 0x10 // 11...110000 (26 bits)
for d := 0; d <= 0x10; d++ {
for i := range [2]int{} {
x0, y0 := float64(base), float64(d)
if i&1 != 0 {
x0, y0 = y0, x0
}
x := NewFloat(x0)
y := NewFloat(y0)
z := new(Float).SetPrec(24)
z.Add(x, y)
got, acc := z.Float32()
want := float32(y0) + float32(x0)
if got != want || acc != Exact {
t.Errorf("d = %d: %g + %g = %g (%s); want %g (Exact)", d, x0, y0, got, acc, want)
}
z.Sub(z, y)
got, acc = z.Float32()
want = float32(want) - float32(y0)
if got != want || acc != Exact {
t.Errorf("d = %d: %g - %g = %g (%s); want %g (Exact)", d, x0+y0, y0, got, acc, want)
}
}
}
}
// TestFloatAdd64 tests that Float.Add/Sub of numbers with
// 53bit mantissa behaves like float64 addition/subtraction.
func TestFloatAdd64(t *testing.T) {
// chose base such that we cross the mantissa precision limit
const base = 1<<55 - 0x10 // 11...110000 (55 bits)
for d := 0; d <= 0x10; d++ {
for i := range [2]int{} {
x0, y0 := float64(base), float64(d)
if i&1 != 0 {
x0, y0 = y0, x0
}
x := NewFloat(x0)
y := NewFloat(y0)
z := new(Float).SetPrec(53)
z.Add(x, y)
got, acc := z.Float64()
want := x0 + y0
if got != want || acc != Exact {
t.Errorf("d = %d: %g + %g = %g (%s); want %g (Exact)", d, x0, y0, got, acc, want)
}
z.Sub(z, y)
got, acc = z.Float64()
want -= y0
if got != want || acc != Exact {
t.Errorf("d = %d: %g - %g = %g (%s); want %g (Exact)", d, x0+y0, y0, got, acc, want)
}
}
}
}
func TestIssue20490(t *testing.T) {
var tests = []struct {
a, b float64
}{
{4, 1},
{-4, 1},
{4, -1},
{-4, -1},
}
for _, test := range tests {
a, b := NewFloat(test.a), NewFloat(test.b)
diff := new(Float).Sub(a, b)
b.Sub(a, b)
if b.Cmp(diff) != 0 {
t.Errorf("got %g - %g = %g; want %g\n", a, NewFloat(test.b), b, diff)
}
b = NewFloat(test.b)
sum := new(Float).Add(a, b)
b.Add(a, b)
if b.Cmp(sum) != 0 {
t.Errorf("got %g + %g = %g; want %g\n", a, NewFloat(test.b), b, sum)
}
}
}
// TestFloatMul tests Float.Mul/Quo by comparing the result of a "manual"
// multiplication/division of arguments represented by Bits values with the
// respective Float multiplication/division for a variety of precisions
// and rounding modes.
func TestFloatMul(t *testing.T) {
for _, xbits := range bitsList {
for _, ybits := range bitsList {
// exact values
x := xbits.Float()
y := ybits.Float()
zbits := xbits.mul(ybits)
z := zbits.Float()
for i, mode := range [...]RoundingMode{ToZero, ToNearestEven, AwayFromZero} {
for _, prec := range precList {
got := new(Float).SetPrec(prec).SetMode(mode)
got.Mul(x, y)
want := zbits.round(prec, mode)
if got.Cmp(want) != 0 {
t.Errorf("i = %d, prec = %d, %s:\n\t %v %v\n\t* %v %v\n\t= %v\n\twant %v",
i, prec, mode, x, xbits, y, ybits, got, want)
}
if x.Sign() == 0 {
continue // ignore div-0 case (not invertable)
}
got.Quo(z, x)
want = ybits.round(prec, mode)
if got.Cmp(want) != 0 {
t.Errorf("i = %d, prec = %d, %s:\n\t %v %v\n\t/ %v %v\n\t= %v\n\twant %v",
i, prec, mode, z, zbits, x, xbits, got, want)
}
}
}
}
}
}
// TestFloatMul64 tests that Float.Mul/Quo of numbers with
// 53bit mantissa behaves like float64 multiplication/division.
func TestFloatMul64(t *testing.T) {
for _, test := range []struct {
x, y float64
}{
{0, 0},
{0, 1},
{1, 1},
{1, 1.5},
{1.234, 0.5678},
{2.718281828, 3.14159265358979},
{2.718281828e10, 3.14159265358979e-32},
{1.0 / 3, 1e200},
} {
for i := range [8]int{} {
x0, y0 := test.x, test.y
if i&1 != 0 {
x0 = -x0
}
if i&2 != 0 {
y0 = -y0
}
if i&4 != 0 {
x0, y0 = y0, x0
}
x := NewFloat(x0)
y := NewFloat(y0)
z := new(Float).SetPrec(53)
z.Mul(x, y)
got, _ := z.Float64()
want := x0 * y0
if got != want {
t.Errorf("%g * %g = %g; want %g", x0, y0, got, want)
}
if y0 == 0 {
continue // avoid division-by-zero
}
z.Quo(z, y)
got, _ = z.Float64()
want /= y0
if got != want {
t.Errorf("%g / %g = %g; want %g", x0*y0, y0, got, want)
}
}
}
}
func TestIssue6866(t *testing.T) {
for _, prec := range precList {
two := new(Float).SetPrec(prec).SetInt64(2)
one := new(Float).SetPrec(prec).SetInt64(1)
three := new(Float).SetPrec(prec).SetInt64(3)
msix := new(Float).SetPrec(prec).SetInt64(-6)
psix := new(Float).SetPrec(prec).SetInt64(+6)
p := new(Float).SetPrec(prec)
z1 := new(Float).SetPrec(prec)
z2 := new(Float).SetPrec(prec)
// z1 = 2 + 1.0/3*-6
p.Quo(one, three)
p.Mul(p, msix)
z1.Add(two, p)
// z2 = 2 - 1.0/3*+6
p.Quo(one, three)
p.Mul(p, psix)
z2.Sub(two, p)
if z1.Cmp(z2) != 0 {
t.Fatalf("prec %d: got z1 = %v != z2 = %v; want z1 == z2\n", prec, z1, z2)
}
if z1.Sign() != 0 {
t.Errorf("prec %d: got z1 = %v; want 0", prec, z1)
}
if z2.Sign() != 0 {
t.Errorf("prec %d: got z2 = %v; want 0", prec, z2)
}
}
}
func TestFloatQuo(t *testing.T) {
// TODO(gri) make the test vary these precisions
preci := 200 // precision of integer part
precf := 20 // precision of fractional part
for i := 0; i < 8; i++ {
// compute accurate (not rounded) result z
bits := Bits{preci - 1}
if i&3 != 0 {
bits = append(bits, 0)
}
if i&2 != 0 {
bits = append(bits, -1)
}
if i&1 != 0 {
bits = append(bits, -precf)
}
z := bits.Float()
// compute accurate x as z*y
y := NewFloat(3.14159265358979323e123)
x := new(Float).SetPrec(z.Prec() + y.Prec()).SetMode(ToZero)
x.Mul(z, y)
// leave for debugging
// fmt.Printf("x = %s\ny = %s\nz = %s\n", x, y, z)
if got := x.Acc(); got != Exact {
t.Errorf("got acc = %s; want exact", got)
}
// round accurate z for a variety of precisions and
// modes and compare against result of x / y.
for _, mode := range [...]RoundingMode{ToZero, ToNearestEven, AwayFromZero} {
for d := -5; d < 5; d++ {
prec := uint(preci + d)
got := new(Float).SetPrec(prec).SetMode(mode).Quo(x, y)
want := bits.round(prec, mode)
if got.Cmp(want) != 0 {
t.Errorf("i = %d, prec = %d, %s:\n\t %s\n\t/ %s\n\t= %s\n\twant %s",
i, prec, mode, x, y, got, want)
}
}
}
}
}
var long = flag.Bool("long", false, "run very long tests")
// TestFloatQuoSmoke tests all divisions x/y for values x, y in the range [-n, +n];
// it serves as a smoke test for basic correctness of division.
func TestFloatQuoSmoke(t *testing.T) {
n := 10
if *long {
n = 1000
}
const dprec = 3 // max. precision variation
const prec = 10 + dprec // enough bits to hold n precisely
for x := -n; x <= n; x++ {
for y := -n; y < n; y++ {
if y == 0 {
continue
}
a := float64(x)
b := float64(y)
c := a / b
// vary operand precision (only ok as long as a, b can be represented correctly)
for ad := -dprec; ad <= dprec; ad++ {
for bd := -dprec; bd <= dprec; bd++ {
A := new(Float).SetPrec(uint(prec + ad)).SetFloat64(a)
B := new(Float).SetPrec(uint(prec + bd)).SetFloat64(b)
C := new(Float).SetPrec(53).Quo(A, B) // C has float64 mantissa width
cc, acc := C.Float64()
if cc != c {
t.Errorf("%g/%g = %s; want %.5g\n", a, b, C.Text('g', 5), c)
continue
}
if acc != Exact {
t.Errorf("%g/%g got %s result; want exact result", a, b, acc)
}
}
}
}
}
}
// TestFloatArithmeticSpecialValues tests that Float operations produce the
// correct results for combinations of zero (±0), finite (±1 and ±2.71828),
// and infinite (±Inf) operands.
func TestFloatArithmeticSpecialValues(t *testing.T) {
zero := 0.0
args := []float64{math.Inf(-1), -2.71828, -1, -zero, zero, 1, 2.71828, math.Inf(1)}
xx := new(Float)
yy := new(Float)
got := new(Float)
want := new(Float)
for i := 0; i < 4; i++ {
for _, x := range args {
xx.SetFloat64(x)
// check conversion is correct
// (no need to do this for y, since we see exactly the
// same values there)
if got, acc := xx.Float64(); got != x || acc != Exact {
t.Errorf("Float(%g) == %g (%s)", x, got, acc)
}
for _, y := range args {
yy.SetFloat64(y)
var (
op string
z float64
f func(z, x, y *Float) *Float
)
switch i {
case 0:
op = "+"
z = x + y
f = (*Float).Add
case 1:
op = "-"
z = x - y
f = (*Float).Sub
case 2:
op = "*"
z = x * y
f = (*Float).Mul
case 3:
op = "/"
z = x / y
f = (*Float).Quo
default:
panic("unreachable")
}
var errnan bool // set if execution of f panicked with ErrNaN
// protect execution of f
func() {
defer func() {
if p := recover(); p != nil {
_ = p.(ErrNaN) // re-panic if not ErrNaN
errnan = true
}
}()
f(got, xx, yy)
}()
if math.IsNaN(z) {
if !errnan {
t.Errorf("%5g %s %5g = %5s; want ErrNaN panic", x, op, y, got)
}
continue
}
if errnan {
t.Errorf("%5g %s %5g panicked with ErrNan; want %5s", x, op, y, want)
continue
}
want.SetFloat64(z)
if !alike(got, want) {
t.Errorf("%5g %s %5g = %5s; want %5s", x, op, y, got, want)
}
}
}
}
}
func TestFloatArithmeticOverflow(t *testing.T) {
for _, test := range []struct {
prec uint
mode RoundingMode
op byte
x, y, want string
acc Accuracy
}{
{4, ToNearestEven, '+', "0", "0", "0", Exact}, // smoke test
{4, ToNearestEven, '+', "0x.8p+0", "0x.8p+0", "0x.8p+1", Exact}, // smoke test
{4, ToNearestEven, '+', "0", "0x.8p2147483647", "0x.8p+2147483647", Exact},
{4, ToNearestEven, '+', "0x.8p2147483500", "0x.8p2147483647", "0x.8p+2147483647", Below}, // rounded to zero
{4, ToNearestEven, '+', "0x.8p2147483647", "0x.8p2147483647", "+Inf", Above}, // exponent overflow in +
{4, ToNearestEven, '+', "-0x.8p2147483647", "-0x.8p2147483647", "-Inf", Below}, // exponent overflow in +
{4, ToNearestEven, '-', "-0x.8p2147483647", "0x.8p2147483647", "-Inf", Below}, // exponent overflow in -
{4, ToZero, '+', "0x.fp2147483647", "0x.8p2147483643", "0x.fp+2147483647", Below}, // rounded to zero
{4, ToNearestEven, '+', "0x.fp2147483647", "0x.8p2147483643", "+Inf", Above}, // exponent overflow in rounding
{4, AwayFromZero, '+', "0x.fp2147483647", "0x.8p2147483643", "+Inf", Above}, // exponent overflow in rounding
{4, AwayFromZero, '-', "-0x.fp2147483647", "0x.8p2147483644", "-Inf", Below}, // exponent overflow in rounding
{4, ToNearestEven, '-', "-0x.fp2147483647", "0x.8p2147483643", "-Inf", Below}, // exponent overflow in rounding
{4, ToZero, '-', "-0x.fp2147483647", "0x.8p2147483643", "-0x.fp+2147483647", Above}, // rounded to zero
{4, ToNearestEven, '+', "0", "0x.8p-2147483648", "0x.8p-2147483648", Exact},
{4, ToNearestEven, '+', "0x.8p-2147483648", "0x.8p-2147483648", "0x.8p-2147483647", Exact},
{4, ToNearestEven, '*', "1", "0x.8p2147483647", "0x.8p+2147483647", Exact},
{4, ToNearestEven, '*', "2", "0x.8p2147483647", "+Inf", Above}, // exponent overflow in *
{4, ToNearestEven, '*', "-2", "0x.8p2147483647", "-Inf", Below}, // exponent overflow in *
{4, ToNearestEven, '/', "0.5", "0x.8p2147483647", "0x.8p-2147483646", Exact},
{4, ToNearestEven, '/', "0x.8p+0", "0x.8p2147483647", "0x.8p-2147483646", Exact},
{4, ToNearestEven, '/', "0x.8p-1", "0x.8p2147483647", "0x.8p-2147483647", Exact},
{4, ToNearestEven, '/', "0x.8p-2", "0x.8p2147483647", "0x.8p-2147483648", Exact},
{4, ToNearestEven, '/', "0x.8p-3", "0x.8p2147483647", "0", Below}, // exponent underflow in /
} {
x := makeFloat(test.x)
y := makeFloat(test.y)
z := new(Float).SetPrec(test.prec).SetMode(test.mode)
switch test.op {
case '+':
z.Add(x, y)
case '-':
z.Sub(x, y)
case '*':
z.Mul(x, y)
case '/':
z.Quo(x, y)
default:
panic("unreachable")
}
if got := z.Text('p', 0); got != test.want || z.Acc() != test.acc {
t.Errorf(
"prec = %d (%s): %s %c %s = %s (%s); want %s (%s)",
test.prec, test.mode, x.Text('p', 0), test.op, y.Text('p', 0), got, z.Acc(), test.want, test.acc,
)
}
}
}
// TODO(gri) Add tests that check correctness in the presence of aliasing.
// For rounding modes ToNegativeInf and ToPositiveInf, rounding is affected
// by the sign of the value to be rounded. Test that rounding happens after
// the sign of a result has been set.
// This test uses specific values that are known to fail if rounding is
// "factored" out before setting the result sign.
func TestFloatArithmeticRounding(t *testing.T) {
for _, test := range []struct {
mode RoundingMode
prec uint
x, y, want int64
op byte
}{
{ToZero, 3, -0x8, -0x1, -0x8, '+'},
{AwayFromZero, 3, -0x8, -0x1, -0xa, '+'},
{ToNegativeInf, 3, -0x8, -0x1, -0xa, '+'},
{ToZero, 3, -0x8, 0x1, -0x8, '-'},
{AwayFromZero, 3, -0x8, 0x1, -0xa, '-'},
{ToNegativeInf, 3, -0x8, 0x1, -0xa, '-'},
{ToZero, 3, -0x9, 0x1, -0x8, '*'},
{AwayFromZero, 3, -0x9, 0x1, -0xa, '*'},
{ToNegativeInf, 3, -0x9, 0x1, -0xa, '*'},
{ToZero, 3, -0x9, 0x1, -0x8, '/'},
{AwayFromZero, 3, -0x9, 0x1, -0xa, '/'},
{ToNegativeInf, 3, -0x9, 0x1, -0xa, '/'},
} {
var x, y, z Float
x.SetInt64(test.x)
y.SetInt64(test.y)
z.SetPrec(test.prec).SetMode(test.mode)
switch test.op {
case '+':
z.Add(&x, &y)
case '-':
z.Sub(&x, &y)
case '*':
z.Mul(&x, &y)
case '/':
z.Quo(&x, &y)
default:
panic("unreachable")
}
if got, acc := z.Int64(); got != test.want || acc != Exact {
t.Errorf("%s, %d bits: %d %c %d = %d (%s); want %d (Exact)",
test.mode, test.prec, test.x, test.op, test.y, got, acc, test.want,
)
}
}
}
// TestFloatCmpSpecialValues tests that Cmp produces the correct results for
// combinations of zero (±0), finite (±1 and ±2.71828), and infinite (±Inf)
// operands.
func TestFloatCmpSpecialValues(t *testing.T) {
zero := 0.0
args := []float64{math.Inf(-1), -2.71828, -1, -zero, zero, 1, 2.71828, math.Inf(1)}
xx := new(Float)
yy := new(Float)
for i := 0; i < 4; i++ {
for _, x := range args {
xx.SetFloat64(x)
// check conversion is correct
// (no need to do this for y, since we see exactly the
// same values there)
if got, acc := xx.Float64(); got != x || acc != Exact {
t.Errorf("Float(%g) == %g (%s)", x, got, acc)
}
for _, y := range args {
yy.SetFloat64(y)
got := xx.Cmp(yy)
want := 0
switch {
case x < y:
want = -1
case x > y:
want = +1
}
if got != want {
t.Errorf("(%g).Cmp(%g) = %v; want %v", x, y, got, want)
}
}
}
}
}
func BenchmarkFloatAdd(b *testing.B) {
x := new(Float)
y := new(Float)
z := new(Float)
for _, prec := range []uint{10, 1e2, 1e3, 1e4, 1e5} {
x.SetPrec(prec).SetRat(NewRat(1, 3))
y.SetPrec(prec).SetRat(NewRat(1, 6))
z.SetPrec(prec)
b.Run(fmt.Sprintf("%v", prec), func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
z.Add(x, y)
}
})
}
}
func BenchmarkFloatSub(b *testing.B) {
x := new(Float)
y := new(Float)
z := new(Float)
for _, prec := range []uint{10, 1e2, 1e3, 1e4, 1e5} {
x.SetPrec(prec).SetRat(NewRat(1, 3))
y.SetPrec(prec).SetRat(NewRat(1, 6))
z.SetPrec(prec)
b.Run(fmt.Sprintf("%v", prec), func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
z.Sub(x, y)
}
})
}
}