libgo/go/math/big/rat_test.go

   1 // Copyright 2010 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         "math"
   9         "testing"
  10 )
  11
  12 func TestZeroRat(t *testing.T) {
  13         var x, y, z Rat
  14         y.SetFrac64(0, 42)
  15
  16         if x.Cmp(&y) != 0 {
  17                 t.Errorf("x and y should be both equal and zero")
  18         }
  19
  20         if s := x.String(); s != "0/1" {
  21                 t.Errorf("got x = %s, want 0/1", s)
  22         }
  23
  24         if s := x.RatString(); s != "0" {
  25                 t.Errorf("got x = %s, want 0", s)
  26         }
  27
  28         z.Add(&x, &y)
  29         if s := z.RatString(); s != "0" {
  30                 t.Errorf("got x+y = %s, want 0", s)
  31         }
  32
  33         z.Sub(&x, &y)
  34         if s := z.RatString(); s != "0" {
  35                 t.Errorf("got x-y = %s, want 0", s)
  36         }
  37
  38         z.Mul(&x, &y)
  39         if s := z.RatString(); s != "0" {
  40                 t.Errorf("got x*y = %s, want 0", s)
  41         }
  42
  43         // check for division by zero
  44         defer func() {
  45                 if s := recover(); s == nil || s.(string) != "division by zero" {
  46                         panic(s)
  47                 }
  48         }()
  49         z.Quo(&x, &y)
  50 }
  51
  52 func TestRatSign(t *testing.T) {
  53         zero := NewRat(0, 1)
  54         for _, a := range setStringTests {
  55                 x, ok := new(Rat).SetString(a.in)
  56                 if !ok {
  57                         continue
  58                 }
  59                 s := x.Sign()
  60                 e := x.Cmp(zero)
  61                 if s != e {
  62                         t.Errorf("got %d; want %d for z = %v", s, e, &x)
  63                 }
  64         }
  65 }
  66
  67 var ratCmpTests = []struct {
  68         rat1, rat2 string
  69         out        int
  70 }{
  71         {"0", "0/1", 0},
  72         {"1/1", "1", 0},
  73         {"-1", "-2/2", 0},
  74         {"1", "0", 1},
  75         {"0/1", "1/1", -1},
  76         {"-5/1434770811533343057144", "-5/1434770811533343057145", -1},
  77         {"49832350382626108453/8964749413", "49832350382626108454/8964749413", -1},
  78         {"-37414950961700930/7204075375675961", "37414950961700930/7204075375675961", -1},
  79         {"37414950961700930/7204075375675961", "74829901923401860/14408150751351922", 0},
  80 }
  81
  82 func TestRatCmp(t *testing.T) {
  83         for i, test := range ratCmpTests {
  84                 x, _ := new(Rat).SetString(test.rat1)
  85                 y, _ := new(Rat).SetString(test.rat2)
  86
  87                 out := x.Cmp(y)
  88                 if out != test.out {
  89                         t.Errorf("#%d got out = %v; want %v", i, out, test.out)
  90                 }
  91         }
  92 }
  93
  94 func TestIsInt(t *testing.T) {
  95         one := NewInt(1)
  96         for _, a := range setStringTests {
  97                 x, ok := new(Rat).SetString(a.in)
  98                 if !ok {
  99                         continue
 100                 }
 101                 i := x.IsInt()
 102                 e := x.Denom().Cmp(one) == 0
 103                 if i != e {
 104                         t.Errorf("got IsInt(%v) == %v; want %v", x, i, e)
 105                 }
 106         }
 107 }
 108
 109 func TestRatAbs(t *testing.T) {
 110         zero := new(Rat)
 111         for _, a := range setStringTests {
 112                 x, ok := new(Rat).SetString(a.in)
 113                 if !ok {
 114                         continue
 115                 }
 116                 e := new(Rat).Set(x)
 117                 if e.Cmp(zero) < 0 {
 118                         e.Sub(zero, e)
 119                 }
 120                 z := new(Rat).Abs(x)
 121                 if z.Cmp(e) != 0 {
 122                         t.Errorf("got Abs(%v) = %v; want %v", x, z, e)
 123                 }
 124         }
 125 }
 126
 127 func TestRatNeg(t *testing.T) {
 128         zero := new(Rat)
 129         for _, a := range setStringTests {
 130                 x, ok := new(Rat).SetString(a.in)
 131                 if !ok {
 132                         continue
 133                 }
 134                 e := new(Rat).Sub(zero, x)
 135                 z := new(Rat).Neg(x)
 136                 if z.Cmp(e) != 0 {
 137                         t.Errorf("got Neg(%v) = %v; want %v", x, z, e)
 138                 }
 139         }
 140 }
 141
 142 func TestRatInv(t *testing.T) {
 143         zero := new(Rat)
 144         for _, a := range setStringTests {
 145                 x, ok := new(Rat).SetString(a.in)
 146                 if !ok {
 147                         continue
 148                 }
 149                 if x.Cmp(zero) == 0 {
 150                         continue // avoid division by zero
 151                 }
 152                 e := new(Rat).SetFrac(x.Denom(), x.Num())
 153                 z := new(Rat).Inv(x)
 154                 if z.Cmp(e) != 0 {
 155                         t.Errorf("got Inv(%v) = %v; want %v", x, z, e)
 156                 }
 157         }
 158 }
 159
 160 type ratBinFun func(z, x, y *Rat) *Rat
 161 type ratBinArg struct {
 162         x, y, z string
 163 }
 164
 165 func testRatBin(t *testing.T, i int, name string, f ratBinFun, a ratBinArg) {
 166         x, _ := new(Rat).SetString(a.x)
 167         y, _ := new(Rat).SetString(a.y)
 168         z, _ := new(Rat).SetString(a.z)
 169         out := f(new(Rat), x, y)
 170
 171         if out.Cmp(z) != 0 {
 172                 t.Errorf("%s #%d got %s want %s", name, i, out, z)
 173         }
 174 }
 175
 176 var ratBinTests = []struct {
 177         x, y      string
 178         sum, prod string
 179 }{
 180         {"0", "0", "0", "0"},
 181         {"0", "1", "1", "0"},
 182         {"-1", "0", "-1", "0"},
 183         {"-1", "1", "0", "-1"},
 184         {"1", "1", "2", "1"},
 185         {"1/2", "1/2", "1", "1/4"},
 186         {"1/4", "1/3", "7/12", "1/12"},
 187         {"2/5", "-14/3", "-64/15", "-28/15"},
 188         {"4707/49292519774798173060", "-3367/70976135186689855734", "84058377121001851123459/1749296273614329067191168098769082663020", "-1760941/388732505247628681598037355282018369560"},
 189         {"-61204110018146728334/3", "-31052192278051565633/2", "-215564796870448153567/6", "950260896245257153059642991192710872711/3"},
 190         {"-854857841473707320655/4237645934602118692642972629634714039", "-18/31750379913563777419", "-27/133467566250814981", "15387441146526731771790/134546868362786310073779084329032722548987800600710485341"},
 191         {"618575745270541348005638912139/19198433543745179392300736", "-19948846211000086/637313996471", "27674141753240653/30123979153216", "-6169936206128396568797607742807090270137721977/6117715203873571641674006593837351328"},
 192         {"-3/26206484091896184128", "5/2848423294177090248", "15310893822118706237/9330894968229805033368778458685147968", "-5/24882386581946146755650075889827061248"},
 193         {"26946729/330400702820", "41563965/225583428284", "1238218672302860271/4658307703098666660055", "224002580204097/14906584649915733312176"},
 194         {"-8259900599013409474/7", "-84829337473700364773/56707961321161574960", "-468402123685491748914621885145127724451/396955729248131024720", "350340947706464153265156004876107029701/198477864624065512360"},
 195         {"575775209696864/1320203974639986246357", "29/712593081308", "410331716733912717985762465/940768218243776489278275419794956", "808/45524274987585732633"},
 196         {"1786597389946320496771/2066653520653241", "6269770/1992362624741777", "3559549865190272133656109052308126637/4117523232840525481453983149257", "8967230/3296219033"},
 197         {"-36459180403360509753/32150500941194292113930", "9381566963714/9633539", "301622077145533298008420642898530153/309723104686531919656937098270", "-3784609207827/3426986245"},
 198 }
 199
 200 func TestRatBin(t *testing.T) {
 201         for i, test := range ratBinTests {
 202                 arg := ratBinArg{test.x, test.y, test.sum}
 203                 testRatBin(t, i, "Add", (*Rat).Add, arg)
 204
 205                 arg = ratBinArg{test.y, test.x, test.sum}
 206                 testRatBin(t, i, "Add symmetric", (*Rat).Add, arg)
 207
 208                 arg = ratBinArg{test.sum, test.x, test.y}
 209                 testRatBin(t, i, "Sub", (*Rat).Sub, arg)
 210
 211                 arg = ratBinArg{test.sum, test.y, test.x}
 212                 testRatBin(t, i, "Sub symmetric", (*Rat).Sub, arg)
 213
 214                 arg = ratBinArg{test.x, test.y, test.prod}
 215                 testRatBin(t, i, "Mul", (*Rat).Mul, arg)
 216
 217                 arg = ratBinArg{test.y, test.x, test.prod}
 218                 testRatBin(t, i, "Mul symmetric", (*Rat).Mul, arg)
 219
 220                 if test.x != "0" {
 221                         arg = ratBinArg{test.prod, test.x, test.y}
 222                         testRatBin(t, i, "Quo", (*Rat).Quo, arg)
 223                 }
 224
 225                 if test.y != "0" {
 226                         arg = ratBinArg{test.prod, test.y, test.x}
 227                         testRatBin(t, i, "Quo symmetric", (*Rat).Quo, arg)
 228                 }
 229         }
 230 }
 231
 232 func TestIssue820(t *testing.T) {
 233         x := NewRat(3, 1)
 234         y := NewRat(2, 1)
 235         z := y.Quo(x, y)
 236         q := NewRat(3, 2)
 237         if z.Cmp(q) != 0 {
 238                 t.Errorf("got %s want %s", z, q)
 239         }
 240
 241         y = NewRat(3, 1)
 242         x = NewRat(2, 1)
 243         z = y.Quo(x, y)
 244         q = NewRat(2, 3)
 245         if z.Cmp(q) != 0 {
 246                 t.Errorf("got %s want %s", z, q)
 247         }
 248
 249         x = NewRat(3, 1)
 250         z = x.Quo(x, x)
 251         q = NewRat(3, 3)
 252         if z.Cmp(q) != 0 {
 253                 t.Errorf("got %s want %s", z, q)
 254         }
 255 }
 256
 257 var setFrac64Tests = []struct {
 258         a, b int64
 259         out  string
 260 }{
 261         {0, 1, "0"},
 262         {0, -1, "0"},
 263         {1, 1, "1"},
 264         {-1, 1, "-1"},
 265         {1, -1, "-1"},
 266         {-1, -1, "1"},
 267         {-9223372036854775808, -9223372036854775808, "1"},
 268 }
 269
 270 func TestRatSetFrac64Rat(t *testing.T) {
 271         for i, test := range setFrac64Tests {
 272                 x := new(Rat).SetFrac64(test.a, test.b)
 273                 if x.RatString() != test.out {
 274                         t.Errorf("#%d got %s want %s", i, x.RatString(), test.out)
 275                 }
 276         }
 277 }
 278
 279 func TestIssue2379(t *testing.T) {
 280         // 1) no aliasing
 281         q := NewRat(3, 2)
 282         x := new(Rat)
 283         x.SetFrac(NewInt(3), NewInt(2))
 284         if x.Cmp(q) != 0 {
 285                 t.Errorf("1) got %s want %s", x, q)
 286         }
 287
 288         // 2) aliasing of numerator
 289         x = NewRat(2, 3)
 290         x.SetFrac(NewInt(3), x.Num())
 291         if x.Cmp(q) != 0 {
 292                 t.Errorf("2) got %s want %s", x, q)
 293         }
 294
 295         // 3) aliasing of denominator
 296         x = NewRat(2, 3)
 297         x.SetFrac(x.Denom(), NewInt(2))
 298         if x.Cmp(q) != 0 {
 299                 t.Errorf("3) got %s want %s", x, q)
 300         }
 301
 302         // 4) aliasing of numerator and denominator
 303         x = NewRat(2, 3)
 304         x.SetFrac(x.Denom(), x.Num())
 305         if x.Cmp(q) != 0 {
 306                 t.Errorf("4) got %s want %s", x, q)
 307         }
 308
 309         // 5) numerator and denominator are the same
 310         q = NewRat(1, 1)
 311         x = new(Rat)
 312         n := NewInt(7)
 313         x.SetFrac(n, n)
 314         if x.Cmp(q) != 0 {
 315                 t.Errorf("5) got %s want %s", x, q)
 316         }
 317 }
 318
 319 func TestIssue3521(t *testing.T) {
 320         a := new(Int)
 321         b := new(Int)
 322         a.SetString("64375784358435883458348587", 0)
 323         b.SetString("4789759874531", 0)
 324
 325         // 0) a raw zero value has 1 as denominator
 326         zero := new(Rat)
 327         one := NewInt(1)
 328         if zero.Denom().Cmp(one) != 0 {
 329                 t.Errorf("0) got %s want %s", zero.Denom(), one)
 330         }
 331
 332         // 1a) the denominator of an (uninitialized) zero value is not shared with the value
 333         s := &zero.b
 334         d := zero.Denom()
 335         if d == s {
 336                 t.Errorf("1a) got %s (%p) == %s (%p) want different *Int values", d, d, s, s)
 337         }
 338
 339         // 1b) the denominator of an (uninitialized) value is a new 1 each time
 340         d1 := zero.Denom()
 341         d2 := zero.Denom()
 342         if d1 == d2 {
 343                 t.Errorf("1b) got %s (%p) == %s (%p) want different *Int values", d1, d1, d2, d2)
 344         }
 345
 346         // 1c) the denominator of an initialized zero value is shared with the value
 347         x := new(Rat)
 348         x.Set(x) // initialize x (any operation that sets x explicitly will do)
 349         s = &x.b
 350         d = x.Denom()
 351         if d != s {
 352                 t.Errorf("1c) got %s (%p) != %s (%p) want identical *Int values", d, d, s, s)
 353         }
 354
 355         // 1d) a zero value remains zero independent of denominator
 356         x.Denom().Set(new(Int).Neg(b))
 357         if x.Cmp(zero) != 0 {
 358                 t.Errorf("1d) got %s want %s", x, zero)
 359         }
 360
 361         // 1e) a zero value may have a denominator != 0 and != 1
 362         x.Num().Set(a)
 363         qab := new(Rat).SetFrac(a, b)
 364         if x.Cmp(qab) != 0 {
 365                 t.Errorf("1e) got %s want %s", x, qab)
 366         }
 367
 368         // 2a) an integral value becomes a fraction depending on denominator
 369         x.SetFrac64(10, 2)
 370         x.Denom().SetInt64(3)
 371         q53 := NewRat(5, 3)
 372         if x.Cmp(q53) != 0 {
 373                 t.Errorf("2a) got %s want %s", x, q53)
 374         }
 375
 376         // 2b) an integral value becomes a fraction depending on denominator
 377         x = NewRat(10, 2)
 378         x.Denom().SetInt64(3)
 379         if x.Cmp(q53) != 0 {
 380                 t.Errorf("2b) got %s want %s", x, q53)
 381         }
 382
 383         // 3) changing the numerator/denominator of a Rat changes the Rat
 384         x.SetFrac(a, b)
 385         a = x.Num()
 386         b = x.Denom()
 387         a.SetInt64(5)
 388         b.SetInt64(3)
 389         if x.Cmp(q53) != 0 {
 390                 t.Errorf("3) got %s want %s", x, q53)
 391         }
 392 }
 393
 394 func TestFloat32Distribution(t *testing.T) {
 395         // Generate a distribution of (sign, mantissa, exp) values
 396         // broader than the float32 range, and check Rat.Float32()
 397         // always picks the closest float32 approximation.
 398         var add = []int64{
 399                 0,
 400                 1,
 401                 3,
 402                 5,
 403                 7,
 404                 9,
 405                 11,
 406         }
 407         var winc, einc = uint64(5), 15 // quick test (~60ms on x86-64)
 408         if *long {
 409                 winc, einc = uint64(1), 1 // soak test (~1.5s on x86-64)
 410         }
 411
 412         for _, sign := range "+-" {
 413                 for _, a := range add {
 414                         for wid := uint64(0); wid < 30; wid += winc {
 415                                 b := 1<<wid + a
 416                                 if sign == '-' {
 417                                         b = -b
 418                                 }
 419                                 for exp := -150; exp < 150; exp += einc {
 420                                         num, den := NewInt(b), NewInt(1)
 421                                         if exp > 0 {
 422                                                 num.Lsh(num, uint(exp))
 423                                         } else {
 424                                                 den.Lsh(den, uint(-exp))
 425                                         }
 426                                         r := new(Rat).SetFrac(num, den)
 427                                         f, _ := r.Float32()
 428
 429                                         if !checkIsBestApprox32(t, f, r) {
 430                                                 // Append context information.
 431                                                 t.Errorf("(input was mantissa %#x, exp %d; f = %g (%b); f ~ %g; r = %v)",
 432                                                         b, exp, f, f, math.Ldexp(float64(b), exp), r)
 433                                         }
 434
 435                                         checkNonLossyRoundtrip32(t, f)
 436                                 }
 437                         }
 438                 }
 439         }
 440 }
 441
 442 func TestFloat64Distribution(t *testing.T) {
 443         // Generate a distribution of (sign, mantissa, exp) values
 444         // broader than the float64 range, and check Rat.Float64()
 445         // always picks the closest float64 approximation.
 446         var add = []int64{
 447                 0,
 448                 1,
 449                 3,
 450                 5,
 451                 7,
 452                 9,
 453                 11,
 454         }
 455         var winc, einc = uint64(10), 500 // quick test (~12ms on x86-64)
 456         if *long {
 457                 winc, einc = uint64(1), 1 // soak test (~75s on x86-64)
 458         }
 459
 460         for _, sign := range "+-" {
 461                 for _, a := range add {
 462                         for wid := uint64(0); wid < 60; wid += winc {
 463                                 b := 1<<wid + a
 464                                 if sign == '-' {
 465                                         b = -b
 466                                 }
 467                                 for exp := -1100; exp < 1100; exp += einc {
 468                                         num, den := NewInt(b), NewInt(1)
 469                                         if exp > 0 {
 470                                                 num.Lsh(num, uint(exp))
 471                                         } else {
 472                                                 den.Lsh(den, uint(-exp))
 473                                         }
 474                                         r := new(Rat).SetFrac(num, den)
 475                                         f, _ := r.Float64()
 476
 477                                         if !checkIsBestApprox64(t, f, r) {
 478                                                 // Append context information.
 479                                                 t.Errorf("(input was mantissa %#x, exp %d; f = %g (%b); f ~ %g; r = %v)",
 480                                                         b, exp, f, f, math.Ldexp(float64(b), exp), r)
 481                                         }
 482
 483                                         checkNonLossyRoundtrip64(t, f)
 484                                 }
 485                         }
 486                 }
 487         }
 488 }
 489
 490 // TestSetFloat64NonFinite checks that SetFloat64 of a non-finite value
 491 // returns nil.
 492 func TestSetFloat64NonFinite(t *testing.T) {
 493         for _, f := range []float64{math.NaN(), math.Inf(+1), math.Inf(-1)} {
 494                 var r Rat
 495                 if r2 := r.SetFloat64(f); r2 != nil {
 496                         t.Errorf("SetFloat64(%g) was %v, want nil", f, r2)
 497                 }
 498         }
 499 }
 500
 501 // checkNonLossyRoundtrip32 checks that a float->Rat->float roundtrip is
 502 // non-lossy for finite f.
 503 func checkNonLossyRoundtrip32(t *testing.T, f float32) {
 504         if !isFinite(float64(f)) {
 505                 return
 506         }
 507         r := new(Rat).SetFloat64(float64(f))
 508         if r == nil {
 509                 t.Errorf("Rat.SetFloat64(float64(%g) (%b)) == nil", f, f)
 510                 return
 511         }
 512         f2, exact := r.Float32()
 513         if f != f2 || !exact {
 514                 t.Errorf("Rat.SetFloat64(float64(%g)).Float32() = %g (%b), %v, want %g (%b), %v; delta = %b",
 515                         f, f2, f2, exact, f, f, true, f2-f)
 516         }
 517 }
 518
 519 // checkNonLossyRoundtrip64 checks that a float->Rat->float roundtrip is
 520 // non-lossy for finite f.
 521 func checkNonLossyRoundtrip64(t *testing.T, f float64) {
 522         if !isFinite(f) {
 523                 return
 524         }
 525         r := new(Rat).SetFloat64(f)
 526         if r == nil {
 527                 t.Errorf("Rat.SetFloat64(%g (%b)) == nil", f, f)
 528                 return
 529         }
 530         f2, exact := r.Float64()
 531         if f != f2 || !exact {
 532                 t.Errorf("Rat.SetFloat64(%g).Float64() = %g (%b), %v, want %g (%b), %v; delta = %b",
 533                         f, f2, f2, exact, f, f, true, f2-f)
 534         }
 535 }
 536
 537 // delta returns the absolute difference between r and f.
 538 func delta(r *Rat, f float64) *Rat {
 539         d := new(Rat).Sub(r, new(Rat).SetFloat64(f))
 540         return d.Abs(d)
 541 }
 542
 543 // checkIsBestApprox32 checks that f is the best possible float32
 544 // approximation of r.
 545 // Returns true on success.
 546 func checkIsBestApprox32(t *testing.T, f float32, r *Rat) bool {
 547         if math.Abs(float64(f)) >= math.MaxFloat32 {
 548                 // Cannot check +Inf, -Inf, nor the float next to them (MaxFloat32).
 549                 // But we have tests for these special cases.
 550                 return true
 551         }
 552
 553         // r must be strictly between f0 and f1, the floats bracketing f.
 554         f0 := math.Nextafter32(f, float32(math.Inf(-1)))
 555         f1 := math.Nextafter32(f, float32(math.Inf(+1)))
 556
 557         // For f to be correct, r must be closer to f than to f0 or f1.
 558         df := delta(r, float64(f))
 559         df0 := delta(r, float64(f0))
 560         df1 := delta(r, float64(f1))
 561         if df.Cmp(df0) > 0 {
 562                 t.Errorf("Rat(%v).Float32() = %g (%b), but previous float32 %g (%b) is closer", r, f, f, f0, f0)
 563                 return false
 564         }
 565         if df.Cmp(df1) > 0 {
 566                 t.Errorf("Rat(%v).Float32() = %g (%b), but next float32 %g (%b) is closer", r, f, f, f1, f1)
 567                 return false
 568         }
 569         if df.Cmp(df0) == 0 && !isEven32(f) {
 570                 t.Errorf("Rat(%v).Float32() = %g (%b); halfway should have rounded to %g (%b) instead", r, f, f, f0, f0)
 571                 return false
 572         }
 573         if df.Cmp(df1) == 0 && !isEven32(f) {
 574                 t.Errorf("Rat(%v).Float32() = %g (%b); halfway should have rounded to %g (%b) instead", r, f, f, f1, f1)
 575                 return false
 576         }
 577         return true
 578 }
 579
 580 // checkIsBestApprox64 checks that f is the best possible float64
 581 // approximation of r.
 582 // Returns true on success.
 583 func checkIsBestApprox64(t *testing.T, f float64, r *Rat) bool {
 584         if math.Abs(f) >= math.MaxFloat64 {
 585                 // Cannot check +Inf, -Inf, nor the float next to them (MaxFloat64).
 586                 // But we have tests for these special cases.
 587                 return true
 588         }
 589
 590         // r must be strictly between f0 and f1, the floats bracketing f.
 591         f0 := math.Nextafter(f, math.Inf(-1))
 592         f1 := math.Nextafter(f, math.Inf(+1))
 593
 594         // For f to be correct, r must be closer to f than to f0 or f1.
 595         df := delta(r, f)
 596         df0 := delta(r, f0)
 597         df1 := delta(r, f1)
 598         if df.Cmp(df0) > 0 {
 599                 t.Errorf("Rat(%v).Float64() = %g (%b), but previous float64 %g (%b) is closer", r, f, f, f0, f0)
 600                 return false
 601         }
 602         if df.Cmp(df1) > 0 {
 603                 t.Errorf("Rat(%v).Float64() = %g (%b), but next float64 %g (%b) is closer", r, f, f, f1, f1)
 604                 return false
 605         }
 606         if df.Cmp(df0) == 0 && !isEven64(f) {
 607                 t.Errorf("Rat(%v).Float64() = %g (%b); halfway should have rounded to %g (%b) instead", r, f, f, f0, f0)
 608                 return false
 609         }
 610         if df.Cmp(df1) == 0 && !isEven64(f) {
 611                 t.Errorf("Rat(%v).Float64() = %g (%b); halfway should have rounded to %g (%b) instead", r, f, f, f1, f1)
 612                 return false
 613         }
 614         return true
 615 }
 616
 617 func isEven32(f float32) bool { return math.Float32bits(f)&1 == 0 }
 618 func isEven64(f float64) bool { return math.Float64bits(f)&1 == 0 }
 619
 620 func TestIsFinite(t *testing.T) {
 621         finites := []float64{
 622                 1.0 / 3,
 623                 4891559871276714924261e+222,
 624                 math.MaxFloat64,
 625                 math.SmallestNonzeroFloat64,
 626                 -math.MaxFloat64,
 627                 -math.SmallestNonzeroFloat64,
 628         }
 629         for _, f := range finites {
 630                 if !isFinite(f) {
 631                         t.Errorf("!IsFinite(%g (%b))", f, f)
 632                 }
 633         }
 634         nonfinites := []float64{
 635                 math.NaN(),
 636                 math.Inf(-1),
 637                 math.Inf(+1),
 638         }
 639         for _, f := range nonfinites {
 640                 if isFinite(f) {
 641                         t.Errorf("IsFinite(%g, (%b))", f, f)
 642                 }
 643         }
 644 }
 645
 646 func TestRatSetInt64(t *testing.T) {
 647         var testCases = []int64{
 648                 0,
 649                 1,
 650                 -1,
 651                 12345,
 652                 -98765,
 653                 math.MaxInt64,
 654                 math.MinInt64,
 655         }
 656         var r = new(Rat)
 657         for i, want := range testCases {
 658                 r.SetInt64(want)
 659                 if !r.IsInt() {
 660                         t.Errorf("#%d: Rat.SetInt64(%d) is not an integer", i, want)
 661                 }
 662                 num := r.Num()
 663                 if !num.IsInt64() {
 664                         t.Errorf("#%d: Rat.SetInt64(%d) numerator is not an int64", i, want)
 665                 }
 666                 got := num.Int64()
 667                 if got != want {
 668                         t.Errorf("#%d: Rat.SetInt64(%d) = %d, but expected %d", i, want, got, want)
 669                 }
 670         }
 671 }
 672
 673 func TestRatSetUint64(t *testing.T) {
 674         var testCases = []uint64{
 675                 0,
 676                 1,
 677                 12345,
 678                 ^uint64(0),
 679         }
 680         var r = new(Rat)
 681         for i, want := range testCases {
 682                 r.SetUint64(want)
 683                 if !r.IsInt() {
 684                         t.Errorf("#%d: Rat.SetUint64(%d) is not an integer", i, want)
 685                 }
 686                 num := r.Num()
 687                 if !num.IsUint64() {
 688                         t.Errorf("#%d: Rat.SetUint64(%d) numerator is not a uint64", i, want)
 689                 }
 690                 got := num.Uint64()
 691                 if got != want {
 692                         t.Errorf("#%d: Rat.SetUint64(%d) = %d, but expected %d", i, want, got, want)
 693                 }
 694         }
 695 }
 696
 697 func BenchmarkRatCmp(b *testing.B) {
 698         x, y := NewRat(4, 1), NewRat(7, 2)
 699         for i := 0; i < b.N; i++ {
 700                 x.Cmp(y)
 701         }
 702 }
 703
 704 // TestIssue34919 verifies that a Rat's denominator is not modified
 705 // when simply accessing the Rat value.
 706 func TestIssue34919(t *testing.T) {
 707         for _, acc := range []struct {
 708                 name string
 709                 f    func(*Rat)
 710         }{
 711                 {"Float32", func(x *Rat) { x.Float32() }},
 712                 {"Float64", func(x *Rat) { x.Float64() }},
 713                 {"Inv", func(x *Rat) { new(Rat).Inv(x) }},
 714                 {"Sign", func(x *Rat) { x.Sign() }},
 715                 {"IsInt", func(x *Rat) { x.IsInt() }},
 716                 {"Num", func(x *Rat) { x.Num() }},
 717                 // {"Denom", func(x *Rat) { x.Denom() }}, TODO(gri) should we change the API? See issue #33792.
 718         } {
 719                 // A denominator of length 0 is interpreted as 1. Make sure that
 720                 // "materialization" of the denominator doesn't lead to setting
 721                 // the underlying array element 0 to 1.
 722                 r := &Rat{Int{abs: nat{991}}, Int{abs: make(nat, 0, 1)}}
 723                 acc.f(r)
 724                 if d := r.b.abs[:1][0]; d != 0 {
 725                         t.Errorf("%s modified denominator: got %d, want 0", acc.name, d)
 726                 }
 727         }
 728 }
 729
 730 func TestDenomRace(t *testing.T) {
 731         x := NewRat(1, 2)
 732         const N = 3
 733         c := make(chan bool, N)
 734         for i := 0; i < N; i++ {
 735                 go func() {
 736                         // Denom (also used by Float.SetRat) used to mutate x unnecessarily,
 737                         // provoking race reports when run in the race detector.
 738                         x.Denom()
 739                         new(Float).SetRat(x)
 740                         c <- true
 741                 }()
 742         }
 743         for i := 0; i < N; i++ {
 744                 <-c
 745         }
 746 }