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 5package big 6 7import ( 8 "math" 9 "testing" 10) 11 12func 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 52func 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 67var 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 82func 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 94func 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 109func 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 127func 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 142func 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 160type ratBinFun func(z, x, y *Rat) *Rat 161type ratBinArg struct { 162 x, y, z string 163} 164 165func 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 176var 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 200func 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 232func 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 257var 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 270func 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 279func 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 319func 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 394func 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 442func 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. 492func 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. 503func 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. 521func 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. 538func 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. 546func 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. 583func 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 617func isEven32(f float32) bool { return math.Float32bits(f)&1 == 0 } 618func isEven64(f float64) bool { return math.Float64bits(f)&1 == 0 } 619 620func 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 646func 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 673func 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 697func 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. 706func 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 730func 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} 747