Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package rand

import (

        "errors"

        "fmt"

        "math"

        "testing"

)

const (

        numTestSamples = 10000

)

type statsResults struct {

        mean        float64

        stddev      float64

        closeEnough float64

        maxError    float64

}

func max(a, b float64) float64 {

        if a > b {

                return a

        }

        return b

}

func nearEqual(a, b, closeEnough, maxError float64) bool {

        absDiff := math.Abs(a - b)

        if absDiff < closeEnough { // Necessary when one value is zero and one value is close to zero.

                return true

        }

        return absDiff/max(math.Abs(a), math.Abs(b)) < maxError

}

var testSeeds = []int64{1, 1754801282, 1698661970, 1550503961}

// checkSimilarDistribution returns success if the mean and stddev of the

// two statsResults are similar.

func (this *statsResults) checkSimilarDistribution(expected *statsResults) error {

        if !nearEqual(this.mean, expected.mean, expected.closeEnough, expected.maxError) {

                s := fmt.Sprintf("mean %v != %v (allowed error %v, %v)", this.mean, expected.mean, expected.closeEnough, expected.maxError)

                fmt.Println(s)

                return errors.New(s)

        }

        if !nearEqual(this.stddev, expected.stddev, 0, expected.maxError) {

                s := fmt.Sprintf("stddev %v != %v (allowed error %v, %v)", this.stddev, expected.stddev, expected.closeEnough, expected.maxError)

                fmt.Println(s)

                return errors.New(s)

        }

        return nil

}

func getStatsResults(samples []float64) *statsResults {

        res := new(statsResults)

        var sum float64

        for i := range samples {

                sum += samples[i]

        }

        res.mean = sum / float64(len(samples))

        var devsum float64

        for i := range samples {

                devsum += math.Pow(samples[i]-res.mean, 2)

        }

        res.stddev = math.Sqrt(devsum / float64(len(samples)))

        return res

}

func checkSampleDistribution(t *testing.T, samples []float64, expected *statsResults) {

        actual := getStatsResults(samples)

        err := actual.checkSimilarDistribution(expected)

        if err != nil {

                t.Errorf(err.Error())

        }

}

func checkSampleSliceDistributions(t *testing.T, samples []float64, nslices int, expected *statsResults) {

        chunk := len(samples) / nslices

        for i := 0; i < nslices; i++ {

                low := i * chunk

                var high int

                if i == nslices-1 {

                        high = len(samples) - 1

                } else {

                        high = (i + 1) * chunk

                }

                checkSampleDistribution(t, samples[low:high], expected)

        }

}

//

// Normal distribution tests

//

func generateNormalSamples(nsamples int, mean, stddev float64, seed int64) []float64 {

        r := New(NewSource(seed))

        samples := make([]float64, nsamples)

        for i := range samples {

                samples[i] = r.NormFloat64()*stddev + mean

        }

        return samples

}

func testNormalDistribution(t *testing.T, nsamples int, mean, stddev float64, seed int64) {

        //fmt.Printf("testing nsamples=%v mean=%v stddev=%v seed=%v\n", nsamples, mean, stddev, seed);

        samples := generateNormalSamples(nsamples, mean, stddev, seed)

        errorScale := max(1.0, stddev) // Error scales with stddev

        expected := &statsResults{mean, stddev, 0.10 * errorScale, 0.08 * errorScale}

        // Make sure that the entire set matches the expected distribution.

        checkSampleDistribution(t, samples, expected)

        // Make sure that each half of the set matches the expected distribution.

        checkSampleSliceDistributions(t, samples, 2, expected)

        // Make sure that each 7th of the set matches the expected distribution.

        checkSampleSliceDistributions(t, samples, 7, expected)

}

// Actual tests

func TestStandardNormalValues(t *testing.T) {

        for _, seed := range testSeeds {

                testNormalDistribution(t, numTestSamples, 0, 1, seed)

        }

}

func TestNonStandardNormalValues(t *testing.T) {

        sdmax := 1000.0

        mmax := 1000.0

        if testing.Short() {

                sdmax = 5

                mmax = 5

        }

        for sd := 0.5; sd < sdmax; sd *= 2 {

                for m := 0.5; m < mmax; m *= 2 {

                        for _, seed := range testSeeds {

                                testNormalDistribution(t, numTestSamples, m, sd, seed)

                        }

                }

        }

}

//

// Exponential distribution tests

//

func generateExponentialSamples(nsamples int, rate float64, seed int64) []float64 {

        r := New(NewSource(seed))

        samples := make([]float64, nsamples)

        for i := range samples {

                samples[i] = r.ExpFloat64() / rate

        }

        return samples

}

func testExponentialDistribution(t *testing.T, nsamples int, rate float64, seed int64) {

        //fmt.Printf("testing nsamples=%v rate=%v seed=%v\n", nsamples, rate, seed);

        mean := 1 / rate

        stddev := mean

        samples := generateExponentialSamples(nsamples, rate, seed)

        errorScale := max(1.0, 1/rate) // Error scales with the inverse of the rate

        expected := &statsResults{mean, stddev, 0.10 * errorScale, 0.20 * errorScale}

        // Make sure that the entire set matches the expected distribution.

        checkSampleDistribution(t, samples, expected)

        // Make sure that each half of the set matches the expected distribution.

        checkSampleSliceDistributions(t, samples, 2, expected)

        // Make sure that each 7th of the set matches the expected distribution.

        checkSampleSliceDistributions(t, samples, 7, expected)

}

// Actual tests

