...
Run Format

Source file src/math/big/float_test.go

Documentation: math/big

     1  // Copyright 2014 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package big
     6  
     7  import (
     8  	"flag"
     9  	"fmt"
    10  	"math"
    11  	"strconv"
    12  	"strings"
    13  	"testing"
    14  )
    15  
    16  // Verify that ErrNaN implements the error interface.
    17  var _ error = ErrNaN{}
    18  
    19  func (x *Float) uint64() uint64 {
    20  	u, acc := x.Uint64()
    21  	if acc != Exact {
    22  		panic(fmt.Sprintf("%s is not a uint64", x.Text('g', 10)))
    23  	}
    24  	return u
    25  }
    26  
    27  func (x *Float) int64() int64 {
    28  	i, acc := x.Int64()
    29  	if acc != Exact {
    30  		panic(fmt.Sprintf("%s is not an int64", x.Text('g', 10)))
    31  	}
    32  	return i
    33  }
    34  
    35  func TestFloatZeroValue(t *testing.T) {
    36  	// zero (uninitialized) value is a ready-to-use 0.0
    37  	var x Float
    38  	if s := x.Text('f', 1); s != "0.0" {
    39  		t.Errorf("zero value = %s; want 0.0", s)
    40  	}
    41  
    42  	// zero value has precision 0
    43  	if prec := x.Prec(); prec != 0 {
    44  		t.Errorf("prec = %d; want 0", prec)
    45  	}
    46  
    47  	// zero value can be used in any and all positions of binary operations
    48  	make := func(x int) *Float {
    49  		var f Float
    50  		if x != 0 {
    51  			f.SetInt64(int64(x))
    52  		}
    53  		// x == 0 translates into the zero value
    54  		return &f
    55  	}
    56  	for _, test := range []struct {
    57  		z, x, y, want int
    58  		opname        rune
    59  		op            func(z, x, y *Float) *Float
    60  	}{
    61  		{0, 0, 0, 0, '+', (*Float).Add},
    62  		{0, 1, 2, 3, '+', (*Float).Add},
    63  		{1, 2, 0, 2, '+', (*Float).Add},
    64  		{2, 0, 1, 1, '+', (*Float).Add},
    65  
    66  		{0, 0, 0, 0, '-', (*Float).Sub},
    67  		{0, 1, 2, -1, '-', (*Float).Sub},
    68  		{1, 2, 0, 2, '-', (*Float).Sub},
    69  		{2, 0, 1, -1, '-', (*Float).Sub},
    70  
    71  		{0, 0, 0, 0, '*', (*Float).Mul},
    72  		{0, 1, 2, 2, '*', (*Float).Mul},
    73  		{1, 2, 0, 0, '*', (*Float).Mul},
    74  		{2, 0, 1, 0, '*', (*Float).Mul},
    75  
    76  		// {0, 0, 0, 0, '/', (*Float).Quo}, // panics
    77  		{0, 2, 1, 2, '/', (*Float).Quo},
    78  		{1, 2, 0, 0, '/', (*Float).Quo}, // = +Inf
    79  		{2, 0, 1, 0, '/', (*Float).Quo},
    80  	} {
    81  		z := make(test.z)
    82  		test.op(z, make(test.x), make(test.y))
    83  		got := 0
    84  		if !z.IsInf() {
    85  			got = int(z.int64())
    86  		}
    87  		if got != test.want {
    88  			t.Errorf("%d %c %d = %d; want %d", test.x, test.opname, test.y, got, test.want)
    89  		}
    90  	}
    91  
    92  	// TODO(gri) test how precision is set for zero value results
    93  }
    94  
    95  func makeFloat(s string) *Float {
    96  	x, _, err := ParseFloat(s, 0, 1000, ToNearestEven)
    97  	if err != nil {
    98  		panic(err)
    99  	}
   100  	return x
   101  }
   102  
   103  func TestFloatSetPrec(t *testing.T) {
   104  	for _, test := range []struct {
   105  		x    string
   106  		prec uint
   107  		want string
   108  		acc  Accuracy
   109  	}{
   110  		// prec 0
   111  		{"0", 0, "0", Exact},
   112  		{"-0", 0, "-0", Exact},
   113  		{"-Inf", 0, "-Inf", Exact},
   114  		{"+Inf", 0, "+Inf", Exact},
   115  		{"123", 0, "0", Below},
   116  		{"-123", 0, "-0", Above},
   117  
   118  		// prec at upper limit
   119  		{"0", MaxPrec, "0", Exact},
   120  		{"-0", MaxPrec, "-0", Exact},
   121  		{"-Inf", MaxPrec, "-Inf", Exact},
   122  		{"+Inf", MaxPrec, "+Inf", Exact},
   123  
   124  		// just a few regular cases - general rounding is tested elsewhere
   125  		{"1.5", 1, "2", Above},
   126  		{"-1.5", 1, "-2", Below},
   127  		{"123", 1e6, "123", Exact},
   128  		{"-123", 1e6, "-123", Exact},
   129  	} {
   130  		x := makeFloat(test.x).SetPrec(test.prec)
   131  		prec := test.prec
   132  		if prec > MaxPrec {
   133  			prec = MaxPrec
   134  		}
   135  		if got := x.Prec(); got != prec {
   136  			t.Errorf("%s.SetPrec(%d).Prec() == %d; want %d", test.x, test.prec, got, prec)
   137  		}
   138  		if got, acc := x.String(), x.Acc(); got != test.want || acc != test.acc {
   139  			t.Errorf("%s.SetPrec(%d) = %s (%s); want %s (%s)", test.x, test.prec, got, acc, test.want, test.acc)
   140  		}
   141  	}
   142  }
   143  
   144  func TestFloatMinPrec(t *testing.T) {
   145  	const max = 100
   146  	for _, test := range []struct {
   147  		x    string
   148  		want uint
   149  	}{
   150  		{"0", 0},
   151  		{"-0", 0},
   152  		{"+Inf", 0},
   153  		{"-Inf", 0},
   154  		{"1", 1},
   155  		{"2", 1},
   156  		{"3", 2},
   157  		{"0x8001", 16},
   158  		{"0x8001p-1000", 16},
   159  		{"0x8001p+1000", 16},
   160  		{"0.1", max},
   161  	} {
   162  		x := makeFloat(test.x).SetPrec(max)
   163  		if got := x.MinPrec(); got != test.want {
   164  			t.Errorf("%s.MinPrec() = %d; want %d", test.x, got, test.want)
   165  		}
   166  	}
   167  }
   168  
   169  func TestFloatSign(t *testing.T) {
   170  	for _, test := range []struct {
   171  		x string
   172  		s int
   173  	}{
   174  		{"-Inf", -1},
   175  		{"-1", -1},
   176  		{"-0", 0},
   177  		{"+0", 0},
   178  		{"+1", +1},
   179  		{"+Inf", +1},
   180  	} {
   181  		x := makeFloat(test.x)
   182  		s := x.Sign()
   183  		if s != test.s {
   184  			t.Errorf("%s.Sign() = %d; want %d", test.x, s, test.s)
   185  		}
   186  	}
   187  }
   188  
   189  // alike(x, y) is like x.Cmp(y) == 0 but also considers the sign of 0 (0 != -0).
   190  func alike(x, y *Float) bool {
   191  	return x.Cmp(y) == 0 && x.Signbit() == y.Signbit()
   192  }
   193  
   194  func alike32(x, y float32) bool {
   195  	// we can ignore NaNs
   196  	return x == y && math.Signbit(float64(x)) == math.Signbit(float64(y))
   197  
   198  }
   199  
   200  func alike64(x, y float64) bool {
   201  	// we can ignore NaNs
   202  	return x == y && math.Signbit(x) == math.Signbit(y)
   203  
   204  }
   205  
   206  func TestFloatMantExp(t *testing.T) {
   207  	for _, test := range []struct {
   208  		x    string
   209  		mant string
   210  		exp  int
   211  	}{
   212  		{"0", "0", 0},
   213  		{"+0", "0", 0},
   214  		{"-0", "-0", 0},
   215  		{"Inf", "+Inf", 0},
   216  		{"+Inf", "+Inf", 0},
   217  		{"-Inf", "-Inf", 0},
   218  		{"1.5", "0.75", 1},
   219  		{"1.024e3", "0.5", 11},
   220  		{"-0.125", "-0.5", -2},
   221  	} {
   222  		x := makeFloat(test.x)
   223  		mant := makeFloat(test.mant)
   224  		m := new(Float)
   225  		e := x.MantExp(m)
   226  		if !alike(m, mant) || e != test.exp {
   227  			t.Errorf("%s.MantExp() = %s, %d; want %s, %d", test.x, m.Text('g', 10), e, test.mant, test.exp)
   228  		}
   229  	}
   230  }
   231  
   232  func TestFloatMantExpAliasing(t *testing.T) {
   233  	x := makeFloat("0.5p10")
   234  	if e := x.MantExp(x); e != 10 {
   235  		t.Fatalf("Float.MantExp aliasing error: got %d; want 10", e)
   236  	}
   237  	if want := makeFloat("0.5"); !alike(x, want) {
   238  		t.Fatalf("Float.MantExp aliasing error: got %s; want %s", x.Text('g', 10), want.Text('g', 10))
   239  	}
   240  }
   241  
   242  func TestFloatSetMantExp(t *testing.T) {
   243  	for _, test := range []struct {
   244  		frac string
   245  		exp  int
   246  		z    string
   247  	}{
   248  		{"0", 0, "0"},
   249  		{"+0", 0, "0"},
   250  		{"-0", 0, "-0"},
   251  		{"Inf", 1234, "+Inf"},
   252  		{"+Inf", -1234, "+Inf"},
   253  		{"-Inf", -1234, "-Inf"},
   254  		{"0", MinExp, "0"},
   255  		{"0.25", MinExp, "+0"},    // exponent underflow
   256  		{"-0.25", MinExp, "-0"},   // exponent underflow
   257  		{"1", MaxExp, "+Inf"},     // exponent overflow
   258  		{"2", MaxExp - 1, "+Inf"}, // exponent overflow
   259  		{"0.75", 1, "1.5"},
   260  		{"0.5", 11, "1024"},
   261  		{"-0.5", -2, "-0.125"},
   262  		{"32", 5, "1024"},
   263  		{"1024", -10, "1"},
   264  	} {
   265  		frac := makeFloat(test.frac)
   266  		want := makeFloat(test.z)
   267  		var z Float
   268  		z.SetMantExp(frac, test.exp)
   269  		if !alike(&z, want) {
   270  			t.Errorf("SetMantExp(%s, %d) = %s; want %s", test.frac, test.exp, z.Text('g', 10), test.z)
   271  		}
   272  		// test inverse property
   273  		mant := new(Float)
   274  		if z.SetMantExp(mant, want.MantExp(mant)).Cmp(want) != 0 {
   275  			t.Errorf("Inverse property not satisfied: got %s; want %s", z.Text('g', 10), test.z)
   276  		}
   277  	}
   278  }
   279  
   280  func TestFloatPredicates(t *testing.T) {
   281  	for _, test := range []struct {
   282  		x            string
   283  		sign         int
   284  		signbit, inf bool
   285  	}{
   286  		{x: "-Inf", sign: -1, signbit: true, inf: true},
   287  		{x: "-1", sign: -1, signbit: true},
   288  		{x: "-0", signbit: true},
   289  		{x: "0"},
   290  		{x: "1", sign: 1},
   291  		{x: "+Inf", sign: 1, inf: true},
   292  	} {
   293  		x := makeFloat(test.x)
   294  		if got := x.Signbit(); got != test.signbit {
   295  			t.Errorf("(%s).Signbit() = %v; want %v", test.x, got, test.signbit)
   296  		}
   297  		if got := x.Sign(); got != test.sign {
   298  			t.Errorf("(%s).Sign() = %d; want %d", test.x, got, test.sign)
   299  		}
   300  		if got := x.IsInf(); got != test.inf {
   301  			t.Errorf("(%s).IsInf() = %v; want %v", test.x, got, test.inf)
   302  		}
   303  	}
   304  }
   305  
   306  func TestFloatIsInt(t *testing.T) {
   307  	for _, test := range []string{
   308  		"0 int",
   309  		"-0 int",
   310  		"1 int",
   311  		"-1 int",
   312  		"0.5",
   313  		"1.23",
   314  		"1.23e1",
   315  		"1.23e2 int",
   316  		"0.000000001e+8",
   317  		"0.000000001e+9 int",
   318  		"1.2345e200 int",
   319  		"Inf",
   320  		"+Inf",
   321  		"-Inf",
   322  	} {
   323  		s := strings.TrimSuffix(test, " int")
   324  		want := s != test
   325  		if got := makeFloat(s).IsInt(); got != want {
   326  			t.Errorf("%s.IsInt() == %t", s, got)
   327  		}
   328  	}
   329  }
   330  
   331  func fromBinary(s string) int64 {
   332  	x, err := strconv.ParseInt(s, 2, 64)
   333  	if err != nil {
   334  		panic(err)
   335  	}
   336  	return x
   337  }
   338  
   339  func toBinary(x int64) string {
   340  	return strconv.FormatInt(x, 2)
   341  }
   342  
   343  func testFloatRound(t *testing.T, x, r int64, prec uint, mode RoundingMode) {
   344  	// verify test data
   345  	var ok bool
   346  	switch mode {
   347  	case ToNearestEven, ToNearestAway:
   348  		ok = true // nothing to do for now
   349  	case ToZero:
   350  		if x < 0 {
   351  			ok = r >= x
   352  		} else {
   353  			ok = r <= x
   354  		}
   355  	case AwayFromZero:
   356  		if x < 0 {
   357  			ok = r <= x
   358  		} else {
   359  			ok = r >= x
   360  		}
   361  	case ToNegativeInf:
   362  		ok = r <= x
   363  	case ToPositiveInf:
   364  		ok = r >= x
   365  	default:
   366  		panic("unreachable")
   367  	}
   368  	if !ok {
   369  		t.Fatalf("incorrect test data for prec = %d, %s: x = %s, r = %s", prec, mode, toBinary(x), toBinary(r))
   370  	}
   371  
   372  	// compute expected accuracy
   373  	a := Exact
   374  	switch {
   375  	case r < x:
   376  		a = Below
   377  	case r > x:
   378  		a = Above
   379  	}
   380  
   381  	// round
   382  	f := new(Float).SetMode(mode).SetInt64(x).SetPrec(prec)
   383  
   384  	// check result
   385  	r1 := f.int64()
   386  	p1 := f.Prec()
   387  	a1 := f.Acc()
   388  	if r1 != r || p1 != prec || a1 != a {
   389  		t.Errorf("round %s (%d bits, %s) incorrect: got %s (%d bits, %s); want %s (%d bits, %s)",
   390  			toBinary(x), prec, mode,
   391  			toBinary(r1), p1, a1,
   392  			toBinary(r), prec, a)
   393  		return
   394  	}
   395  
   396  	// g and f should be the same
   397  	// (rounding by SetPrec after SetInt64 using default precision
   398  	// should be the same as rounding by SetInt64 after setting the
   399  	// precision)
   400  	g := new(Float).SetMode(mode).SetPrec(prec).SetInt64(x)
   401  	if !alike(g, f) {
   402  		t.Errorf("round %s (%d bits, %s) not symmetric: got %s and %s; want %s",
   403  			toBinary(x), prec, mode,
   404  			toBinary(g.int64()),
   405  			toBinary(r1),
   406  			toBinary(r),
   407  		)
   408  		return
   409  	}
   410  
   411  	// h and f should be the same
   412  	// (repeated rounding should be idempotent)
   413  	h := new(Float).SetMode(mode).SetPrec(prec).Set(f)
   414  	if !alike(h, f) {
   415  		t.Errorf("round %s (%d bits, %s) not idempotent: got %s and %s; want %s",
   416  			toBinary(x), prec, mode,
   417  			toBinary(h.int64()),
   418  			toBinary(r1),
   419  			toBinary(r),
   420  		)
   421  		return
   422  	}
   423  }
   424  
   425  // TestFloatRound tests basic rounding.
   426  func TestFloatRound(t *testing.T) {
   427  	for _, test := range []struct {
   428  		prec                        uint
   429  		x, zero, neven, naway, away string // input, results rounded to prec bits
   430  	}{
   431  		{5, "1000", "1000", "1000", "1000", "1000"},
   432  		{5, "1001", "1001", "1001", "1001", "1001"},
   433  		{5, "1010", "1010", "1010", "1010", "1010"},
   434  		{5, "1011", "1011", "1011", "1011", "1011"},
   435  		{5, "1100", "1100", "1100", "1100", "1100"},
   436  		{5, "1101", "1101", "1101", "1101", "1101"},
   437  		{5, "1110", "1110", "1110", "1110", "1110"},
   438  		{5, "1111", "1111", "1111", "1111", "1111"},
   439  
   440  		{4, "1000", "1000", "1000", "1000", "1000"},
   441  		{4, "1001", "1001", "1001", "1001", "1001"},
   442  		{4, "1010", "1010", "1010", "1010", "1010"},
   443  		{4, "1011", "1011", "1011", "1011", "1011"},
   444  		{4, "1100", "1100", "1100", "1100", "1100"},
   445  		{4, "1101", "1101", "1101", "1101", "1101"},
   446  		{4, "1110", "1110", "1110", "1110", "1110"},
   447  		{4, "1111", "1111", "1111", "1111", "1111"},
   448  
   449  		{3, "1000", "1000", "1000", "1000", "1000"},
   450  		{3, "1001", "1000", "1000", "1010", "1010"},
   451  		{3, "1010", "1010", "1010", "1010", "1010"},
   452  		{3, "1011", "1010", "1100", "1100", "1100"},
   453  		{3, "1100", "1100", "1100", "1100", "1100"},
   454  		{3, "1101", "1100", "1100", "1110", "1110"},
   455  		{3, "1110", "1110", "1110", "1110", "1110"},
   456  		{3, "1111", "1110", "10000", "10000", "10000"},
   457  
   458  		{3, "1000001", "1000000", "1000000", "1000000", "1010000"},
   459  		{3, "1001001", "1000000", "1010000", "1010000", "1010000"},
   460  		{3, "1010001", "1010000", "1010000", "1010000", "1100000"},
   461  		{3, "1011001", "1010000", "1100000", "1100000", "1100000"},
   462  		{3, "1100001", "1100000", "1100000", "1100000", "1110000"},
   463  		{3, "1101001", "1100000", "1110000", "1110000", "1110000"},
   464  		{3, "1110001", "1110000", "1110000", "1110000", "10000000"},
   465  		{3, "1111001", "1110000", "10000000", "10000000", "10000000"},
   466  
   467  		{2, "1000", "1000", "1000", "1000", "1000"},
   468  		{2, "1001", "1000", "1000", "1000", "1100"},
   469  		{2, "1010", "1000", "1000", "1100", "1100"},
   470  		{2, "1011", "1000", "1100", "1100", "1100"},
   471  		{2, "1100", "1100", "1100", "1100", "1100"},
   472  		{2, "1101", "1100", "1100", "1100", "10000"},
   473  		{2, "1110", "1100", "10000", "10000", "10000"},
   474  		{2, "1111", "1100", "10000", "10000", "10000"},
   475  
   476  		{2, "1000001", "1000000", "1000000", "1000000", "1100000"},
   477  		{2, "1001001", "1000000", "1000000", "1000000", "1100000"},
   478  		{2, "1010001", "1000000", "1100000", "1100000", "1100000"},
   479  		{2, "1011001", "1000000", "1100000", "1100000", "1100000"},
   480  		{2, "1100001", "1100000", "1100000", "1100000", "10000000"},
   481  		{2, "1101001", "1100000", "1100000", "1100000", "10000000"},
   482  		{2, "1110001", "1100000", "10000000", "10000000", "10000000"},
   483  		{2, "1111001", "1100000", "10000000", "10000000", "10000000"},
   484  
   485  		{1, "1000", "1000", "1000", "1000", "1000"},
   486  		{1, "1001", "1000", "1000", "1000", "10000"},
   487  		{1, "1010", "1000", "1000", "1000", "10000"},
   488  		{1, "1011", "1000", "1000", "1000", "10000"},
   489  		{1, "1100", "1000", "10000", "10000", "10000"},
   490  		{1, "1101", "1000", "10000", "10000", "10000"},
   491  		{1, "1110", "1000", "10000", "10000", "10000"},
   492  		{1, "1111", "1000", "10000", "10000", "10000"},
   493  
   494  		{1, "1000001", "1000000", "1000000", "1000000", "10000000"},
   495  		{1, "1001001", "1000000", "1000000", "1000000", "10000000"},
   496  		{1, "1010001", "1000000", "1000000", "1000000", "10000000"},
   497  		{1, "1011001", "1000000", "1000000", "1000000", "10000000"},
   498  		{1, "1100001", "1000000", "10000000", "10000000", "10000000"},
   499  		{1, "1101001", "1000000", "10000000", "10000000", "10000000"},
   500  		{1, "1110001", "1000000", "10000000", "10000000", "10000000"},
   501  		{1, "1111001", "1000000", "10000000", "10000000", "10000000"},
   502  	} {
   503  		x := fromBinary(test.x)
   504  		z := fromBinary(test.zero)
   505  		e := fromBinary(test.neven)
   506  		n := fromBinary(test.naway)
   507  		a := fromBinary(test.away)
   508  		prec := test.prec
   509  
   510  		testFloatRound(t, x, z, prec, ToZero)
   511  		testFloatRound(t, x, e, prec, ToNearestEven)
   512  		testFloatRound(t, x, n, prec, ToNearestAway)
   513  		testFloatRound(t, x, a, prec, AwayFromZero)
   514  
   515  		testFloatRound(t, x, z, prec, ToNegativeInf)
   516  		testFloatRound(t, x, a, prec, ToPositiveInf)
   517  
   518  		testFloatRound(t, -x, -a, prec, ToNegativeInf)
   519  		testFloatRound(t, -x, -z, prec, ToPositiveInf)
   520  	}
   521  }
   522  
   523  // TestFloatRound24 tests that rounding a float64 to 24 bits
   524  // matches IEEE-754 rounding to nearest when converting a
   525  // float64 to a float32 (excluding denormal numbers).
   526  func TestFloatRound24(t *testing.T) {
   527  	const x0 = 1<<26 - 0x10 // 11...110000 (26 bits)
   528  	for d := 0; d <= 0x10; d++ {
   529  		x := float64(x0 + d)
   530  		f := new(Float).SetPrec(24).SetFloat64(x)
   531  		got, _ := f.Float32()
   532  		want := float32(x)
   533  		if got != want {
   534  			t.Errorf("Round(%g, 24) = %g; want %g", x, got, want)
   535  		}
   536  	}
   537  }
   538  
   539  func TestFloatSetUint64(t *testing.T) {
   540  	for _, want := range []uint64{
   541  		0,
   542  		1,
   543  		2,
   544  		10,
   545  		100,
   546  		1<<32 - 1,
   547  		1 << 32,
   548  		1<<64 - 1,
   549  	} {
   550  		var f Float
   551  		f.SetUint64(want)
   552  		if got := f.uint64(); got != want {
   553  			t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
   554  		}
   555  	}
   556  
   557  	// test basic rounding behavior (exhaustive rounding testing is done elsewhere)
   558  	const x uint64 = 0x8765432187654321 // 64 bits needed
   559  	for prec := uint(1); prec <= 64; prec++ {
   560  		f := new(Float).SetPrec(prec).SetMode(ToZero).SetUint64(x)
   561  		got := f.uint64()
   562  		want := x &^ (1<<(64-prec) - 1) // cut off (round to zero) low 64-prec bits
   563  		if got != want {
   564  			t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
   565  		}
   566  	}
   567  }
   568  
   569  func TestFloatSetInt64(t *testing.T) {
   570  	for _, want := range []int64{
   571  		0,
   572  		1,
   573  		2,
   574  		10,
   575  		100,
   576  		1<<32 - 1,
   577  		1 << 32,
   578  		1<<63 - 1,
   579  	} {
   580  		for i := range [2]int{} {
   581  			if i&1 != 0 {
   582  				want = -want
   583  			}
   584  			var f Float
   585  			f.SetInt64(want)
   586  			if got := f.int64(); got != want {
   587  				t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
   588  			}
   589  		}
   590  	}
   591  
   592  	// test basic rounding behavior (exhaustive rounding testing is done elsewhere)
   593  	const x int64 = 0x7654321076543210 // 63 bits needed
   594  	for prec := uint(1); prec <= 63; prec++ {
   595  		f := new(Float).SetPrec(prec).SetMode(ToZero).SetInt64(x)
   596  		got := f.int64()
   597  		want := x &^ (1<<(63-prec) - 1) // cut off (round to zero) low 63-prec bits
   598  		if got != want {
   599  			t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
   600  		}
   601  	}
   602  }
   603  
   604  func TestFloatSetFloat64(t *testing.T) {
   605  	for _, want := range []float64{
   606  		0,
   607  		1,
   608  		2,
   609  		12345,
   610  		1e10,
   611  		1e100,
   612  		3.14159265e10,
   613  		2.718281828e-123,
   614  		1.0 / 3,
   615  		math.MaxFloat32,
   616  		math.MaxFloat64,
   617  		math.SmallestNonzeroFloat32,
   618  		math.SmallestNonzeroFloat64,
   619  		math.Inf(-1),
   620  		math.Inf(0),
   621  		-math.Inf(1),
   622  	} {
   623  		for i := range [2]int{} {
   624  			if i&1 != 0 {
   625  				want = -want
   626  			}
   627  			var f Float
   628  			f.SetFloat64(want)
   629  			if got, acc := f.Float64(); got != want || acc != Exact {
   630  				t.Errorf("got %g (%s, %s); want %g (Exact)", got, f.Text('p', 0), acc, want)
   631  			}
   632  		}
   633  	}
   634  
   635  	// test basic rounding behavior (exhaustive rounding testing is done elsewhere)
   636  	const x uint64 = 0x8765432143218 // 53 bits needed
   637  	for prec := uint(1); prec <= 52; prec++ {
   638  		f := new(Float).SetPrec(prec).SetMode(ToZero).SetFloat64(float64(x))
   639  		got, _ := f.Float64()
   640  		want := float64(x &^ (1<<(52-prec) - 1)) // cut off (round to zero) low 53-prec bits
   641  		if got != want {
   642  			t.Errorf("got %g (%s); want %g", got, f.Text('p', 0), want)
   643  		}
   644  	}
   645  
   646  	// test NaN
   647  	defer func() {
   648  		if p, ok := recover().(ErrNaN); !ok {
   649  			t.Errorf("got %v; want ErrNaN panic", p)
   650  		}
   651  	}()
   652  	var f Float
   653  	f.SetFloat64(math.NaN())
   654  	// should not reach here
   655  	t.Errorf("got %s; want ErrNaN panic", f.Text('p', 0))
   656  }
   657  
   658  func TestFloatSetInt(t *testing.T) {
   659  	for _, want := range []string{
   660  		"0",
   661  		"1",
   662  		"-1",
   663  		"1234567890",
   664  		"123456789012345678901234567890",
   665  		"123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
   666  	} {
   667  		var x Int
   668  		_, ok := x.SetString(want, 0)
   669  		if !ok {
   670  			t.Errorf("invalid integer %s", want)
   671  			continue
   672  		}
   673  		n := x.BitLen()
   674  
   675  		var f Float
   676  		f.SetInt(&x)
   677  
   678  		// check precision
   679  		if n < 64 {
   680  			n = 64
   681  		}
   682  		if prec := f.Prec(); prec != uint(n) {
   683  			t.Errorf("got prec = %d; want %d", prec, n)
   684  		}
   685  
   686  		// check value
   687  		got := f.Text('g', 100)
   688  		if got != want {
   689  			t.Errorf("got %s (%s); want %s", got, f.Text('p', 0), want)
   690  		}
   691  	}
   692  
   693  	// TODO(gri) test basic rounding behavior
   694  }
   695  
   696  func TestFloatSetRat(t *testing.T) {
   697  	for _, want := range []string{
   698  		"0",
   699  		"1",
   700  		"-1",
   701  		"1234567890",
   702  		"123456789012345678901234567890",
   703  		"123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
   704  		"1.2",
   705  		"3.14159265",
   706  		// TODO(gri) expand
   707  	} {
   708  		var x Rat
   709  		_, ok := x.SetString(want)
   710  		if !ok {
   711  			t.Errorf("invalid fraction %s", want)
   712  			continue
   713  		}
   714  		n := max(x.Num().BitLen(), x.Denom().BitLen())
   715  
   716  		var f1, f2 Float
   717  		f2.SetPrec(1000)
   718  		f1.SetRat(&x)
   719  		f2.SetRat(&x)
   720  
   721  		// check precision when set automatically
   722  		if n < 64 {
   723  			n = 64
   724  		}
   725  		if prec := f1.Prec(); prec != uint(n) {
   726  			t.Errorf("got prec = %d; want %d", prec, n)
   727  		}
   728  
   729  		got := f2.Text('g', 100)
   730  		if got != want {
   731  			t.Errorf("got %s (%s); want %s", got, f2.Text('p', 0), want)
   732  		}
   733  	}
   734  }
   735  
   736  func TestFloatSetInf(t *testing.T) {
   737  	var f Float
   738  	for _, test := range []struct {
   739  		signbit bool
   740  		prec    uint
   741  		want    string
   742  	}{
   743  		{false, 0, "+Inf"},
   744  		{true, 0, "-Inf"},
   745  		{false, 10, "+Inf"},
   746  		{true, 30, "-Inf"},
   747  	} {
   748  		x := f.SetPrec(test.prec).SetInf(test.signbit)
   749  		if got := x.String(); got != test.want || x.Prec() != test.prec {
   750  			t.Errorf("SetInf(%v) = %s (prec = %d); want %s (prec = %d)", test.signbit, got, x.Prec(), test.want, test.prec)
   751  		}
   752  	}
   753  }
   754  
   755  func TestFloatUint64(t *testing.T) {
   756  	for _, test := range []struct {
   757  		x   string
   758  		out uint64
   759  		acc Accuracy
   760  	}{
   761  		{"-Inf", 0, Above},
   762  		{"-1", 0, Above},
   763  		{"-1e-1000", 0, Above},
   764  		{"-0", 0, Exact},
   765  		{"0", 0, Exact},
   766  		{"1e-1000", 0, Below},
   767  		{"1", 1, Exact},
   768  		{"1.000000000000000000001", 1, Below},
   769  		{"12345.0", 12345, Exact},
   770  		{"12345.000000000000000000001", 12345, Below},
   771  		{"18446744073709551615", 18446744073709551615, Exact},
   772  		{"18446744073709551615.000000000000000000001", math.MaxUint64, Below},
   773  		{"18446744073709551616", math.MaxUint64, Below},
   774  		{"1e10000", math.MaxUint64, Below},
   775  		{"+Inf", math.MaxUint64, Below},
   776  	} {
   777  		x := makeFloat(test.x)
   778  		out, acc := x.Uint64()
   779  		if out != test.out || acc != test.acc {
   780  			t.Errorf("%s: got %d (%s); want %d (%s)", test.x, out, acc, test.out, test.acc)
   781  		}
   782  	}
   783  }
   784  
   785  func TestFloatInt64(t *testing.T) {
   786  	for _, test := range []struct {
   787  		x   string
   788  		out int64
   789  		acc Accuracy
   790  	}{
   791  		{"-Inf", math.MinInt64, Above},
   792  		{"-1e10000", math.MinInt64, Above},
   793  		{"-9223372036854775809", math.MinInt64, Above},
   794  		{"-9223372036854775808.000000000000000000001", math.MinInt64, Above},
   795  		{"-9223372036854775808", -9223372036854775808, Exact},
   796  		{"-9223372036854775807.000000000000000000001", -9223372036854775807, Above},
   797  		{"-9223372036854775807", -9223372036854775807, Exact},
   798  		{"-12345.000000000000000000001", -12345, Above},
   799  		{"-12345.0", -12345, Exact},
   800  		{"-1.000000000000000000001", -1, Above},
   801  		{"-1.5", -1, Above},
   802  		{"-1", -1, Exact},
   803  		{"-1e-1000", 0, Above},
   804  		{"0", 0, Exact},
   805  		{"1e-1000", 0, Below},
   806  		{"1", 1, Exact},
   807  		{"1.000000000000000000001", 1, Below},
   808  		{"1.5", 1, Below},
   809  		{"12345.0", 12345, Exact},
   810  		{"12345.000000000000000000001", 12345, Below},
   811  		{"9223372036854775807", 9223372036854775807, Exact},
   812  		{"9223372036854775807.000000000000000000001", math.MaxInt64, Below},
   813  		{"9223372036854775808", math.MaxInt64, Below},
   814  		{"1e10000", math.MaxInt64, Below},
   815  		{"+Inf", math.MaxInt64, Below},
   816  	} {
   817  		x := makeFloat(test.x)
   818  		out, acc := x.Int64()
   819  		if out != test.out || acc != test.acc {
   820  			t.Errorf("%s: got %d (%s); want %d (%s)", test.x, out, acc, test.out, test.acc)
   821  		}
   822  	}
   823  }
   824  
   825  func TestFloatFloat32(t *testing.T) {
   826  	for _, test := range []struct {
   827  		x   string
   828  		out float32
   829  		acc Accuracy
   830  	}{
   831  		{"0", 0, Exact},
   832  
   833  		// underflow to zero
   834  		{"1e-1000", 0, Below},
   835  		{"0x0.000002p-127", 0, Below},
   836  		{"0x.0000010p-126", 0, Below},
   837  
   838  		// denormals
   839  		{"1.401298464e-45", math.SmallestNonzeroFloat32, Above}, // rounded up to smallest denormal
   840  		{"0x.ffffff8p-149", math.SmallestNonzeroFloat32, Above}, // rounded up to smallest denormal
   841  		{"0x.0000018p-126", math.SmallestNonzeroFloat32, Above}, // rounded up to smallest denormal
   842  		{"0x.0000020p-126", math.SmallestNonzeroFloat32, Exact},
   843  		{"0x.8p-148", math.SmallestNonzeroFloat32, Exact},
   844  		{"1p-149", math.SmallestNonzeroFloat32, Exact},
   845  		{"0x.fffffep-126", math.Float32frombits(0x7fffff), Exact}, // largest denormal
   846  
   847  		// special denormal cases (see issues 14553, 14651)
   848  		{"0x0.0000001p-126", math.Float32frombits(0x00000000), Below}, // underflow to zero
   849  		{"0x0.0000008p-126", math.Float32frombits(0x00000000), Below}, // underflow to zero
   850  		{"0x0.0000010p-126", math.Float32frombits(0x00000000), Below}, // rounded down to even
   851  		{"0x0.0000011p-126", math.Float32frombits(0x00000001), Above}, // rounded up to smallest denormal
   852  		{"0x0.0000018p-126", math.Float32frombits(0x00000001), Above}, // rounded up to smallest denormal
   853  
   854  		{"0x1.0000000p-149", math.Float32frombits(0x00000001), Exact}, // smallest denormal
   855  		{"0x0.0000020p-126", math.Float32frombits(0x00000001), Exact}, // smallest denormal
   856  		{"0x0.fffffe0p-126", math.Float32frombits(0x007fffff), Exact}, // largest denormal
   857  		{"0x1.0000000p-126", math.Float32frombits(0x00800000), Exact}, // smallest normal
   858  
   859  		{"0x0.8p-149", math.Float32frombits(0x000000000), Below}, // rounded down to even
   860  		{"0x0.9p-149", math.Float32frombits(0x000000001), Above}, // rounded up to smallest denormal
   861  		{"0x0.ap-149", math.Float32frombits(0x000000001), Above}, // rounded up to smallest denormal
   862  		{"0x0.bp-149", math.Float32frombits(0x000000001), Above}, // rounded up to smallest denormal
   863  		{"0x0.cp-149", math.Float32frombits(0x000000001), Above}, // rounded up to smallest denormal
   864  
   865  		{"0x1.0p-149", math.Float32frombits(0x000000001), Exact}, // smallest denormal
   866  		{"0x1.7p-149", math.Float32frombits(0x000000001), Below},
   867  		{"0x1.8p-149", math.Float32frombits(0x000000002), Above},
   868  		{"0x1.9p-149", math.Float32frombits(0x000000002), Above},
   869  
   870  		{"0x2.0p-149", math.Float32frombits(0x000000002), Exact},
   871  		{"0x2.8p-149", math.Float32frombits(0x000000002), Below}, // rounded down to even
   872  		{"0x2.9p-149", math.Float32frombits(0x000000003), Above},
   873  
   874  		{"0x3.0p-149", math.Float32frombits(0x000000003), Exact},
   875  		{"0x3.7p-149", math.Float32frombits(0x000000003), Below},
   876  		{"0x3.8p-149", math.Float32frombits(0x000000004), Above}, // rounded up to even
   877  
   878  		{"0x4.0p-149", math.Float32frombits(0x000000004), Exact},
   879  		{"0x4.8p-149", math.Float32frombits(0x000000004), Below}, // rounded down to even
   880  		{"0x4.9p-149", math.Float32frombits(0x000000005), Above},
   881  
   882  		// specific case from issue 14553
   883  		{"0x7.7p-149", math.Float32frombits(0x000000007), Below},
   884  		{"0x7.8p-149", math.Float32frombits(0x000000008), Above},
   885  		{"0x7.9p-149", math.Float32frombits(0x000000008), Above},
   886  
   887  		// normals
   888  		{"0x.ffffffp-126", math.Float32frombits(0x00800000), Above}, // rounded up to smallest normal
   889  		{"1p-126", math.Float32frombits(0x00800000), Exact},         // smallest normal
   890  		{"0x1.fffffep-126", math.Float32frombits(0x00ffffff), Exact},
   891  		{"0x1.ffffffp-126", math.Float32frombits(0x01000000), Above}, // rounded up
   892  		{"1", 1, Exact},
   893  		{"1.000000000000000000001", 1, Below},
   894  		{"12345.0", 12345, Exact},
   895  		{"12345.000000000000000000001", 12345, Below},
   896  		{"0x1.fffffe0p127", math.MaxFloat32, Exact},
   897  		{"0x1.fffffe8p127", math.MaxFloat32, Below},
   898  
   899  		// overflow
   900  		{"0x1.ffffff0p127", float32(math.Inf(+1)), Above},
   901  		{"0x1p128", float32(math.Inf(+1)), Above},
   902  		{"1e10000", float32(math.Inf(+1)), Above},
   903  		{"0x1.ffffff0p2147483646", float32(math.Inf(+1)), Above}, // overflow in rounding
   904  
   905  		// inf
   906  		{"Inf", float32(math.Inf(+1)), Exact},
   907  	} {
   908  		for i := 0; i < 2; i++ {
   909  			// test both signs
   910  			tx, tout, tacc := test.x, test.out, test.acc
   911  			if i != 0 {
   912  				tx = "-" + tx
   913  				tout = -tout
   914  				tacc = -tacc
   915  			}
   916  
   917  			// conversion should match strconv where syntax is agreeable
   918  			if f, err := strconv.ParseFloat(tx, 32); err == nil && !alike32(float32(f), tout) {
   919  				t.Errorf("%s: got %g; want %g (incorrect test data)", tx, f, tout)
   920  			}
   921  
   922  			x := makeFloat(tx)
   923  			out, acc := x.Float32()
   924  			if !alike32(out, tout) || acc != tacc {
   925  				t.Errorf("%s: got %g (%#08x, %s); want %g (%#08x, %s)", tx, out, math.Float32bits(out), acc, test.out, math.Float32bits(test.out), tacc)
   926  			}
   927  
   928  			// test that x.SetFloat64(float64(f)).Float32() == f
   929  			var x2 Float
   930  			out2, acc2 := x2.SetFloat64(float64(out)).Float32()
   931  			if !alike32(out2, out) || acc2 != Exact {
   932  				t.Errorf("idempotency test: got %g (%s); want %g (Exact)", out2, acc2, out)
   933  			}
   934  		}
   935  	}
   936  }
   937  
   938  func TestFloatFloat64(t *testing.T) {
   939  	const smallestNormalFloat64 = 2.2250738585072014e-308 // 1p-1022
   940  	for _, test := range []struct {
   941  		x   string
   942  		out float64
   943  		acc Accuracy
   944  	}{
   945  		{"0", 0, Exact},
   946  
   947  		// underflow to zero
   948  		{"1e-1000", 0, Below},
   949  		{"0x0.0000000000001p-1023", 0, Below},
   950  		{"0x0.00000000000008p-1022", 0, Below},
   951  
   952  		// denormals
   953  		{"0x0.0000000000000cp-1022", math.SmallestNonzeroFloat64, Above}, // rounded up to smallest denormal
   954  		{"0x0.00000000000010p-1022", math.SmallestNonzeroFloat64, Exact}, // smallest denormal
   955  		{"0x.8p-1073", math.SmallestNonzeroFloat64, Exact},
   956  		{"1p-1074", math.SmallestNonzeroFloat64, Exact},
   957  		{"0x.fffffffffffffp-1022", math.Float64frombits(0x000fffffffffffff), Exact}, // largest denormal
   958  
   959  		// special denormal cases (see issues 14553, 14651)
   960  		{"0x0.00000000000001p-1022", math.Float64frombits(0x00000000000000000), Below}, // underflow to zero
   961  		{"0x0.00000000000004p-1022", math.Float64frombits(0x00000000000000000), Below}, // underflow to zero
   962  		{"0x0.00000000000008p-1022", math.Float64frombits(0x00000000000000000), Below}, // rounded down to even
   963  		{"0x0.00000000000009p-1022", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
   964  		{"0x0.0000000000000ap-1022", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
   965  
   966  		{"0x0.8p-1074", math.Float64frombits(0x00000000000000000), Below}, // rounded down to even
   967  		{"0x0.9p-1074", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
   968  		{"0x0.ap-1074", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
   969  		{"0x0.bp-1074", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
   970  		{"0x0.cp-1074", math.Float64frombits(0x00000000000000001), Above}, // rounded up to smallest denormal
   971  
   972  		{"0x1.0p-1074", math.Float64frombits(0x00000000000000001), Exact},
   973  		{"0x1.7p-1074", math.Float64frombits(0x00000000000000001), Below},
   974  		{"0x1.8p-1074", math.Float64frombits(0x00000000000000002), Above},
   975  		{"0x1.9p-1074", math.Float64frombits(0x00000000000000002), Above},
   976  
   977  		{"0x2.0p-1074", math.Float64frombits(0x00000000000000002), Exact},
   978  		{"0x2.8p-1074", math.Float64frombits(0x00000000000000002), Below}, // rounded down to even
   979  		{"0x2.9p-1074", math.Float64frombits(0x00000000000000003), Above},
   980  
   981  		{"0x3.0p-1074", math.Float64frombits(0x00000000000000003), Exact},
   982  		{"0x3.7p-1074", math.Float64frombits(0x00000000000000003), Below},
   983  		{"0x3.8p-1074", math.Float64frombits(0x00000000000000004), Above}, // rounded up to even
   984  
   985  		{"0x4.0p-1074", math.Float64frombits(0x00000000000000004), Exact},
   986  		{"0x4.8p-1074", math.Float64frombits(0x00000000000000004), Below}, // rounded down to even
   987  		{"0x4.9p-1074", math.Float64frombits(0x00000000000000005), Above},
   988  
   989  		// normals
   990  		{"0x.fffffffffffff8p-1022", math.Float64frombits(0x0010000000000000), Above}, // rounded up to smallest normal
   991  		{"1p-1022", math.Float64frombits(0x0010000000000000), Exact},                 // smallest normal
   992  		{"1", 1, Exact},
   993  		{"1.000000000000000000001", 1, Below},
   994  		{"12345.0", 12345, Exact},
   995  		{"12345.000000000000000000001", 12345, Below},
   996  		{"0x1.fffffffffffff0p1023", math.MaxFloat64, Exact},
   997  		{"0x1.fffffffffffff4p1023", math.MaxFloat64, Below},
   998  
   999  		// overflow
  1000  		{"0x1.fffffffffffff8p1023", math.Inf(+1), Above},
  1001  		{"0x1p1024", math.Inf(+1), Above},
  1002  		{"1e10000", math.Inf(+1), Above},
  1003  		{"0x1.fffffffffffff8p2147483646", math.Inf(+1), Above}, // overflow in rounding
  1004  		{"Inf", math.Inf(+1), Exact},
  1005  
  1006  		// selected denormalized values that were handled incorrectly in the past
  1007  		{"0x.fffffffffffffp-1022", smallestNormalFloat64 - math.SmallestNonzeroFloat64, Exact},
  1008  		{"4503599627370495p-1074", smallestNormalFloat64 - math.SmallestNonzeroFloat64, Exact},
  1009  
  1010  		// https://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
  1011  		{"2.2250738585072011e-308", 2.225073858507201e-308, Below},
  1012  		// https://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
  1013  		{"2.2250738585072012e-308", 2.2250738585072014e-308, Above},
  1014  	} {
  1015  		for i := 0; i < 2; i++ {
  1016  			// test both signs
  1017  			tx, tout, tacc := test.x, test.out, test.acc
  1018  			if i != 0 {
  1019  				tx = "-" + tx
  1020  				tout = -tout
  1021  				tacc = -tacc
  1022  			}
  1023  
  1024  			// conversion should match strconv where syntax is agreeable
  1025  			if f, err := strconv.ParseFloat(tx, 64); err == nil && !alike64(f, tout) {
  1026  				t.Errorf("%s: got %g; want %g (incorrect test data)", tx, f, tout)
  1027  			}
  1028  
  1029  			x := makeFloat(tx)
  1030  			out, acc := x.Float64()
  1031  			if !alike64(out, tout) || acc != tacc {
  1032  				t.Errorf("%s: got %g (%#016x, %s); want %g (%#016x, %s)", tx, out, math.Float64bits(out), acc, test.out, math.Float64bits(test.out), tacc)
  1033  			}
  1034  
  1035  			// test that x.SetFloat64(f).Float64() == f
  1036  			var x2 Float
  1037  			out2, acc2 := x2.SetFloat64(out).Float64()
  1038  			if !alike64(out2, out) || acc2 != Exact {
  1039  				t.Errorf("idempotency test: got %g (%s); want %g (Exact)", out2, acc2, out)
  1040  			}
  1041  		}
  1042  	}
  1043  }
  1044  
  1045  func TestFloatInt(t *testing.T) {
  1046  	for _, test := range []struct {
  1047  		x    string
  1048  		want string
  1049  		acc  Accuracy
  1050  	}{
  1051  		{"0", "0", Exact},
  1052  		{"+0", "0", Exact},
  1053  		{"-0", "0", Exact},
  1054  		{"Inf", "nil", Below},
  1055  		{"+Inf", "nil", Below},
  1056  		{"-Inf", "nil", Above},
  1057  		{"1", "1", Exact},
  1058  		{"-1", "-1", Exact},
  1059  		{"1.23", "1", Below},
  1060  		{"-1.23", "-1", Above},
  1061  		{"123e-2", "1", Below},
  1062  		{"123e-3", "0", Below},
  1063  		{"123e-4", "0", Below},
  1064  		{"1e-1000", "0", Below},
  1065  		{"-1e-1000", "0", Above},
  1066  		{"1e+10", "10000000000", Exact},
  1067  		{"1e+100", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Exact},
  1068  	} {
  1069  		x := makeFloat(test.x)
  1070  		res, acc := x.Int(nil)
  1071  		got := "nil"
  1072  		if res != nil {
  1073  			got = res.String()
  1074  		}
  1075  		if got != test.want || acc != test.acc {
  1076  			t.Errorf("%s: got %s (%s); want %s (%s)", test.x, got, acc, test.want, test.acc)
  1077  		}
  1078  	}
  1079  
  1080  	// check that supplied *Int is used
  1081  	for _, f := range []string{"0", "1", "-1", "1234"} {
  1082  		x := makeFloat(f)
  1083  		i := new(Int)
  1084  		if res, _ := x.Int(i); res != i {
  1085  			t.Errorf("(%s).Int is not using supplied *Int", f)
  1086  		}
  1087  	}
  1088  }
  1089  
  1090  func TestFloatRat(t *testing.T) {
  1091  	for _, test := range []struct {
  1092  		x, want string
  1093  		acc     Accuracy
  1094  	}{
  1095  		{"0", "0/1", Exact},
  1096  		{"+0", "0/1", Exact},
  1097  		{"-0", "0/1", Exact},
  1098  		{"Inf", "nil", Below},
  1099  		{"+Inf", "nil", Below},
  1100  		{"-Inf", "nil", Above},
  1101  		{"1", "1/1", Exact},
  1102  		{"-1", "-1/1", Exact},
  1103  		{"1.25", "5/4", Exact},
  1104  		{"-1.25", "-5/4", Exact},
  1105  		{"1e10", "10000000000/1", Exact},
  1106  		{"1p10", "1024/1", Exact},
  1107  		{"-1p-10", "-1/1024", Exact},
  1108  		{"3.14159265", "7244019449799623199/2305843009213693952", Exact},
  1109  	} {
  1110  		x := makeFloat(test.x).SetPrec(64)
  1111  		res, acc := x.Rat(nil)
  1112  		got := "nil"
  1113  		if res != nil {
  1114  			got = res.String()
  1115  		}
  1116  		if got != test.want {
  1117  			t.Errorf("%s: got %s; want %s", test.x, got, test.want)
  1118  			continue
  1119  		}
  1120  		if acc != test.acc {
  1121  			t.Errorf("%s: got %s; want %s", test.x, acc, test.acc)
  1122  			continue
  1123  		}
  1124  
  1125  		// inverse conversion
  1126  		if res != nil {
  1127  			got := new(Float).SetPrec(64).SetRat(res)
  1128  			if got.Cmp(x) != 0 {
  1129  				t.Errorf("%s: got %s; want %s", test.x, got, x)
  1130  			}
  1131  		}
  1132  	}
  1133  
  1134  	// check that supplied *Rat is used
  1135  	for _, f := range []string{"0", "1", "-1", "1234"} {
  1136  		x := makeFloat(f)
  1137  		r := new(Rat)
  1138  		if res, _ := x.Rat(r); res != r {
  1139  			t.Errorf("(%s).Rat is not using supplied *Rat", f)
  1140  		}
  1141  	}
  1142  }
  1143  
  1144  func TestFloatAbs(t *testing.T) {
  1145  	for _, test := range []string{
  1146  		"0",
  1147  		"1",
  1148  		"1234",
  1149  		"1.23e-2",
  1150  		"1e-1000",
  1151  		"1e1000",
  1152  		"Inf",
  1153  	} {
  1154  		p := makeFloat(test)
  1155  		a := new(Float).Abs(p)
  1156  		if !alike(a, p) {
  1157  			t.Errorf("%s: got %s; want %s", test, a.Text('g', 10), test)
  1158  		}
  1159  
  1160  		n := makeFloat("-" + test)
  1161  		a.Abs(n)
  1162  		if !alike(a, p) {
  1163  			t.Errorf("-%s: got %s; want %s", test, a.Text('g', 10), test)
  1164  		}
  1165  	}
  1166  }
  1167  
  1168  func TestFloatNeg(t *testing.T) {
  1169  	for _, test := range []string{
  1170  		"0",
  1171  		"1",
  1172  		"1234",
  1173  		"1.23e-2",
  1174  		"1e-1000",
  1175  		"1e1000",
  1176  		"Inf",
  1177  	} {
  1178  		p1 := makeFloat(test)
  1179  		n1 := makeFloat("-" + test)
  1180  		n2 := new(Float).Neg(p1)
  1181  		p2 := new(Float).Neg(n2)
  1182  		if !alike(n2, n1) {
  1183  			t.Errorf("%s: got %s; want %s", test, n2.Text('g', 10), n1.Text('g', 10))
  1184  		}
  1185  		if !alike(p2, p1) {
  1186  			t.Errorf("%s: got %s; want %s", test, p2.Text('g', 10), p1.Text('g', 10))
  1187  		}
  1188  	}
  1189  }
  1190  
  1191  func TestFloatInc(t *testing.T) {
  1192  	const n = 10
  1193  	for _, prec := range precList {
  1194  		if 1<<prec < n {
  1195  			continue // prec must be large enough to hold all numbers from 0 to n
  1196  		}
  1197  		var x, one Float
  1198  		x.SetPrec(prec)
  1199  		one.SetInt64(1)
  1200  		for i := 0; i < n; i++ {
  1201  			x.Add(&x, &one)
  1202  		}
  1203  		if x.Cmp(new(Float).SetInt64(n)) != 0 {
  1204  			t.Errorf("prec = %d: got %s; want %d", prec, &x, n)
  1205  		}
  1206  	}
  1207  }
  1208  
  1209  // Selected precisions with which to run various tests.
  1210  var precList = [...]uint{1, 2, 5, 8, 10, 16, 23, 24, 32, 50, 53, 64, 100, 128, 500, 511, 512, 513, 1000, 10000}
  1211  
  1212  // Selected bits with which to run various tests.
  1213  // Each entry is a list of bits representing a floating-point number (see fromBits).
  1214  var bitsList = [...]Bits{
  1215  	{},           // = 0
  1216  	{0},          // = 1
  1217  	{1},          // = 2
  1218  	{-1},         // = 1/2
  1219  	{10},         // = 2**10 == 1024
  1220  	{-10},        // = 2**-10 == 1/1024
  1221  	{100, 10, 1}, // = 2**100 + 2**10 + 2**1
  1222  	{0, -1, -2, -10},
  1223  	// TODO(gri) add more test cases
  1224  }
  1225  
  1226  // TestFloatAdd tests Float.Add/Sub by comparing the result of a "manual"
  1227  // addition/subtraction of arguments represented by Bits values with the
  1228  // respective Float addition/subtraction for a variety of precisions
  1229  // and rounding modes.
  1230  func TestFloatAdd(t *testing.T) {
  1231  	for _, xbits := range bitsList {
  1232  		for _, ybits := range bitsList {
  1233  			// exact values
  1234  			x := xbits.Float()
  1235  			y := ybits.Float()
  1236  			zbits := xbits.add(ybits)
  1237  			z := zbits.Float()
  1238  
  1239  			for i, mode := range [...]RoundingMode{ToZero, ToNearestEven, AwayFromZero} {
  1240  				for _, prec := range precList {
  1241  					got := new(Float).SetPrec(prec).SetMode(mode)
  1242  					got.Add(x, y)
  1243  					want := zbits.round(prec, mode)
  1244  					if got.Cmp(want) != 0 {
  1245  						t.Errorf("i = %d, prec = %d, %s:\n\t     %s %v\n\t+    %s %v\n\t=    %s\n\twant %s",
  1246  							i, prec, mode, x, xbits, y, ybits, got, want)
  1247  					}
  1248  
  1249  					got.Sub(z, x)
  1250  					want = ybits.round(prec, mode)
  1251  					if got.Cmp(want) != 0 {
  1252  						t.Errorf("i = %d, prec = %d, %s:\n\t     %s %v\n\t-    %s %v\n\t=    %s\n\twant %s",
  1253  							i, prec, mode, z, zbits, x, xbits, got, want)
  1254  					}
  1255  				}
  1256  			}
  1257  		}
  1258  	}
  1259  }
  1260  
  1261  // TestFloatAddRoundZero tests Float.Add/Sub rounding when the result is exactly zero.
  1262  // x + (-x) or x - x for non-zero x should be +0 in all cases except when
  1263  // the rounding mode is ToNegativeInf in which case it should be -0.
  1264  func TestFloatAddRoundZero(t *testing.T) {
  1265  	for _, mode := range [...]RoundingMode{ToNearestEven, ToNearestAway, ToZero, AwayFromZero, ToPositiveInf, ToNegativeInf} {
  1266  		x := NewFloat(5.0)
  1267  		y := new(Float).Neg(x)
  1268  		want := NewFloat(0.0)
  1269  		if mode == ToNegativeInf {
  1270  			want.Neg(want)
  1271  		}
  1272  		got := new(Float).SetMode(mode)
  1273  		got.Add(x, y)
  1274  		if got.Cmp(want) != 0 || got.neg != (mode == ToNegativeInf) {
  1275  			t.Errorf("%s:\n\t     %v\n\t+    %v\n\t=    %v\n\twant %v",
  1276  				mode, x, y, got, want)
  1277  		}
  1278  		got.Sub(x, x)
  1279  		if got.Cmp(want) != 0 || got.neg != (mode == ToNegativeInf) {
  1280  			t.Errorf("%v:\n\t     %v\n\t-    %v\n\t=    %v\n\twant %v",
  1281  				mode, x, x, got, want)
  1282  		}
  1283  	}
  1284  }
  1285  
  1286  // TestFloatAdd32 tests that Float.Add/Sub of numbers with
  1287  // 24bit mantissa behaves like float32 addition/subtraction
  1288  // (excluding denormal numbers).
  1289  func TestFloatAdd32(t *testing.T) {
  1290  	// chose base such that we cross the mantissa precision limit
  1291  	const base = 1<<26 - 0x10 // 11...110000 (26 bits)
  1292  	for d := 0; d <= 0x10; d++ {
  1293  		for i := range [2]int{} {
  1294  			x0, y0 := float64(base), float64(d)
  1295  			if i&1 != 0 {
  1296  				x0, y0 = y0, x0
  1297  			}
  1298  
  1299  			x := NewFloat(x0)
  1300  			y := NewFloat(y0)
  1301  			z := new(Float).SetPrec(24)
  1302  
  1303  			z.Add(x, y)
  1304  			got, acc := z.Float32()
  1305  			want := float32(y0) + float32(x0)
  1306  			if got != want || acc != Exact {
  1307  				t.Errorf("d = %d: %g + %g = %g (%s); want %g (Exact)", d, x0, y0, got, acc, want)
  1308  			}
  1309  
  1310  			z.Sub(z, y)
  1311  			got, acc = z.Float32()
  1312  			want = float32(want) - float32(y0)
  1313  			if got != want || acc != Exact {
  1314  				t.Errorf("d = %d: %g - %g = %g (%s); want %g (Exact)", d, x0+y0, y0, got, acc, want)
  1315  			}
  1316  		}
  1317  	}
  1318  }
  1319  
  1320  // TestFloatAdd64 tests that Float.Add/Sub of numbers with
  1321  // 53bit mantissa behaves like float64 addition/subtraction.
  1322  func TestFloatAdd64(t *testing.T) {
  1323  	// chose base such that we cross the mantissa precision limit
  1324  	const base = 1<<55 - 0x10 // 11...110000 (55 bits)
  1325  	for d := 0; d <= 0x10; d++ {
  1326  		for i := range [2]int{} {
  1327  			x0, y0 := float64(base), float64(d)
  1328  			if i&1 != 0 {
  1329  				x0, y0 = y0, x0
  1330  			}
  1331  
  1332  			x := NewFloat(x0)
  1333  			y := NewFloat(y0)
  1334  			z := new(Float).SetPrec(53)
  1335  
  1336  			z.Add(x, y)
  1337  			got, acc := z.Float64()
  1338  			want := x0 + y0
  1339  			if got != want || acc != Exact {
  1340  				t.Errorf("d = %d: %g + %g = %g (%s); want %g (Exact)", d, x0, y0, got, acc, want)
  1341  			}
  1342  
  1343  			z.Sub(z, y)
  1344  			got, acc = z.Float64()
  1345  			want -= y0
  1346  			if got != want || acc != Exact {
  1347  				t.Errorf("d = %d: %g - %g = %g (%s); want %g (Exact)", d, x0+y0, y0, got, acc, want)
  1348  			}
  1349  		}
  1350  	}
  1351  }
  1352  
  1353  func TestIssue20490(t *testing.T) {
  1354  	var tests = []struct {
  1355  		a, b float64
  1356  	}{
  1357  		{4, 1},
  1358  		{-4, 1},
  1359  		{4, -1},
  1360  		{-4, -1},
  1361  	}
  1362  
  1363  	for _, test := range tests {
  1364  		a, b := NewFloat(test.a), NewFloat(test.b)
  1365  		diff := new(Float).Sub(a, b)
  1366  		b.Sub(a, b)
  1367  		if b.Cmp(diff) != 0 {
  1368  			t.Errorf("got %g - %g = %g; want %g\n", a, NewFloat(test.b), b, diff)
  1369  		}
  1370  
  1371  		b = NewFloat(test.b)
  1372  		sum := new(Float).Add(a, b)
  1373  		b.Add(a, b)
  1374  		if b.Cmp(sum) != 0 {
  1375  			t.Errorf("got %g + %g = %g; want %g\n", a, NewFloat(test.b), b, sum)
  1376  		}
  1377  
  1378  	}
  1379  }
  1380  
  1381  // TestFloatMul tests Float.Mul/Quo by comparing the result of a "manual"
  1382  // multiplication/division of arguments represented by Bits values with the
  1383  // respective Float multiplication/division for a variety of precisions
  1384  // and rounding modes.
  1385  func TestFloatMul(t *testing.T) {
  1386  	for _, xbits := range bitsList {
  1387  		for _, ybits := range bitsList {
  1388  			// exact values
  1389  			x := xbits.Float()
  1390  			y := ybits.Float()
  1391  			zbits := xbits.mul(ybits)
  1392  			z := zbits.Float()
  1393  
  1394  			for i, mode := range [...]RoundingMode{ToZero, ToNearestEven, AwayFromZero} {
  1395  				for _, prec := range precList {
  1396  					got := new(Float).SetPrec(prec).SetMode(mode)
  1397  					got.Mul(x, y)
  1398  					want := zbits.round(prec, mode)
  1399  					if got.Cmp(want) != 0 {
  1400  						t.Errorf("i = %d, prec = %d, %s:\n\t     %v %v\n\t*    %v %v\n\t=    %v\n\twant %v",
  1401  							i, prec, mode, x, xbits, y, ybits, got, want)
  1402  					}
  1403  
  1404  					if x.Sign() == 0 {
  1405  						continue // ignore div-0 case (not invertable)
  1406  					}
  1407  					got.Quo(z, x)
  1408  					want = ybits.round(prec, mode)
  1409  					if got.Cmp(want) != 0 {
  1410  						t.Errorf("i = %d, prec = %d, %s:\n\t     %v %v\n\t/    %v %v\n\t=    %v\n\twant %v",
  1411  							i, prec, mode, z, zbits, x, xbits, got, want)
  1412  					}
  1413  				}
  1414  			}
  1415  		}
  1416  	}
  1417  }
  1418  
  1419  // TestFloatMul64 tests that Float.Mul/Quo of numbers with
  1420  // 53bit mantissa behaves like float64 multiplication/division.
  1421  func TestFloatMul64(t *testing.T) {
  1422  	for _, test := range []struct {
  1423  		x, y float64
  1424  	}{
  1425  		{0, 0},
  1426  		{0, 1},
  1427  		{1, 1},
  1428  		{1, 1.5},
  1429  		{1.234, 0.5678},
  1430  		{2.718281828, 3.14159265358979},
  1431  		{2.718281828e10, 3.14159265358979e-32},
  1432  		{1.0 / 3, 1e200},
  1433  	} {
  1434  		for i := range [8]int{} {
  1435  			x0, y0 := test.x, test.y
  1436  			if i&1 != 0 {
  1437  				x0 = -x0
  1438  			}
  1439  			if i&2 != 0 {
  1440  				y0 = -y0
  1441  			}
  1442  			if i&4 != 0 {
  1443  				x0, y0 = y0, x0
  1444  			}
  1445  
  1446  			x := NewFloat(x0)
  1447  			y := NewFloat(y0)
  1448  			z := new(Float).SetPrec(53)
  1449  
  1450  			z.Mul(x, y)
  1451  			got, _ := z.Float64()
  1452  			want := x0 * y0
  1453  			if got != want {
  1454  				t.Errorf("%g * %g = %g; want %g", x0, y0, got, want)
  1455  			}
  1456  
  1457  			if y0 == 0 {
  1458  				continue // avoid division-by-zero
  1459  			}
  1460  			z.Quo(z, y)
  1461  			got, _ = z.Float64()
  1462  			want /= y0
  1463  			if got != want {
  1464  				t.Errorf("%g / %g = %g; want %g", x0*y0, y0, got, want)
  1465  			}
  1466  		}
  1467  	}
  1468  }
  1469  
  1470  func TestIssue6866(t *testing.T) {
  1471  	for _, prec := range precList {
  1472  		two := new(Float).SetPrec(prec).SetInt64(2)
  1473  		one := new(Float).SetPrec(prec).SetInt64(1)
  1474  		three := new(Float).SetPrec(prec).SetInt64(3)
  1475  		msix := new(Float).SetPrec(prec).SetInt64(-6)
  1476  		psix := new(Float).SetPrec(prec).SetInt64(+6)
  1477  
  1478  		p := new(Float).SetPrec(prec)
  1479  		z1 := new(Float).SetPrec(prec)
  1480  		z2 := new(Float).SetPrec(prec)
  1481  
  1482  		// z1 = 2 + 1.0/3*-6
  1483  		p.Quo(one, three)
  1484  		p.Mul(p, msix)
  1485  		z1.Add(two, p)
  1486  
  1487  		// z2 = 2 - 1.0/3*+6
  1488  		p.Quo(one, three)
  1489  		p.Mul(p, psix)
  1490  		z2.Sub(two, p)
  1491  
  1492  		if z1.Cmp(z2) != 0 {
  1493  			t.Fatalf("prec %d: got z1 = %v != z2 = %v; want z1 == z2\n", prec, z1, z2)
  1494  		}
  1495  		if z1.Sign() != 0 {
  1496  			t.Errorf("prec %d: got z1 = %v; want 0", prec, z1)
  1497  		}
  1498  		if z2.Sign() != 0 {
  1499  			t.Errorf("prec %d: got z2 = %v; want 0", prec, z2)
  1500  		}
  1501  	}
  1502  }
  1503  
  1504  func TestFloatQuo(t *testing.T) {
  1505  	// TODO(gri) make the test vary these precisions
  1506  	preci := 200 // precision of integer part
  1507  	precf := 20  // precision of fractional part
  1508  
  1509  	for i := 0; i < 8; i++ {
  1510  		// compute accurate (not rounded) result z
  1511  		bits := Bits{preci - 1}
  1512  		if i&3 != 0 {
  1513  			bits = append(bits, 0)
  1514  		}
  1515  		if i&2 != 0 {
  1516  			bits = append(bits, -1)
  1517  		}
  1518  		if i&1 != 0 {
  1519  			bits = append(bits, -precf)
  1520  		}
  1521  		z := bits.Float()
  1522  
  1523  		// compute accurate x as z*y
  1524  		y := NewFloat(3.14159265358979323e123)
  1525  
  1526  		x := new(Float).SetPrec(z.Prec() + y.Prec()).SetMode(ToZero)
  1527  		x.Mul(z, y)
  1528  
  1529  		// leave for debugging
  1530  		// fmt.Printf("x = %s\ny = %s\nz = %s\n", x, y, z)
  1531  
  1532  		if got := x.Acc(); got != Exact {
  1533  			t.Errorf("got acc = %s; want exact", got)
  1534  		}
  1535  
  1536  		// round accurate z for a variety of precisions and
  1537  		// modes and compare against result of x / y.
  1538  		for _, mode := range [...]RoundingMode{ToZero, ToNearestEven, AwayFromZero} {
  1539  			for d := -5; d < 5; d++ {
  1540  				prec := uint(preci + d)
  1541  				got := new(Float).SetPrec(prec).SetMode(mode).Quo(x, y)
  1542  				want := bits.round(prec, mode)
  1543  				if got.Cmp(want) != 0 {
  1544  					t.Errorf("i = %d, prec = %d, %s:\n\t     %s\n\t/    %s\n\t=    %s\n\twant %s",
  1545  						i, prec, mode, x, y, got, want)
  1546  				}
  1547  			}
  1548  		}
  1549  	}
  1550  }
  1551  
  1552  var long = flag.Bool("long", false, "run very long tests")
  1553  
  1554  // TestFloatQuoSmoke tests all divisions x/y for values x, y in the range [-n, +n];
  1555  // it serves as a smoke test for basic correctness of division.
  1556  func TestFloatQuoSmoke(t *testing.T) {
  1557  	n := 10
  1558  	if *long {
  1559  		n = 1000
  1560  	}
  1561  
  1562  	const dprec = 3         // max. precision variation
  1563  	const prec = 10 + dprec // enough bits to hold n precisely
  1564  	for x := -n; x <= n; x++ {
  1565  		for y := -n; y < n; y++ {
  1566  			if y == 0 {
  1567  				continue
  1568  			}
  1569  
  1570  			a := float64(x)
  1571  			b := float64(y)
  1572  			c := a / b
  1573  
  1574  			// vary operand precision (only ok as long as a, b can be represented correctly)
  1575  			for ad := -dprec; ad <= dprec; ad++ {
  1576  				for bd := -dprec; bd <= dprec; bd++ {
  1577  					A := new(Float).SetPrec(uint(prec + ad)).SetFloat64(a)
  1578  					B := new(Float).SetPrec(uint(prec + bd)).SetFloat64(b)
  1579  					C := new(Float).SetPrec(53).Quo(A, B) // C has float64 mantissa width
  1580  
  1581  					cc, acc := C.Float64()
  1582  					if cc != c {
  1583  						t.Errorf("%g/%g = %s; want %.5g\n", a, b, C.Text('g', 5), c)
  1584  						continue
  1585  					}
  1586  					if acc != Exact {
  1587  						t.Errorf("%g/%g got %s result; want exact result", a, b, acc)
  1588  					}
  1589  				}
  1590  			}
  1591  		}
  1592  	}
  1593  }
  1594  
  1595  // TestFloatArithmeticSpecialValues tests that Float operations produce the
  1596  // correct results for combinations of zero (±0), finite (±1 and ±2.71828),
  1597  // and infinite (±Inf) operands.
  1598  func TestFloatArithmeticSpecialValues(t *testing.T) {
  1599  	zero := 0.0
  1600  	args := []float64{math.Inf(-1), -2.71828, -1, -zero, zero, 1, 2.71828, math.Inf(1)}
  1601  	xx := new(Float)
  1602  	yy := new(Float)
  1603  	got := new(Float)
  1604  	want := new(Float)
  1605  	for i := 0; i < 4; i++ {
  1606  		for _, x := range args {
  1607  			xx.SetFloat64(x)
  1608  			// check conversion is correct
  1609  			// (no need to do this for y, since we see exactly the
  1610  			// same values there)
  1611  			if got, acc := xx.Float64(); got != x || acc != Exact {
  1612  				t.Errorf("Float(%g) == %g (%s)", x, got, acc)
  1613  			}
  1614  			for _, y := range args {
  1615  				yy.SetFloat64(y)
  1616  				var (
  1617  					op string
  1618  					z  float64
  1619  					f  func(z, x, y *Float) *Float
  1620  				)
  1621  				switch i {
  1622  				case 0:
  1623  					op = "+"
  1624  					z = x + y
  1625  					f = (*Float).Add
  1626  				case 1:
  1627  					op = "-"
  1628  					z = x - y
  1629  					f = (*Float).Sub
  1630  				case 2:
  1631  					op = "*"
  1632  					z = x * y
  1633  					f = (*Float).Mul
  1634  				case 3:
  1635  					op = "/"
  1636  					z = x / y
  1637  					f = (*Float).Quo
  1638  				default:
  1639  					panic("unreachable")
  1640  				}
  1641  				var errnan bool // set if execution of f panicked with ErrNaN
  1642  				// protect execution of f
  1643  				func() {
  1644  					defer func() {
  1645  						if p := recover(); p != nil {
  1646  							_ = p.(ErrNaN) // re-panic if not ErrNaN
  1647  							errnan = true
  1648  						}
  1649  					}()
  1650  					f(got, xx, yy)
  1651  				}()
  1652  				if math.IsNaN(z) {
  1653  					if !errnan {
  1654  						t.Errorf("%5g %s %5g = %5s; want ErrNaN panic", x, op, y, got)
  1655  					}
  1656  					continue
  1657  				}
  1658  				if errnan {
  1659  					t.Errorf("%5g %s %5g panicked with ErrNan; want %5s", x, op, y, want)
  1660  					continue
  1661  				}
  1662  				want.SetFloat64(z)
  1663  				if !alike(got, want) {
  1664  					t.Errorf("%5g %s %5g = %5s; want %5s", x, op, y, got, want)
  1665  				}
  1666  			}
  1667  		}
  1668  	}
  1669  }
  1670  
  1671  func TestFloatArithmeticOverflow(t *testing.T) {
  1672  	for _, test := range []struct {
  1673  		prec       uint
  1674  		mode       RoundingMode
  1675  		op         byte
  1676  		x, y, want string
  1677  		acc        Accuracy
  1678  	}{
  1679  		{4, ToNearestEven, '+', "0", "0", "0", Exact},                   // smoke test
  1680  		{4, ToNearestEven, '+', "0x.8p+0", "0x.8p+0", "0x.8p+1", Exact}, // smoke test
  1681  
  1682  		{4, ToNearestEven, '+', "0", "0x.8p2147483647", "0x.8p+2147483647", Exact},
  1683  		{4, ToNearestEven, '+', "0x.8p2147483500", "0x.8p2147483647", "0x.8p+2147483647", Below}, // rounded to zero
  1684  		{4, ToNearestEven, '+', "0x.8p2147483647", "0x.8p2147483647", "+Inf", Above},             // exponent overflow in +
  1685  		{4, ToNearestEven, '+', "-0x.8p2147483647", "-0x.8p2147483647", "-Inf", Below},           // exponent overflow in +
  1686  		{4, ToNearestEven, '-', "-0x.8p2147483647", "0x.8p2147483647", "-Inf", Below},            // exponent overflow in -
  1687  
  1688  		{4, ToZero, '+', "0x.fp2147483647", "0x.8p2147483643", "0x.fp+2147483647", Below}, // rounded to zero
  1689  		{4, ToNearestEven, '+', "0x.fp2147483647", "0x.8p2147483643", "+Inf", Above},      // exponent overflow in rounding
  1690  		{4, AwayFromZero, '+', "0x.fp2147483647", "0x.8p2147483643", "+Inf", Above},       // exponent overflow in rounding
  1691  
  1692  		{4, AwayFromZero, '-', "-0x.fp2147483647", "0x.8p2147483644", "-Inf", Below},        // exponent overflow in rounding
  1693  		{4, ToNearestEven, '-', "-0x.fp2147483647", "0x.8p2147483643", "-Inf", Below},       // exponent overflow in rounding
  1694  		{4, ToZero, '-', "-0x.fp2147483647", "0x.8p2147483643", "-0x.fp+2147483647", Above}, // rounded to zero
  1695  
  1696  		{4, ToNearestEven, '+', "0", "0x.8p-2147483648", "0x.8p-2147483648", Exact},
  1697  		{4, ToNearestEven, '+', "0x.8p-2147483648", "0x.8p-2147483648", "0x.8p-2147483647", Exact},
  1698  
  1699  		{4, ToNearestEven, '*', "1", "0x.8p2147483647", "0x.8p+2147483647", Exact},
  1700  		{4, ToNearestEven, '*', "2", "0x.8p2147483647", "+Inf", Above},  // exponent overflow in *
  1701  		{4, ToNearestEven, '*', "-2", "0x.8p2147483647", "-Inf", Below}, // exponent overflow in *
  1702  
  1703  		{4, ToNearestEven, '/', "0.5", "0x.8p2147483647", "0x.8p-2147483646", Exact},
  1704  		{4, ToNearestEven, '/', "0x.8p+0", "0x.8p2147483647", "0x.8p-2147483646", Exact},
  1705  		{4, ToNearestEven, '/', "0x.8p-1", "0x.8p2147483647", "0x.8p-2147483647", Exact},
  1706  		{4, ToNearestEven, '/', "0x.8p-2", "0x.8p2147483647", "0x.8p-2147483648", Exact},
  1707  		{4, ToNearestEven, '/', "0x.8p-3", "0x.8p2147483647", "0", Below}, // exponent underflow in /
  1708  	} {
  1709  		x := makeFloat(test.x)
  1710  		y := makeFloat(test.y)
  1711  		z := new(Float).SetPrec(test.prec).SetMode(test.mode)
  1712  		switch test.op {
  1713  		case '+':
  1714  			z.Add(x, y)
  1715  		case '-':
  1716  			z.Sub(x, y)
  1717  		case '*':
  1718  			z.Mul(x, y)
  1719  		case '/':
  1720  			z.Quo(x, y)
  1721  		default:
  1722  			panic("unreachable")
  1723  		}
  1724  		if got := z.Text('p', 0); got != test.want || z.Acc() != test.acc {
  1725  			t.Errorf(
  1726  				"prec = %d (%s): %s %c %s = %s (%s); want %s (%s)",
  1727  				test.prec, test.mode, x.Text('p', 0), test.op, y.Text('p', 0), got, z.Acc(), test.want, test.acc,
  1728  			)
  1729  		}
  1730  	}
  1731  }
  1732  
  1733  // TODO(gri) Add tests that check correctness in the presence of aliasing.
  1734  
  1735  // For rounding modes ToNegativeInf and ToPositiveInf, rounding is affected
  1736  // by the sign of the value to be rounded. Test that rounding happens after
  1737  // the sign of a result has been set.
  1738  // This test uses specific values that are known to fail if rounding is
  1739  // "factored" out before setting the result sign.
  1740  func TestFloatArithmeticRounding(t *testing.T) {
  1741  	for _, test := range []struct {
  1742  		mode       RoundingMode
  1743  		prec       uint
  1744  		x, y, want int64
  1745  		op         byte
  1746  	}{
  1747  		{ToZero, 3, -0x8, -0x1, -0x8, '+'},
  1748  		{AwayFromZero, 3, -0x8, -0x1, -0xa, '+'},
  1749  		{ToNegativeInf, 3, -0x8, -0x1, -0xa, '+'},
  1750  
  1751  		{ToZero, 3, -0x8, 0x1, -0x8, '-'},
  1752  		{AwayFromZero, 3, -0x8, 0x1, -0xa, '-'},
  1753  		{ToNegativeInf, 3, -0x8, 0x1, -0xa, '-'},
  1754  
  1755  		{ToZero, 3, -0x9, 0x1, -0x8, '*'},
  1756  		{AwayFromZero, 3, -0x9, 0x1, -0xa, '*'},
  1757  		{ToNegativeInf, 3, -0x9, 0x1, -0xa, '*'},
  1758  
  1759  		{ToZero, 3, -0x9, 0x1, -0x8, '/'},
  1760  		{AwayFromZero, 3, -0x9, 0x1, -0xa, '/'},
  1761  		{ToNegativeInf, 3, -0x9, 0x1, -0xa, '/'},
  1762  	} {
  1763  		var x, y, z Float
  1764  		x.SetInt64(test.x)
  1765  		y.SetInt64(test.y)
  1766  		z.SetPrec(test.prec).SetMode(test.mode)
  1767  		switch test.op {
  1768  		case '+':
  1769  			z.Add(&x, &y)
  1770  		case '-':
  1771  			z.Sub(&x, &y)
  1772  		case '*':
  1773  			z.Mul(&x, &y)
  1774  		case '/':
  1775  			z.Quo(&x, &y)
  1776  		default:
  1777  			panic("unreachable")
  1778  		}
  1779  		if got, acc := z.Int64(); got != test.want || acc != Exact {
  1780  			t.Errorf("%s, %d bits: %d %c %d = %d (%s); want %d (Exact)",
  1781  				test.mode, test.prec, test.x, test.op, test.y, got, acc, test.want,
  1782  			)
  1783  		}
  1784  	}
  1785  }
  1786  
  1787  // TestFloatCmpSpecialValues tests that Cmp produces the correct results for
  1788  // combinations of zero (±0), finite (±1 and ±2.71828), and infinite (±Inf)
  1789  // operands.
  1790  func TestFloatCmpSpecialValues(t *testing.T) {
  1791  	zero := 0.0
  1792  	args := []float64{math.Inf(-1), -2.71828, -1, -zero, zero, 1, 2.71828, math.Inf(1)}
  1793  	xx := new(Float)
  1794  	yy := new(Float)
  1795  	for i := 0; i < 4; i++ {
  1796  		for _, x := range args {
  1797  			xx.SetFloat64(x)
  1798  			// check conversion is correct
  1799  			// (no need to do this for y, since we see exactly the
  1800  			// same values there)
  1801  			if got, acc := xx.Float64(); got != x || acc != Exact {
  1802  				t.Errorf("Float(%g) == %g (%s)", x, got, acc)
  1803  			}
  1804  			for _, y := range args {
  1805  				yy.SetFloat64(y)
  1806  				got := xx.Cmp(yy)
  1807  				want := 0
  1808  				switch {
  1809  				case x < y:
  1810  					want = -1
  1811  				case x > y:
  1812  					want = +1
  1813  				}
  1814  				if got != want {
  1815  					t.Errorf("(%g).Cmp(%g) = %v; want %v", x, y, got, want)
  1816  				}
  1817  			}
  1818  		}
  1819  	}
  1820  }
  1821  
  1822  func BenchmarkFloatAdd(b *testing.B) {
  1823  	x := new(Float)
  1824  	y := new(Float)
  1825  	z := new(Float)
  1826  
  1827  	for _, prec := range []uint{10, 1e2, 1e3, 1e4, 1e5} {
  1828  		x.SetPrec(prec).SetRat(NewRat(1, 3))
  1829  		y.SetPrec(prec).SetRat(NewRat(1, 6))
  1830  		z.SetPrec(prec)
  1831  
  1832  		b.Run(fmt.Sprintf("%v", prec), func(b *testing.B) {
  1833  			b.ReportAllocs()
  1834  			for i := 0; i < b.N; i++ {
  1835  				z.Add(x, y)
  1836  			}
  1837  		})
  1838  	}
  1839  }
  1840  
  1841  func BenchmarkFloatSub(b *testing.B) {
  1842  	x := new(Float)
  1843  	y := new(Float)
  1844  	z := new(Float)
  1845  
  1846  	for _, prec := range []uint{10, 1e2, 1e3, 1e4, 1e5} {
  1847  		x.SetPrec(prec).SetRat(NewRat(1, 3))
  1848  		y.SetPrec(prec).SetRat(NewRat(1, 6))
  1849  		z.SetPrec(prec)
  1850  
  1851  		b.Run(fmt.Sprintf("%v", prec), func(b *testing.B) {
  1852  			b.ReportAllocs()
  1853  			for i := 0; i < b.N; i++ {
  1854  				z.Sub(x, y)
  1855  			}
  1856  		})
  1857  	}
  1858  }
  1859  

View as plain text