src/math/rand/v2/rand_test.go

   1 // Copyright 2009 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 rand_test
   6
   7 import (
   8         "errors"
   9         "fmt"
  10         "internal/testenv"
  11         "math"
  12         . "math/rand/v2"
  13         "os"
  14         "runtime"
  15         "sync"
  16         "sync/atomic"
  17         "testing"
  18 )
  19
  20 const (
  21         numTestSamples = 10000
  22 )
  23
  24 var rn, kn, wn, fn = GetNormalDistributionParameters()
  25 var re, ke, we, fe = GetExponentialDistributionParameters()
  26
  27 type statsResults struct {
  28         mean        float64
  29         stddev      float64
  30         closeEnough float64
  31         maxError    float64
  32 }
  33
  34 func max(a, b float64) float64 {
  35         if a > b {
  36                 return a
  37         }
  38         return b
  39 }
  40
  41 func nearEqual(a, b, closeEnough, maxError float64) bool {
  42         absDiff := math.Abs(a - b)
  43         if absDiff < closeEnough { // Necessary when one value is zero and one value is close to zero.
  44                 return true
  45         }
  46         return absDiff/max(math.Abs(a), math.Abs(b)) < maxError
  47 }
  48
  49 var testSeeds = []uint64{1, 1754801282, 1698661970, 1550503961}
  50
  51 // checkSimilarDistribution returns success if the mean and stddev of the
  52 // two statsResults are similar.
  53 func (this *statsResults) checkSimilarDistribution(expected *statsResults) error {
  54         if !nearEqual(this.mean, expected.mean, expected.closeEnough, expected.maxError) {
  55                 s := fmt.Sprintf("mean %v != %v (allowed error %v, %v)", this.mean, expected.mean, expected.closeEnough, expected.maxError)
  56                 fmt.Println(s)
  57                 return errors.New(s)
  58         }
  59         if !nearEqual(this.stddev, expected.stddev, expected.closeEnough, expected.maxError) {
  60                 s := fmt.Sprintf("stddev %v != %v (allowed error %v, %v)", this.stddev, expected.stddev, expected.closeEnough, expected.maxError)
  61                 fmt.Println(s)
  62                 return errors.New(s)
  63         }
  64         return nil
  65 }
  66
  67 func getStatsResults(samples []float64) *statsResults {
  68         res := new(statsResults)
  69         var sum, squaresum float64
  70         for _, s := range samples {
  71                 sum += s
  72                 squaresum += s * s
  73         }
  74         res.mean = sum / float64(len(samples))
  75         res.stddev = math.Sqrt(squaresum/float64(len(samples)) - res.mean*res.mean)
  76         return res
  77 }
  78
  79 func checkSampleDistribution(t *testing.T, samples []float64, expected *statsResults) {
  80         t.Helper()
  81         actual := getStatsResults(samples)
  82         err := actual.checkSimilarDistribution(expected)
  83         if err != nil {
  84                 t.Errorf(err.Error())
  85         }
  86 }
  87
  88 func checkSampleSliceDistributions(t *testing.T, samples []float64, nslices int, expected *statsResults) {
  89         t.Helper()
  90         chunk := len(samples) / nslices
  91         for i := 0; i < nslices; i++ {
  92                 low := i * chunk
  93                 var high int
  94                 if i == nslices-1 {
  95                         high = len(samples) - 1
  96                 } else {
  97                         high = (i + 1) * chunk
  98                 }
  99                 checkSampleDistribution(t, samples[low:high], expected)
 100         }
 101 }
 102
 103 //
 104 // Normal distribution tests
 105 //
 106
 107 func generateNormalSamples(nsamples int, mean, stddev float64, seed uint64) []float64 {
 108         r := New(NewPCG(seed, seed))
 109         samples := make([]float64, nsamples)
 110         for i := range samples {
 111                 samples[i] = r.NormFloat64()*stddev + mean
 112         }
 113         return samples
 114 }
 115
 116 func testNormalDistribution(t *testing.T, nsamples int, mean, stddev float64, seed uint64) {
 117         //fmt.Printf("testing nsamples=%v mean=%v stddev=%v seed=%v\n", nsamples, mean, stddev, seed);
 118
 119         samples := generateNormalSamples(nsamples, mean, stddev, seed)
 120         errorScale := max(1.0, stddev) // Error scales with stddev
 121         expected := &statsResults{mean, stddev, 0.10 * errorScale, 0.08 * errorScale}
 122
 123         // Make sure that the entire set matches the expected distribution.
 124         checkSampleDistribution(t, samples, expected)
 125
 126         // Make sure that each half of the set matches the expected distribution.
 127         checkSampleSliceDistributions(t, samples, 2, expected)
 128
 129         // Make sure that each 7th of the set matches the expected distribution.
 130         checkSampleSliceDistributions(t, samples, 7, expected)
 131 }
 132
 133 // Actual tests
 134
 135 func TestStandardNormalValues(t *testing.T) {
 136         for _, seed := range testSeeds {
 137                 testNormalDistribution(t, numTestSamples, 0, 1, seed)
 138         }
 139 }
 140
 141 func TestNonStandardNormalValues(t *testing.T) {
 142         sdmax := 1000.0
 143         mmax := 1000.0
 144         if testing.Short() {
 145                 sdmax = 5
 146                 mmax = 5
 147         }
 148         for sd := 0.5; sd < sdmax; sd *= 2 {
 149                 for m := 0.5; m < mmax; m *= 2 {
 150                         for _, seed := range testSeeds {
 151                                 testNormalDistribution(t, numTestSamples, m, sd, seed)
 152                                 if testing.Short() {
 153                                         break
 154                                 }
 155                         }
 156                 }
 157         }
 158 }
 159
 160 //
 161 // Exponential distribution tests
 162 //
 163
 164 func generateExponentialSamples(nsamples int, rate float64, seed uint64) []float64 {
 165         r := New(NewPCG(seed, seed))
 166         samples := make([]float64, nsamples)
 167         for i := range samples {
 168                 samples[i] = r.ExpFloat64() / rate
 169         }
 170         return samples
 171 }
 172
 173 func testExponentialDistribution(t *testing.T, nsamples int, rate float64, seed uint64) {
 174         //fmt.Printf("testing nsamples=%v rate=%v seed=%v\n", nsamples, rate, seed);
 175
 176         mean := 1 / rate
 177         stddev := mean
 178
 179         samples := generateExponentialSamples(nsamples, rate, seed)
 180         errorScale := max(1.0, 1/rate) // Error scales with the inverse of the rate
 181         expected := &statsResults{mean, stddev, 0.10 * errorScale, 0.20 * errorScale}
 182
 183         // Make sure that the entire set matches the expected distribution.
 184         checkSampleDistribution(t, samples, expected)
 185
 186         // Make sure that each half of the set matches the expected distribution.
 187         checkSampleSliceDistributions(t, samples, 2, expected)
 188
 189         // Make sure that each 7th of the set matches the expected distribution.
 190         checkSampleSliceDistributions(t, samples, 7, expected)
 191 }
 192
 193 // Actual tests
 194
 195 func TestStandardExponentialValues(t *testing.T) {
 196         for _, seed := range testSeeds {
 197                 testExponentialDistribution(t, numTestSamples, 1, seed)
 198         }
 199 }
 200
 201 func TestNonStandardExponentialValues(t *testing.T) {
 202         for rate := 0.05; rate < 10; rate *= 2 {
 203                 for _, seed := range testSeeds {
 204                         testExponentialDistribution(t, numTestSamples, rate, seed)
 205                         if testing.Short() {
 206                                 break
 207                         }
 208                 }
 209         }
 210 }
 211
 212 //
 213 // Table generation tests
 214 //
 215
 216 func initNorm() (testKn []uint32, testWn, testFn []float32) {
 217         const m1 = 1 << 31
 218         var (
 219                 dn float64 = rn
 220                 tn         = dn
 221                 vn float64 = 9.91256303526217e-3
 222         )
 223
 224         testKn = make([]uint32, 128)
 225         testWn = make([]float32, 128)
 226         testFn = make([]float32, 128)
 227
 228         q := vn / math.Exp(-0.5*dn*dn)
 229         testKn[0] = uint32((dn / q) * m1)
 230         testKn[1] = 0
 231         testWn[0] = float32(q / m1)
 232         testWn[127] = float32(dn / m1)
 233         testFn[0] = 1.0
 234         testFn[127] = float32(math.Exp(-0.5 * dn * dn))
 235         for i := 126; i >= 1; i-- {
 236                 dn = math.Sqrt(-2.0 * math.Log(vn/dn+math.Exp(-0.5*dn*dn)))
 237                 testKn[i+1] = uint32((dn / tn) * m1)
 238                 tn = dn
 239                 testFn[i] = float32(math.Exp(-0.5 * dn * dn))
 240                 testWn[i] = float32(dn / m1)
 241         }
 242         return
 243 }
 244
 245 func initExp() (testKe []uint32, testWe, testFe []float32) {
 246         const m2 = 1 << 32
 247         var (
 248                 de float64 = re
 249                 te         = de
 250                 ve float64 = 3.9496598225815571993e-3
 251         )
 252
 253         testKe = make([]uint32, 256)
 254         testWe = make([]float32, 256)
 255         testFe = make([]float32, 256)
 256
 257         q := ve / math.Exp(-de)
 258         testKe[0] = uint32((de / q) * m2)
 259         testKe[1] = 0
 260         testWe[0] = float32(q / m2)
 261         testWe[255] = float32(de / m2)
 262         testFe[0] = 1.0
 263         testFe[255] = float32(math.Exp(-de))
 264         for i := 254; i >= 1; i-- {
 265                 de = -math.Log(ve/de + math.Exp(-de))
 266                 testKe[i+1] = uint32((de / te) * m2)
 267                 te = de
 268                 testFe[i] = float32(math.Exp(-de))
 269                 testWe[i] = float32(de / m2)
 270         }
 271         return
 272 }
 273
 274 // compareUint32Slices returns the first index where the two slices
 275 // disagree, or <0 if the lengths are the same and all elements
 276 // are identical.
 277 func compareUint32Slices(s1, s2 []uint32) int {
 278         if len(s1) != len(s2) {
 279                 if len(s1) > len(s2) {
 280                         return len(s2) + 1
 281                 }
 282                 return len(s1) + 1
 283         }
 284         for i := range s1 {
 285                 if s1[i] != s2[i] {
 286                         return i
 287                 }
 288         }
 289         return -1
 290 }
 291
 292 // compareFloat32Slices returns the first index where the two slices
 293 // disagree, or <0 if the lengths are the same and all elements
 294 // are identical.
 295 func compareFloat32Slices(s1, s2 []float32) int {
 296         if len(s1) != len(s2) {
 297                 if len(s1) > len(s2) {
 298                         return len(s2) + 1
 299                 }
 300                 return len(s1) + 1
 301         }
 302         for i := range s1 {
 303                 if !nearEqual(float64(s1[i]), float64(s2[i]), 0, 1e-7) {
 304                         return i
 305                 }
 306         }
 307         return -1
 308 }
 309
 310 func TestNormTables(t *testing.T) {
 311         testKn, testWn, testFn := initNorm()
 312         if i := compareUint32Slices(kn[0:], testKn); i >= 0 {
 313                 t.Errorf("kn disagrees at index %v; %v != %v", i, kn[i], testKn[i])
 314         }
 315         if i := compareFloat32Slices(wn[0:], testWn); i >= 0 {
 316                 t.Errorf("wn disagrees at index %v; %v != %v", i, wn[i], testWn[i])
 317         }
 318         if i := compareFloat32Slices(fn[0:], testFn); i >= 0 {
 319                 t.Errorf("fn disagrees at index %v; %v != %v", i, fn[i], testFn[i])
 320         }
 321 }
 322
 323 func TestExpTables(t *testing.T) {
 324         testKe, testWe, testFe := initExp()
 325         if i := compareUint32Slices(ke[0:], testKe); i >= 0 {
 326                 t.Errorf("ke disagrees at index %v; %v != %v", i, ke[i], testKe[i])
 327         }
 328         if i := compareFloat32Slices(we[0:], testWe); i >= 0 {
 329                 t.Errorf("we disagrees at index %v; %v != %v", i, we[i], testWe[i])
 330         }
 331         if i := compareFloat32Slices(fe[0:], testFe); i >= 0 {
 332                 t.Errorf("fe disagrees at index %v; %v != %v", i, fe[i], testFe[i])
 333         }
 334 }
 335
 336 func hasSlowFloatingPoint() bool {
 337         switch runtime.GOARCH {
 338         case "arm":
 339                 return os.Getenv("GOARM") == "5"
 340         case "mips", "mipsle", "mips64", "mips64le":
 341                 // Be conservative and assume that all mips boards
 342                 // have emulated floating point.
 343                 // TODO: detect what it actually has.
 344                 return true
 345         }
 346         return false
 347 }
 348
 349 func TestFloat32(t *testing.T) {
 350         // For issue 6721, the problem came after 7533753 calls, so check 10e6.
 351         num := int(10e6)
 352         // But do the full amount only on builders (not locally).
 353         // But ARM5 floating point emulation is slow (Issue 10749), so
 354         // do less for that builder:
 355         if testing.Short() && (testenv.Builder() == "" || hasSlowFloatingPoint()) {
 356                 num /= 100 // 1.72 seconds instead of 172 seconds
 357         }
 358
 359         r := testRand()
 360         for ct := 0; ct < num; ct++ {
 361                 f := r.Float32()
 362                 if f >= 1 {
 363                         t.Fatal("Float32() should be in range [0,1). ct:", ct, "f:", f)
 364                 }
 365         }
 366 }
 367
 368 func TestShuffleSmall(t *testing.T) {
 369         // Check that Shuffle allows n=0 and n=1, but that swap is never called for them.
 370         r := testRand()
 371         for n := 0; n <= 1; n++ {
 372                 r.Shuffle(n, func(i, j int) { t.Fatalf("swap called, n=%d i=%d j=%d", n, i, j) })
 373         }
 374 }
 375
 376 // encodePerm converts from a permuted slice of length n, such as Perm generates, to an int in [0, n!).
 377 // See https://en.wikipedia.org/wiki/Lehmer_code.
 378 // encodePerm modifies the input slice.
 379 func encodePerm(s []int) int {
 380         // Convert to Lehmer code.
 381         for i, x := range s {
 382                 r := s[i+1:]
 383                 for j, y := range r {
 384                         if y > x {
 385                                 r[j]--
 386                         }
 387                 }
 388         }
 389         // Convert to int in [0, n!).
 390         m := 0
 391         fact := 1
 392         for i := len(s) - 1; i >= 0; i-- {
 393                 m += s[i] * fact
 394                 fact *= len(s) - i
 395         }
 396         return m
 397 }
 398
 399 // TestUniformFactorial tests several ways of generating a uniform value in [0, n!).
 400 func TestUniformFactorial(t *testing.T) {
 401         r := New(NewPCG(1, 2))
 402         top := 6
 403         if testing.Short() {
 404                 top = 3
 405         }
 406         for n := 3; n <= top; n++ {
 407                 t.Run(fmt.Sprintf("n=%d", n), func(t *testing.T) {
 408                         // Calculate n!.
 409                         nfact := 1
 410                         for i := 2; i <= n; i++ {
 411                                 nfact *= i
 412                         }
 413
 414                         // Test a few different ways to generate a uniform distribution.
 415                         p := make([]int, n) // re-usable slice for Shuffle generator
 416                         tests := [...]struct {
 417                                 name string
 418                                 fn   func() int
 419                         }{
 420                                 {name: "Int32N", fn: func() int { return int(r.Int32N(int32(nfact))) }},
 421                                 {name: "Perm", fn: func() int { return encodePerm(r.Perm(n)) }},
 422                                 {name: "Shuffle", fn: func() int {
 423                                         // Generate permutation using Shuffle.
 424                                         for i := range p {
 425                                                 p[i] = i
 426                                         }
 427                                         r.Shuffle(n, func(i, j int) { p[i], p[j] = p[j], p[i] })
 428                                         return encodePerm(p)
 429                                 }},
 430                         }
 431
 432                         for _, test := range tests {
 433                                 t.Run(test.name, func(t *testing.T) {
 434                                         // Gather chi-squared values and check that they follow
 435                                         // the expected normal distribution given n!-1 degrees of freedom.
 436                                         // See https://en.wikipedia.org/wiki/Pearson%27s_chi-squared_test and
 437                                         // https://www.johndcook.com/Beautiful_Testing_ch10.pdf.
 438                                         nsamples := 10 * nfact
 439                                         if nsamples < 1000 {
 440                                                 nsamples = 1000
 441                                         }
 442                                         samples := make([]float64, nsamples)
 443                                         for i := range samples {
 444                                                 // Generate some uniformly distributed values and count their occurrences.
 445                                                 const iters = 1000
 446                                                 counts := make([]int, nfact)
 447                                                 for i := 0; i < iters; i++ {
 448                                                         counts[test.fn()]++
 449                                                 }
 450                                                 // Calculate chi-squared and add to samples.
 451                                                 want := iters / float64(nfact)
 452                                                 var χ2 float64
 453                                                 for _, have := range counts {
 454                                                         err := float64(have) - want
 455                                                         χ2 += err * err
 456                                                 }
 457                                                 χ2 /= want
 458                                                 samples[i] = χ2
 459                                         }
 460
 461                                         // Check that our samples approximate the appropriate normal distribution.
 462                                         dof := float64(nfact - 1)
 463                                         expected := &statsResults{mean: dof, stddev: math.Sqrt(2 * dof)}
 464                                         errorScale := max(1.0, expected.stddev)
 465                                         expected.closeEnough = 0.10 * errorScale
 466                                         expected.maxError = 0.08 // TODO: What is the right value here? See issue 21211.
 467                                         checkSampleDistribution(t, samples, expected)
 468                                 })
 469                         }
 470                 })
 471         }
 472 }
 473
 474 // Benchmarks
 475
 476 var Sink uint64
 477
 478 func testRand() *Rand {
 479         return New(NewPCG(1, 2))
 480 }
 481
 482 func BenchmarkSourceUint64(b *testing.B) {
 483         s := NewPCG(1, 2)
 484         var t uint64
 485         for n := b.N; n > 0; n-- {
 486                 t += s.Uint64()
 487         }
 488         Sink = uint64(t)
 489 }
 490
 491 func BenchmarkGlobalInt64(b *testing.B) {
 492         var t int64
 493         for n := b.N; n > 0; n-- {
 494                 t += Int64()
 495         }
 496         Sink = uint64(t)
 497 }
 498
 499 func BenchmarkGlobalInt64Parallel(b *testing.B) {
 500         b.RunParallel(func(pb *testing.PB) {
 501                 var t int64
 502                 for pb.Next() {
 503                         t += Int64()
 504                 }
 505                 atomic.AddUint64(&Sink, uint64(t))
 506         })
 507 }
 508
 509 func BenchmarkGlobalUint64(b *testing.B) {
 510         var t uint64
 511         for n := b.N; n > 0; n-- {
 512                 t += Uint64()
 513         }
 514         Sink = t
 515 }
 516
 517 func BenchmarkGlobalUint64Parallel(b *testing.B) {
 518         b.RunParallel(func(pb *testing.PB) {
 519                 var t uint64
 520                 for pb.Next() {
 521                         t += Uint64()
 522                 }
 523                 atomic.AddUint64(&Sink, t)
 524         })
 525 }
 526
 527 func BenchmarkInt64(b *testing.B) {
 528         r := testRand()
 529         var t int64
 530         for n := b.N; n > 0; n-- {
 531                 t += r.Int64()
 532         }
 533         Sink = uint64(t)
 534 }
 535
 536 var AlwaysFalse = false
 537
 538 func keep[T int | uint | int32 | uint32 | int64 | uint64](x T) T {
 539         if AlwaysFalse {
 540                 return -x
 541         }
 542         return x
 543 }
 544
 545 func BenchmarkUint64(b *testing.B) {
 546         r := testRand()
 547         var t uint64
 548         for n := b.N; n > 0; n-- {
 549                 t += r.Uint64()
 550         }
 551         Sink = t
 552 }
 553
 554 func BenchmarkGlobalIntN1000(b *testing.B) {
 555         var t int
 556         arg := keep(1000)
 557         for n := b.N; n > 0; n-- {
 558                 t += IntN(arg)
 559         }
 560         Sink = uint64(t)
 561 }
 562
 563 func BenchmarkIntN1000(b *testing.B) {
 564         r := testRand()
 565         var t int
 566         arg := keep(1000)
 567         for n := b.N; n > 0; n-- {
 568                 t += r.IntN(arg)
 569         }
 570         Sink = uint64(t)
 571 }
 572
 573 func BenchmarkInt64N1000(b *testing.B) {
 574         r := testRand()
 575         var t int64
 576         arg := keep(int64(1000))
 577         for n := b.N; n > 0; n-- {
 578                 t += r.Int64N(arg)
 579         }
 580         Sink = uint64(t)
 581 }
 582
 583 func BenchmarkInt64N1e8(b *testing.B) {
 584         r := testRand()
 585         var t int64
 586         arg := keep(int64(1e8))
 587         for n := b.N; n > 0; n-- {
 588                 t += r.Int64N(arg)
 589         }
 590         Sink = uint64(t)
 591 }
 592
 593 func BenchmarkInt64N1e9(b *testing.B) {
 594         r := testRand()
 595         var t int64
 596         arg := keep(int64(1e9))
 597         for n := b.N; n > 0; n-- {
 598                 t += r.Int64N(arg)
 599         }
 600         Sink = uint64(t)
 601 }
 602
 603 func BenchmarkInt64N2e9(b *testing.B) {
 604         r := testRand()
 605         var t int64
 606         arg := keep(int64(2e9))
 607         for n := b.N; n > 0; n-- {
 608                 t += r.Int64N(arg)
 609         }
 610         Sink = uint64(t)
 611 }
 612
 613 func BenchmarkInt64N1e18(b *testing.B) {
 614         r := testRand()
 615         var t int64
 616         arg := keep(int64(1e18))
 617         for n := b.N; n > 0; n-- {
 618                 t += r.Int64N(arg)
 619         }
 620         Sink = uint64(t)
 621 }
 622
 623 func BenchmarkInt64N2e18(b *testing.B) {
 624         r := testRand()
 625         var t int64
 626         arg := keep(int64(2e18))
 627         for n := b.N; n > 0; n-- {
 628                 t += r.Int64N(arg)
 629         }
 630         Sink = uint64(t)
 631 }
 632
 633 func BenchmarkInt64N4e18(b *testing.B) {
 634         r := testRand()
 635         var t int64
 636         arg := keep(int64(4e18))
 637         for n := b.N; n > 0; n-- {
 638                 t += r.Int64N(arg)
 639         }
 640         Sink = uint64(t)
 641 }
 642
 643 func BenchmarkInt32N1000(b *testing.B) {
 644         r := testRand()
 645         var t int32
 646         arg := keep(int32(1000))
 647         for n := b.N; n > 0; n-- {
 648                 t += r.Int32N(arg)
 649         }
 650         Sink = uint64(t)
 651 }
 652
 653 func BenchmarkInt32N1e8(b *testing.B) {
 654         r := testRand()
 655         var t int32
 656         arg := keep(int32(1e8))
 657         for n := b.N; n > 0; n-- {
 658                 t += r.Int32N(arg)
 659         }
 660         Sink = uint64(t)
 661 }
 662
 663 func BenchmarkInt32N1e9(b *testing.B) {
 664         r := testRand()
 665         var t int32
 666         arg := keep(int32(1e9))
 667         for n := b.N; n > 0; n-- {
 668                 t += r.Int32N(arg)
 669         }
 670         Sink = uint64(t)
 671 }
 672
 673 func BenchmarkInt32N2e9(b *testing.B) {
 674         r := testRand()
 675         var t int32
 676         arg := keep(int32(2e9))
 677         for n := b.N; n > 0; n-- {
 678                 t += r.Int32N(arg)
 679         }
 680         Sink = uint64(t)
 681 }
 682
 683 func BenchmarkFloat32(b *testing.B) {
 684         r := testRand()
 685         var t float32
 686         for n := b.N; n > 0; n-- {
 687                 t += r.Float32()
 688         }
 689         Sink = uint64(t)
 690 }
 691
 692 func BenchmarkFloat64(b *testing.B) {
 693         r := testRand()
 694         var t float64
 695         for n := b.N; n > 0; n-- {
 696                 t += r.Float64()
 697         }
 698         Sink = uint64(t)
 699 }
 700
 701 func BenchmarkExpFloat64(b *testing.B) {
 702         r := testRand()
 703         var t float64
 704         for n := b.N; n > 0; n-- {
 705                 t += r.ExpFloat64()
 706         }
 707         Sink = uint64(t)
 708 }
 709
 710 func BenchmarkNormFloat64(b *testing.B) {
 711         r := testRand()
 712         var t float64
 713         for n := b.N; n > 0; n-- {
 714                 t += r.NormFloat64()
 715         }
 716         Sink = uint64(t)
 717 }
 718
 719 func BenchmarkPerm3(b *testing.B) {
 720         r := testRand()
 721         var t int
 722         for n := b.N; n > 0; n-- {
 723                 t += r.Perm(3)[0]
 724         }
 725         Sink = uint64(t)
 726
 727 }
 728
 729 func BenchmarkPerm30(b *testing.B) {
 730         r := testRand()
 731         var t int
 732         for n := b.N; n > 0; n-- {
 733                 t += r.Perm(30)[0]
 734         }
 735         Sink = uint64(t)
 736 }
 737
 738 func BenchmarkPerm30ViaShuffle(b *testing.B) {
 739         r := testRand()
 740         var t int
 741         for n := b.N; n > 0; n-- {
 742                 p := make([]int, 30)
 743                 for i := range p {
 744                         p[i] = i
 745                 }
 746                 r.Shuffle(30, func(i, j int) { p[i], p[j] = p[j], p[i] })
 747                 t += p[0]
 748         }
 749         Sink = uint64(t)
 750 }
 751
 752 // BenchmarkShuffleOverhead uses a minimal swap function
 753 // to measure just the shuffling overhead.
 754 func BenchmarkShuffleOverhead(b *testing.B) {
 755         r := testRand()
 756         for n := b.N; n > 0; n-- {
 757                 r.Shuffle(30, func(i, j int) {
 758                         if i < 0 || i >= 30 || j < 0 || j >= 30 {
 759                                 b.Fatalf("bad swap(%d, %d)", i, j)
 760                         }
 761                 })
 762         }
 763 }
 764
 765 func BenchmarkConcurrent(b *testing.B) {
 766         const goroutines = 4
 767         var wg sync.WaitGroup
 768         wg.Add(goroutines)
 769         for i := 0; i < goroutines; i++ {
 770                 go func() {
 771                         defer wg.Done()
 772                         for n := b.N; n > 0; n-- {
 773                                 Int64()
 774                         }
 775                 }()
 776         }
 777         wg.Wait()
 778 }
 779
 780 func TestN(t *testing.T) {
 781         for i := 0; i < 1000; i++ {
 782                 v := N(10)
 783                 if v < 0 || v >= 10 {
 784                         t.Fatalf("N(10) returned %d", v)
 785                 }
 786         }
 787 }