func TestStandardExponentialValues(t *testing.T) {

        for _, seed := range testSeeds {

                testExponentialDistribution(t, numTestSamples, 1, seed)

        }

}

func TestNonStandardExponentialValues(t *testing.T) {

        for rate := 0.05; rate < 10; rate *= 2 {

                for _, seed := range testSeeds {

                        testExponentialDistribution(t, numTestSamples, rate, seed)

                }

        }

}

//

// Table generation tests

//

func initNorm() (testKn []uint32, testWn, testFn []float32) {

        const m1 = 1 << 31

        var (

                dn float64 = rn

                tn         = dn

                vn float64 = 9.91256303526217e-3

        )

        testKn = make([]uint32, 128)

        testWn = make([]float32, 128)

        testFn = make([]float32, 128)

        q := vn / math.Exp(-0.5*dn*dn)

        testKn[0] = uint32((dn / q) * m1)

        testKn[1] = 0

        testWn[0] = float32(q / m1)

        testWn[127] = float32(dn / m1)

        testFn[0] = 1.0

        testFn[127] = float32(math.Exp(-0.5 * dn * dn))

        for i := 126; i >= 1; i-- {

                dn = math.Sqrt(-2.0 * math.Log(vn/dn+math.Exp(-0.5*dn*dn)))

                testKn[i+1] = uint32((dn / tn) * m1)

                tn = dn

                testFn[i] = float32(math.Exp(-0.5 * dn * dn))

                testWn[i] = float32(dn / m1)

        }

        return

}

func initExp() (testKe []uint32, testWe, testFe []float32) {

        const m2 = 1 << 32

        var (

                de float64 = re

                te         = de

                ve float64 = 3.9496598225815571993e-3

        )

        testKe = make([]uint32, 256)

        testWe = make([]float32, 256)

        testFe = make([]float32, 256)

        q := ve / math.Exp(-de)

        testKe[0] = uint32((de / q) * m2)

        testKe[1] = 0

        testWe[0] = float32(q / m2)

        testWe[255] = float32(de / m2)

        testFe[0] = 1.0

        testFe[255] = float32(math.Exp(-de))

        for i := 254; i >= 1; i-- {

                de = -math.Log(ve/de + math.Exp(-de))

                testKe[i+1] = uint32((de / te) * m2)

                te = de

                testFe[i] = float32(math.Exp(-de))

                testWe[i] = float32(de / m2)

        }

        return

}

// compareUint32Slices returns the first index where the two slices

// disagree, or <0 if the lengths are the same and all elements

// are identical.

func compareUint32Slices(s1, s2 []uint32) int {

        if len(s1) != len(s2) {

                if len(s1) > len(s2) {

                        return len(s2) + 1

                }

                return len(s1) + 1

        }

        for i := range s1 {

                if s1[i] != s2[i] {

                        return i

                }

        }

        return -1

}

// compareFloat32Slices returns the first index where the two slices

// disagree, or <0 if the lengths are the same and all elements

// are identical.

func compareFloat32Slices(s1, s2 []float32) int {

        if len(s1) != len(s2) {

                if len(s1) > len(s2) {

                        return len(s2) + 1

                }

                return len(s1) + 1

        }

        for i := range s1 {

                if !nearEqual(float64(s1[i]), float64(s2[i]), 0, 1e-7) {

                        return i

                }

        }

        return -1

}

func TestNormTables(t *testing.T) {

        testKn, testWn, testFn := initNorm()

        if i := compareUint32Slices(kn[0:], testKn); i >= 0 {

                t.Errorf("kn disagrees at index %v; %v != %v", i, kn[i], testKn[i])

        }

        if i := compareFloat32Slices(wn[0:], testWn); i >= 0 {

                t.Errorf("wn disagrees at index %v; %v != %v", i, wn[i], testWn[i])

        }

        if i := compareFloat32Slices(fn[0:], testFn); i >= 0 {

                t.Errorf("fn disagrees at index %v; %v != %v", i, fn[i], testFn[i])

        }

}

func TestExpTables(t *testing.T) {

        testKe, testWe, testFe := initExp()

        if i := compareUint32Slices(ke[0:], testKe); i >= 0 {

                t.Errorf("ke disagrees at index %v; %v != %v", i, ke[i], testKe[i])

        }

        if i := compareFloat32Slices(we[0:], testWe); i >= 0 {

                t.Errorf("we disagrees at index %v; %v != %v", i, we[i], testWe[i])

        }

        if i := compareFloat32Slices(fe[0:], testFe); i >= 0 {

                t.Errorf("fe disagrees at index %v; %v != %v", i, fe[i], testFe[i])

        }

}

// Benchmarks

func BenchmarkInt63Threadsafe(b *testing.B) {

        for n := b.N; n > 0; n-- {

                Int63()

        }

}

func BenchmarkInt63Unthreadsafe(b *testing.B) {

        r := New(NewSource(1))

        for n := b.N; n > 0; n-- {

                r.Int63()

        }

}

func BenchmarkIntn1000(b *testing.B) {

        r := New(NewSource(1))

        for n := b.N; n > 0; n-- {

                r.Intn(1000)

        }

}

func BenchmarkInt63n1000(b *testing.B) {

        r := New(NewSource(1))

        for n := b.N; n > 0; n-- {

                r.Int63n(1000)

        }

}

func BenchmarkInt31n1000(b *testing.B) {

        r := New(NewSource(1))

        for n := b.N; n > 0; n-- {

                r.Int31n(1000)

        }

}