testlapack: make tests independent

testlapack/dbdsqr.go

@@ -20,6 +20,7 @@ type Dbdsqrer interface {
 }
 
 func DbdsqrTest(t *testing.T, impl Dbdsqrer) {
+	rnd := rand.New(rand.NewSource(1))
 	bi := blas64.Implementation()
 	_ = bi
 	for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
@@ -58,11 +59,11 @@ func DbdsqrTest(t *testing.T, impl Dbdsqrer) {
 
 				d := make([]float64, n)
 				for i := range d {
-					d[i] = rand.NormFloat64()
+					d[i] = rnd.NormFloat64()
 				}
 				e := make([]float64, n-1)
 				for i := range e {
-					e[i] = rand.NormFloat64()
+					e[i] = rnd.NormFloat64()
 				}
 				dCopy := make([]float64, len(d))
 				copy(dCopy, d)
@@ -70,7 +71,7 @@ func DbdsqrTest(t *testing.T, impl Dbdsqrer) {
 				copy(eCopy, e)
 				work := make([]float64, 4*n)
 				for i := range work {
-					work[i] = rand.NormFloat64()
+					work[i] = rnd.NormFloat64()
 				}
 
 				// First test the decomposition of the bidiagonal matrix. Set
@@ -141,19 +142,19 @@ func DbdsqrTest(t *testing.T, impl Dbdsqrer) {
 
 				u := make([]float64, nru*ldu)
 				for i := range u {
-					u[i] = rand.NormFloat64()
+					u[i] = rnd.NormFloat64()
 				}
 				uCopy := make([]float64, len(u))
 				copy(uCopy, u)
 				vt := make([]float64, n*ldvt)
 				for i := range vt {
-					vt[i] = rand.NormFloat64()
+					vt[i] = rnd.NormFloat64()
 				}
 				vtCopy := make([]float64, len(vt))
 				copy(vtCopy, vt)
 				c := make([]float64, n*ldc)
 				for i := range c {
-					c[i] = rand.NormFloat64()
+					c[i] = rnd.NormFloat64()
 				}
 				cCopy := make([]float64, len(c))
 				copy(cCopy, c)

testlapack/dgebd2.go

@@ -14,6 +14,7 @@ type Dgebd2er interface {
 }
 
 func Dgebd2Test(t *testing.T, impl Dgebd2er) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, lda int
 	}{
@@ -31,7 +32,7 @@ func Dgebd2Test(t *testing.T, impl Dgebd2er) {
 		nb := min(m, n) // 'nb' name parallel with Dlabrd code.
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.NormFloat64()
+			a[i] = rnd.NormFloat64()
 		}
 		d := nanSlice(nb)
 		e := nanSlice(nb - 1)

testlapack/dgebrd.go

@@ -18,6 +18,7 @@ type Dgebrder interface {
 }
 
 func DgebrdTest(t *testing.T, impl Dgebrder) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, lda int
 	}{
@@ -44,7 +45,7 @@ func DgebrdTest(t *testing.T, impl Dgebrder) {
 		minmn := min(m, n)
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.NormFloat64()
+			a[i] = rnd.NormFloat64()
 		}
 
 		d := make([]float64, minmn)

testlapack/dgelq2.go

@@ -19,6 +19,7 @@ type Dgelq2er interface {
 }
 
 func Dgelq2Test(t *testing.T, impl Dgelq2er) {
+	rnd := rand.New(rand.NewSource(1))
 	for c, test := range []struct {
 		m, n, lda int
 	}{
@@ -52,15 +53,15 @@ func Dgelq2Test(t *testing.T, impl Dgelq2er) {
 		k := min(m, n)
 		tau := make([]float64, k)
 		for i := range tau {
-			tau[i] = rand.Float64()
+			tau[i] = rnd.Float64()
 		}
 		work := make([]float64, m)
 		for i := range work {
-			work[i] = rand.Float64()
+			work[i] = rnd.Float64()
 		}
 		a := make([]float64, m*lda)
 		for i := 0; i < m*lda; i++ {
-			a[i] = rand.Float64()
+			a[i] = rnd.Float64()
 		}
 		aCopy := make([]float64, len(a))
 		copy(aCopy, a)

testlapack/dgelqf.go

@@ -17,6 +17,7 @@ type Dgelqfer interface {
 }
 
 func DgelqfTest(t *testing.T, impl Dgelqfer) {
+	rnd := rand.New(rand.NewSource(1))
 	for c, test := range []struct {
 		m, n, lda int
 	}{
@@ -50,12 +51,12 @@ func DgelqfTest(t *testing.T, impl Dgelqfer) {
 		a := make([]float64, m*lda)
 		for i := 0; i < m; i++ {
 			for j := 0; j < n; j++ {
-				a[i*lda+j] = rand.Float64()
+				a[i*lda+j] = rnd.Float64()
 			}
 		}
 		tau := make([]float64, n)
 		for i := 0; i < n; i++ {
-			tau[i] = rand.Float64()
+			tau[i] = rnd.Float64()
 		}
 		aCopy := make([]float64, len(a))
 		copy(aCopy, a)
@@ -63,7 +64,7 @@ func DgelqfTest(t *testing.T, impl Dgelqfer) {
 		copy(ans, a)
 		work := make([]float64, m)
 		for i := range work {
-			work[i] = rand.Float64()
+			work[i] = rnd.Float64()
 		}
 		// Compute unblocked QR.
 		impl.Dgelq2(m, n, ans, lda, tau, work)

testlapack/dgels.go

@@ -18,6 +18,7 @@ type Dgelser interface {
 }
 
 func DgelsTest(t *testing.T, impl Dgelser) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, trans := range []blas.Transpose{blas.NoTrans, blas.Trans} {
 		for _, test := range []struct {
 			m, n, nrhs, lda, ldb int
@@ -69,7 +70,7 @@ func DgelsTest(t *testing.T, impl Dgelser) {
 			}
 			a := make([]float64, m*lda)
 			for i := range a {
-				a[i] = rand.Float64()
+				a[i] = rnd.Float64()
 			}
 			aCopy := make([]float64, len(a))
 			copy(aCopy, a)
@@ -84,7 +85,7 @@ func DgelsTest(t *testing.T, impl Dgelser) {
 			}
 			b := make([]float64, mb*ldb)
 			for i := range b {
-				b[i] = rand.Float64()
+				b[i] = rnd.Float64()
 			}
 			bCopy := make([]float64, len(b))
 			copy(bCopy, b)
@@ -97,7 +98,7 @@ func DgelsTest(t *testing.T, impl Dgelser) {
 			work = make([]float64, int(work[0]))
 			lwork := len(work)
 			for i := range work {
-				work[i] = rand.Float64()
+				work[i] = rnd.Float64()
 			}
 			impl.Dgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork)
 

testlapack/dgeql2.go

@@ -18,6 +18,7 @@ type Dgeql2er interface {
 }
 
 func Dgeql2Test(t *testing.T, impl Dgeql2er) {
+	rnd := rand.New(rand.NewSource(1))
 	// TODO(btracey): Add tests for m < n.
 	for _, test := range []struct {
 		m, n, lda int
@@ -34,7 +35,7 @@ func Dgeql2Test(t *testing.T, impl Dgeql2er) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.NormFloat64()
+			a[i] = rnd.NormFloat64()
 		}
 		tau := nanSlice(min(m, n))
 		work := nanSlice(n)

testlapack/dgeqr2.go

@@ -19,6 +19,7 @@ type Dgeqr2er interface {
 }
 
 func Dgeqr2Test(t *testing.T, impl Dgeqr2er) {
+	rnd := rand.New(rand.NewSource(1))
 	for c, test := range []struct {
 		m, n, lda int
 	}{
@@ -51,17 +52,17 @@ func Dgeqr2Test(t *testing.T, impl Dgeqr2er) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.Float64()
+			a[i] = rnd.Float64()
 		}
 		aCopy := make([]float64, len(a))
 		k := min(m, n)
 		tau := make([]float64, k)
 		for i := range tau {
-			tau[i] = rand.Float64()
+			tau[i] = rnd.Float64()
 		}
 		work := make([]float64, n)
 		for i := range work {
-			work[i] = rand.Float64()
+			work[i] = rnd.Float64()
 		}
 		copy(aCopy, a)
 		impl.Dgeqr2(m, n, a, lda, tau, work)

testlapack/dgeqrf.go

@@ -17,6 +17,7 @@ type Dgeqrfer interface {
 }
 
 func DgeqrfTest(t *testing.T, impl Dgeqrfer) {
+	rnd := rand.New(rand.NewSource(1))
 	for c, test := range []struct {
 		m, n, lda int
 	}{
@@ -50,12 +51,12 @@ func DgeqrfTest(t *testing.T, impl Dgeqrfer) {
 		a := make([]float64, m*lda)
 		for i := 0; i < m; i++ {
 			for j := 0; j < n; j++ {
-				a[i*lda+j] = rand.Float64()
+				a[i*lda+j] = rnd.Float64()
 			}
 		}
 		tau := make([]float64, n)
 		for i := 0; i < n; i++ {
-			tau[i] = rand.Float64()
+			tau[i] = rnd.Float64()
 		}
 		aCopy := make([]float64, len(a))
 		copy(aCopy, a)

testlapack/dgesvd.go

@@ -20,6 +20,7 @@ type Dgesvder interface {
 }
 
 func DgesvdTest(t *testing.T, impl Dgesvder) {
+	rnd := rand.New(rand.NewSource(1))
 	// TODO(btracey): Add tests for all of the cases when the SVD implementation
 	// is finished.
 	// TODO(btracey): Add tests for m > mnthr and n > mnthr when other SVD
@@ -73,17 +74,17 @@ func DgesvdTest(t *testing.T, impl Dgesvder) {
 
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.NormFloat64()
+			a[i] = rnd.NormFloat64()
 		}
 
 		u := make([]float64, m*ldu)
 		for i := range u {
-			u[i] = rand.NormFloat64()
+			u[i] = rnd.NormFloat64()
 		}
 
 		vt := make([]float64, n*ldvt)
 		for i := range vt {
-			vt[i] = rand.NormFloat64()
+			vt[i] = rnd.NormFloat64()
 		}
 
 		uAllOrig := make([]float64, len(u))
@@ -125,6 +126,7 @@ func DgesvdTest(t *testing.T, impl Dgesvder) {
 // svdCheckPartial checks that the singular values and vectors are computed when
 // not all of them are computed.
 func svdCheckPartial(t *testing.T, impl Dgesvder, job lapack.SVDJob, errStr string, uAllOrig, vtAllOrig, aCopy []float64, m, n int, a []float64, lda int, s, u []float64, ldu int, vt []float64, ldvt int, work []float64, shortWork bool) {
+	rnd := rand.New(rand.NewSource(1))
 	jobU := job
 	jobVT := job
 	// Compare the singular values when computed with {SVDNone, SVDNone.}
@@ -132,7 +134,7 @@ func svdCheckPartial(t *testing.T, impl Dgesvder, job lapack.SVDJob, errStr stri
 	copy(sCopy, s)
 	copy(a, aCopy)
 	for i := range s {
-		s[i] = rand.Float64()
+		s[i] = rnd.Float64()
 	}
 	tmp1 := make([]float64, 1)
 	tmp2 := make([]float64, 1)
@@ -167,7 +169,7 @@ func svdCheckPartial(t *testing.T, impl Dgesvder, job lapack.SVDJob, errStr stri
 	jobVT = lapack.SVDNone
 	copy(a, aCopy)
 	for i := range s {
-		s[i] = rand.Float64()
+		s[i] = rnd.Float64()
 	}
 	impl.Dgesvd(jobU, jobVT, m, n, a, lda, s, u, ldu, tmp2, ldvt, work, -1)
 	work = make([]float64, int(work[0]))
@@ -186,7 +188,7 @@ func svdCheckPartial(t *testing.T, impl Dgesvder, job lapack.SVDJob, errStr stri
 	jobVT = job
 	copy(a, aCopy)
 	for i := range s {
-		s[i] = rand.Float64()
+		s[i] = rnd.Float64()
 	}
 	impl.Dgesvd(jobU, jobVT, m, n, a, lda, s, tmp1, ldu, vt, ldvt, work, -1)
 	work = make([]float64, int(work[0]))
@@ -281,5 +283,4 @@ func svdCheck(t *testing.T, thin bool, errStr string, m, n int, s, a, u []float6
 			}
 		}
 	}
-
 }

testlapack/dgetf2.go

@@ -14,6 +14,7 @@ type Dgetf2er interface {
 }
 
 func Dgetf2Test(t *testing.T, impl Dgetf2er) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, lda int
 	}{
@@ -33,7 +34,7 @@ func Dgetf2Test(t *testing.T, impl Dgetf2er) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.Float64()
+			a[i] = rnd.Float64()
 		}
 		aCopy := make([]float64, len(a))
 		copy(aCopy, a)
@@ -41,7 +42,7 @@ func Dgetf2Test(t *testing.T, impl Dgetf2er) {
 		mn := min(m, n)
 		ipiv := make([]int, mn)
 		for i := range ipiv {
-			ipiv[i] = rand.Int()
+			ipiv[i] = rnd.Int()
 		}
 		ok := impl.Dgetf2(m, n, a, lda, ipiv)
 		checkPLU(t, ok, m, n, lda, ipiv, a, aCopy, 1e-14, true)

testlapack/dgetrf.go

@@ -10,6 +10,7 @@ type Dgetrfer interface {
 }
 
 func DgetrfTest(t *testing.T, impl Dgetrfer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, lda int
 	}{
@@ -42,12 +43,12 @@ func DgetrfTest(t *testing.T, impl Dgetrfer) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.Float64()
+			a[i] = rnd.Float64()
 		}
 		mn := min(m, n)
 		ipiv := make([]int, mn)
 		for i := range ipiv {
-			ipiv[i] = rand.Int()
+			ipiv[i] = rnd.Int()
 		}
 
 		// Cannot compare the outputs of Dgetrf and Dgetf2 because the pivoting may

testlapack/dgetri.go

@@ -15,6 +15,7 @@ type Dgetrier interface {
 }
 
 func DgetriTest(t *testing.T, impl Dgetrier) {
+	rnd := rand.New(rand.NewSource(1))
 	bi := blas64.Implementation()
 	for _, test := range []struct {
 		n, lda int
@@ -34,13 +35,13 @@ func DgetriTest(t *testing.T, impl Dgetrier) {
 			lda = n
 		}
 		// Generate a random well conditioned matrix
-		perm := rand.Perm(n)
+		perm := rnd.Perm(n)
 		a := make([]float64, n*lda)
 		for i := 0; i < n; i++ {
 			a[i*lda+perm[i]] = 1
 		}
 		for i := range a {
-			a[i] += 0.01 * rand.Float64()
+			a[i] += 0.01 * rnd.Float64()
 		}
 		aCopy := make([]float64, len(a))
 		copy(aCopy, a)

testlapack/dgetrs.go

@@ -15,6 +15,7 @@ type Dgetrser interface {
 }
 
 func DgetrsTest(t *testing.T, impl Dgetrser) {
+	rnd := rand.New(rand.NewSource(1))
 	// TODO(btracey): Put more thought into creating more regularized matrices
 	// and what correct tolerances should be. Consider also seeding the random
 	// number in this test to make it more robust to code changes in other
@@ -52,11 +53,11 @@ func DgetrsTest(t *testing.T, impl Dgetrser) {
 			}
 			a := make([]float64, n*lda)
 			for i := range a {
-				a[i] = rand.Float64()
+				a[i] = rnd.Float64()
 			}
 			b := make([]float64, n*ldb)
 			for i := range b {
-				b[i] = rand.Float64()
+				b[i] = rnd.Float64()
 			}
 			aCopy := make([]float64, len(a))
 			copy(aCopy, a)
@@ -65,7 +66,7 @@ func DgetrsTest(t *testing.T, impl Dgetrser) {
 
 			ipiv := make([]int, n)
 			for i := range ipiv {
-				ipiv[i] = rand.Int()
+				ipiv[i] = rnd.Int()
 			}
 
 			// Compute the LU factorization.

testlapack/dlabrd.go

@@ -15,6 +15,7 @@ type Dlabrder interface {
 }
 
 func DlabrdTest(t *testing.T, impl Dlabrder) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, nb, lda, ldx, ldy int
 	}{
@@ -63,7 +64,7 @@ func DlabrdTest(t *testing.T, impl Dlabrder) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.NormFloat64()
+			a[i] = rnd.NormFloat64()
 		}
 		d := make([]float64, nb)
 		for i := range d {
@@ -83,11 +84,11 @@ func DlabrdTest(t *testing.T, impl Dlabrder) {
 		}
 		x := make([]float64, m*ldx)
 		for i := range x {
-			x[i] = rand.NormFloat64()
+			x[i] = rnd.NormFloat64()
 		}
 		y := make([]float64, n*ldy)
 		for i := range y {
-			y[i] = rand.NormFloat64()
+			y[i] = rnd.NormFloat64()
 		}
 		aCopy := make([]float64, len(a))
 		copy(aCopy, a)

testlapack/dlacpy.go

@@ -13,6 +13,7 @@ type Dlacpyer interface {
 }
 
 func DlacpyTest(t *testing.T, impl Dlacpyer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower, blas.All} {
 		for _, test := range []struct {
 			m, n, lda, ldb int
@@ -37,11 +38,11 @@ func DlacpyTest(t *testing.T, impl Dlacpyer) {
 			}
 			a := make([]float64, m*lda)
 			for i := range a {
-				a[i] = rand.Float64()
+				a[i] = rnd.Float64()
 			}
 			b := make([]float64, m*ldb)
 			for i := range b {
-				b[i] = rand.Float64()
+				b[i] = rnd.Float64()
 			}
 			impl.Dlacpy(uplo, m, n, a, lda, b, ldb)
 			equal := true

testlapack/dlaev2.go

@@ -11,10 +11,11 @@ type Dlaev2er interface {
 }
 
 func Dlaev2Test(t *testing.T, impl Dlaev2er) {
+	rnd := rand.New(rand.NewSource(1))
 	for trial := 0; trial < 100; trial++ {
-		a := rand.NormFloat64()
+		a := rnd.NormFloat64()
-		b := rand.NormFloat64()
+		b := rnd.NormFloat64()
-		c := rand.NormFloat64()
+		c := rnd.NormFloat64()
 
 		rt1, rt2, cs1, sn1 := impl.Dlaev2(a, b, c)
 		tmp := mul2by2([2][2]float64{{cs1, sn1}, {-sn1, cs1}}, [2][2]float64{{a, b}, {b, c}})

testlapack/dlange.go

@@ -18,6 +18,7 @@ type Dlanger interface {
 }
 
 func DlangeTest(t *testing.T, impl Dlanger) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, lda int
 	}{
@@ -34,11 +35,11 @@ func DlangeTest(t *testing.T, impl Dlanger) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = (rand.Float64() - 0.5)
+			a[i] = rnd.Float64() - 0.5
 		}
 		work := make([]float64, n)
 		for i := range work {
-			work[i] = rand.Float64()
+			work[i] = rnd.Float64()
 		}
 		aCopy := make([]float64, len(a))
 		copy(aCopy, a)

testlapack/dlanst.go

@@ -18,16 +18,17 @@ type Dlanster interface {
 }
 
 func DlanstTest(t *testing.T, impl Dlanster) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, norm := range []lapack.MatrixNorm{lapack.MaxAbs, lapack.MaxColumnSum, lapack.MaxRowSum, lapack.NormFrob} {
 		for _, n := range []int{1, 3, 10, 100} {
 			for cas := 0; cas < 100; cas++ {
 				d := make([]float64, n)
 				for i := range d {
-					d[i] = rand.NormFloat64()
+					d[i] = rnd.NormFloat64()
 				}
 				e := make([]float64, n-1)
 				for i := range e {
-					e[i] = rand.NormFloat64()
+					e[i] = rnd.NormFloat64()
 				}
 
 				m := n

testlapack/dlansy.go

@@ -15,6 +15,7 @@ type Dlansyer interface {
 }
 
 func DlansyTest(t *testing.T, impl Dlansyer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, norm := range []lapack.MatrixNorm{lapack.MaxAbs, lapack.MaxColumnSum, lapack.MaxRowSum, lapack.NormFrob} {
 		for _, uplo := range []blas.Uplo{blas.Lower, blas.Upper} {
 			for _, test := range []struct {
@@ -39,7 +40,7 @@ func DlansyTest(t *testing.T, impl Dlansyer) {
 						}
 					} else {
 						for i := range a {
-							a[i] = rand.NormFloat64()
+							a[i] = rnd.NormFloat64()
 						}
 					}
 

testlapack/dlantr.go

@@ -15,6 +15,7 @@ type Dlantrer interface {
 }
 
 func DlantrTest(t *testing.T, impl Dlantrer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, norm := range []lapack.MatrixNorm{lapack.MaxAbs, lapack.MaxColumnSum, lapack.MaxRowSum, lapack.NormFrob} {
 		for _, diag := range []blas.Diag{blas.NonUnit, blas.Unit} {
 			for _, uplo := range []blas.Uplo{blas.Lower, blas.Upper} {
@@ -44,7 +45,7 @@ func DlantrTest(t *testing.T, impl Dlantrer) {
 							}
 						} else {
 							for i := range a {
-								a[i] = rand.NormFloat64()
+								a[i] = rnd.NormFloat64()
 							}
 						}
 						aDense := make([]float64, len(a))
@@ -68,7 +69,7 @@ func DlantrTest(t *testing.T, impl Dlantrer) {
 						}
 						work := make([]float64, n+6)
 						for i := range work {
-							work[i] = rand.Float64()
+							work[i] = rnd.Float64()
 						}
 						got := impl.Dlantr(norm, uplo, diag, m, n, a, lda, work)
 						want := impl.Dlange(norm, m, n, aDense, lda, work)

testlapack/dlarf.go

@@ -18,6 +18,7 @@ type Dlarfer interface {
 }
 
 func DlarfTest(t *testing.T, impl Dlarfer) {
+	rnd := rand.New(rand.NewSource(1))
 	for i, test := range []struct {
 		m, n, ldc    int
 		incv, lastv  int
@@ -94,7 +95,7 @@ func DlarfTest(t *testing.T, impl Dlarfer) {
 		c := make([]float64, test.ldc*test.m)
 		for i := 0; i <= test.lastr; i++ {
 			for j := 0; j <= test.lastc; j++ {
-				c[i*test.ldc+j] = rand.Float64()
+				c[i*test.ldc+j] = rnd.Float64()
 			}
 		}
 		cCopy := make([]float64, len(c))
@@ -107,7 +108,7 @@ func DlarfTest(t *testing.T, impl Dlarfer) {
 		v := make([]float64, test.incv*sz+1)
 		// Fill with nonzero entries up until lastv.
 		for i := 0; i <= test.lastv; i++ {
-			v[i*test.incv] = rand.Float64()
+			v[i*test.incv] = rnd.Float64()
 		}
 		// Construct h explicitly to compare.
 		h := make([]float64, test.n*test.n)

testlapack/dlarfb.go

@@ -22,6 +22,7 @@ type Dlarfber interface {
 }
 
 func DlarfbTest(t *testing.T, impl Dlarfber) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, store := range []lapack.StoreV{lapack.ColumnWise, lapack.RowWise} {
 		for _, direct := range []lapack.Direct{lapack.Forward, lapack.Backward} {
 			for _, side := range []blas.Side{blas.Left, blas.Right} {
@@ -61,7 +62,7 @@ func DlarfbTest(t *testing.T, impl Dlarfber) {
 						a := make([]float64, ma*lda)
 						for i := 0; i < ma; i++ {
 							for j := 0; j < lda; j++ {
-								a[i*lda+j] = rand.Float64()
+								a[i*lda+j] = rnd.Float64()
 							}
 						}
 						k := min(ma, na)
@@ -109,7 +110,7 @@ func DlarfbTest(t *testing.T, impl Dlarfber) {
 						c := make([]float64, m*ldc)
 						for i := 0; i < m; i++ {
 							for j := 0; j < ldc; j++ {
-								c[i*ldc+j] = rand.Float64()
+								c[i*ldc+j] = rnd.Float64()
 							}
 						}
 						cCopy := make([]float64, len(c))

testlapack/dlarfg.go

@@ -18,6 +18,7 @@ type Dlarfger interface {
 }
 
 func DlarfgTest(t *testing.T, impl Dlarfger) {
+	rnd := rand.New(rand.NewSource(1))
 	for i, test := range []struct {
 		alpha float64
 		n     int
@@ -51,7 +52,7 @@ func DlarfgTest(t *testing.T, impl Dlarfger) {
 		if test.x == nil {
 			x = make([]float64, n-1)
 			for i := range x {
-				x[i] = rand.Float64()
+				x[i] = rnd.Float64()
 			}
 		} else {
 			x = make([]float64, n-1)

testlapack/dlarft.go

@@ -20,6 +20,7 @@ type Dlarfter interface {
 }
 
 func DlarftTest(t *testing.T, impl Dlarfter) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, store := range []lapack.StoreV{lapack.ColumnWise, lapack.RowWise} {
 		for _, direct := range []lapack.Direct{lapack.Forward, lapack.Backward} {
 			for _, test := range []struct {
@@ -46,7 +47,7 @@ func DlarftTest(t *testing.T, impl Dlarfter) {
 				a := make([]float64, m*lda)
 				for i := 0; i < m; i++ {
 					for j := 0; j < lda; j++ {
-						a[i*lda+j] = rand.Float64()
+						a[i*lda+j] = rnd.Float64()
 					}
 				}
 				// Use dgeqr2 to find the v vectors
@@ -70,7 +71,7 @@ func DlarftTest(t *testing.T, impl Dlarfter) {
 				// Find T from the actual function
 				tm := make([]float64, k*ldt)
 				for i := range tm {
-					tm[i] = 100 + rand.Float64()
+					tm[i] = 100 + rnd.Float64()
 				}
 				// The v data has been put into a.
 				impl.Dlarft(direct, store, m, k, v, ldv, tau, tm, ldt)

testlapack/dlartg.go

@@ -15,9 +15,10 @@ type Dlartger interface {
 }
 
 func DlartgTest(t *testing.T, impl Dlartger) {
+	rnd := rand.New(rand.NewSource(1))
 	for i := 0; i < 100; i++ {
-		f := rand.NormFloat64()
+		f := rnd.NormFloat64()
-		g := rand.NormFloat64()
+		g := rnd.NormFloat64()
 		cs, sn, r := impl.Dlartg(f, g)
 
 		rTest := cs*f + sn*g

testlapack/dlasq1.go

@@ -28,6 +28,7 @@ type Dlasq1er interface {
 }
 
 func Dlasq1Test(t *testing.T, impl Dlasq1er) {
+	rnd := rand.New(rand.NewSource(1))
 	bi := blas64.Implementation()
 	// TODO(btracey): Increase the size of this test when we have a more numerically
 	// stable way to test the singular values.
@@ -37,13 +38,13 @@ func Dlasq1Test(t *testing.T, impl Dlasq1er) {
 		e := make([]float64, n-1)
 		for cas := 0; cas < 1; cas++ {
 			for i := range work {
-				work[i] = rand.Float64()
+				work[i] = rnd.Float64()
 			}
 			for i := range d {
-				d[i] = rand.NormFloat64() + 10
+				d[i] = rnd.NormFloat64() + 10
 			}
 			for i := range e {
-				e[i] = rand.NormFloat64()
+				e[i] = rnd.NormFloat64()
 			}
 			ldm := n
 			m := make([]float64, n*ldm)

testlapack/dlasq2.go

@@ -645,6 +645,7 @@ func Dlasq2Test(t *testing.T, impl Dlasq2er) {
 		}
 	}
 
+	rnd := rand.New(rand.NewSource(1))
 	// Perform a bunch of random tests to check for access out of bounds or
 	// infinite loops.
 	// TODO(btracey): Implement direct tests.
@@ -653,7 +654,7 @@ func Dlasq2Test(t *testing.T, impl Dlasq2er) {
 		for k := 0; k < 10; k++ {
 			z := make([]float64, 4*n)
 			for i := range z {
-				z[i] = rand.Float64()
+				z[i] = rnd.Float64()
 			}
 			zCopy := make([]float64, len(z))
 			copy(zCopy, z)

testlapack/dlasr.go

@@ -20,6 +20,7 @@ type Dlasrer interface {
 }
 
 func DlasrTest(t *testing.T, impl Dlasrer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, side := range []blas.Side{blas.Left, blas.Right} {
 		for _, pivot := range []lapack.Pivot{lapack.Variable, lapack.Top, lapack.Bottom} {
 			for _, direct := range []lapack.Direct{lapack.Forward, lapack.Backward} {
@@ -42,7 +43,7 @@ func DlasrTest(t *testing.T, impl Dlasrer) {
 					}
 					a := make([]float64, m*lda)
 					for i := range a {
-						a[i] = rand.Float64()
+						a[i] = rnd.Float64()
 					}
 					var s, c []float64
 					if side == blas.Left {
@@ -53,7 +54,7 @@ func DlasrTest(t *testing.T, impl Dlasrer) {
 						c = make([]float64, n-1)
 					}
 					for k := range s {
-						theta := rand.Float64() * 2 * math.Pi
+						theta := rnd.Float64() * 2 * math.Pi
 						s[k] = math.Sin(theta)
 						c[k] = math.Cos(theta)
 					}

testlapack/dlasv2.go

@@ -16,10 +16,11 @@ type Dlasv2er interface {
 }
 
 func Dlasv2Test(t *testing.T, impl Dlasv2er) {
+	rnd := rand.New(rand.NewSource(1))
 	for i := 0; i < 100; i++ {
-		f := rand.NormFloat64()
+		f := rnd.NormFloat64()
-		g := rand.NormFloat64()
+		g := rnd.NormFloat64()
-		h := rand.NormFloat64()
+		h := rnd.NormFloat64()
 
 		ssmin, ssmax, snr, csr, snl, csl := impl.Dlasv2(f, g, h)
 

testlapack/dlatrd.go

@@ -19,6 +19,7 @@ type Dlatrder interface {
 }
 
 func DlatrdTest(t *testing.T, impl Dlatrder) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
 		for _, test := range []struct {
 			n, nb, lda, ldw int
@@ -42,7 +43,7 @@ func DlatrdTest(t *testing.T, impl Dlatrder) {
 
 			a := make([]float64, n*lda)
 			for i := range a {
-				a[i] = rand.NormFloat64()
+				a[i] = rnd.NormFloat64()
 			}
 
 			e := make([]float64, n-1)

testlapack/dorg2l.go

@@ -18,6 +18,7 @@ type Dorg2ler interface {
 }
 
 func Dorg2lTest(t *testing.T, impl Dorg2ler) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, k, lda int
 	}{
@@ -36,7 +37,7 @@ func Dorg2lTest(t *testing.T, impl Dorg2ler) {
 
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.NormFloat64()
+			a[i] = rnd.NormFloat64()
 		}
 		tau := nanSlice(max(m, n))
 		work := make([]float64, n)

testlapack/dorg2r.go

@@ -18,6 +18,7 @@ type Dorg2rer interface {
 }
 
 func Dorg2rTest(t *testing.T, impl Dorg2rer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, k, lda int
 	}{
@@ -39,7 +40,7 @@ func Dorg2rTest(t *testing.T, impl Dorg2rer) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.NormFloat64()
+			a[i] = rnd.NormFloat64()
 		}
 		k := min(m, n)
 		tau := make([]float64, k)

testlapack/dorgbr.go

@@ -19,6 +19,7 @@ type Dorgbrer interface {
 }
 
 func DorgbrTest(t *testing.T, impl Dorgbrer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, vect := range []lapack.DecompUpdate{lapack.ApplyQ, lapack.ApplyP} {
 		for _, test := range []struct {
 			m, n, k, lda int
@@ -89,7 +90,7 @@ func DorgbrTest(t *testing.T, impl Dorgbrer) {
 				a = make([]float64, n*lda)
 			}
 			for i := range a {
-				a[i] = rand.NormFloat64()
+				a[i] = rnd.NormFloat64()
 			}
 
 			nTau := min(ma, na)

testlapack/dorgl2.go

@@ -17,6 +17,7 @@ type Dorgl2er interface {
 }
 
 func Dorgl2Test(t *testing.T, impl Dorgl2er) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, lda int
 	}{
@@ -34,7 +35,7 @@ func Dorgl2Test(t *testing.T, impl Dorgl2er) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.NormFloat64()
+			a[i] = rnd.NormFloat64()
 		}
 		k := min(m, n)
 		tau := make([]float64, k)

testlapack/dorglq.go

@@ -18,6 +18,7 @@ type Dorglqer interface {
 }
 
 func DorglqTest(t *testing.T, impl Dorglqer) {
+	rnd := rand.New(rand.NewSource(1))
 	// TODO(btracey): Base tests off of nb and nx.
 	for _, test := range []struct{ m, n, k, lda int }{
 		{10, 10, 10, 0},
@@ -52,7 +53,7 @@ func DorglqTest(t *testing.T, impl Dorglqer) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.Float64()
+			a[i] = rnd.Float64()
 		}
 		work := make([]float64, 1)
 		tau := make([]float64, m)

testlapack/dorgql.go

@@ -17,6 +17,7 @@ type Dorgqler interface {
 }
 
 func DorgqlTest(t *testing.T, impl Dorgqler) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, test := range []struct {
 		m, n, k, lda int
 	}{
@@ -34,7 +35,7 @@ func DorgqlTest(t *testing.T, impl Dorgqler) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.NormFloat64()
+			a[i] = rnd.NormFloat64()
 		}
 		tau := nanSlice(min(m, n))
 		work := nanSlice(max(m, n))

testlapack/dorgqr.go

@@ -18,6 +18,7 @@ type Dorgqrer interface {
 }
 
 func DorgqrTest(t *testing.T, impl Dorgqrer) {
+	rnd := rand.New(rand.NewSource(1))
 	// TODO(btracey): Base tests off of nb and nx.
 	for _, test := range []struct{ m, n, k, lda int }{
 		{10, 10, 10, 0},
@@ -52,7 +53,7 @@ func DorgqrTest(t *testing.T, impl Dorgqrer) {
 		}
 		a := make([]float64, m*lda)
 		for i := range a {
-			a[i] = rand.Float64()
+			a[i] = rnd.Float64()
 		}
 		work := make([]float64, 1)
 		tau := make([]float64, n)

testlapack/dorgtr.go

@@ -20,6 +20,7 @@ type Dorgtrer interface {
 }
 
 func DorgtrTest(t *testing.T, impl Dorgtrer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
 		for _, test := range []struct {
 			n, lda int
@@ -39,7 +40,7 @@ func DorgtrTest(t *testing.T, impl Dorgtrer) {
 			}
 			a := make([]float64, n*lda)
 			for i := range a {
-				a[i] = rand.NormFloat64()
+				a[i] = rnd.NormFloat64()
 			}
 			aCopy := make([]float64, len(a))
 			copy(aCopy, a)

testlapack/dorm2r.go

@@ -19,6 +19,7 @@ type Dorm2rer interface {
 }
 
 func Dorm2rTest(t *testing.T, impl Dorm2rer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, side := range []blas.Side{blas.Left, blas.Right} {
 		for _, trans := range []blas.Transpose{blas.NoTrans, blas.Trans} {
 			for _, test := range []struct {
@@ -63,7 +64,7 @@ func Dorm2rTest(t *testing.T, impl Dorm2rer) {
 				}
 				a := make([]float64, ma*lda)
 				for i := range a {
-					a[i] = rand.Float64()
+					a[i] = rnd.Float64()
 				}
 				ldc := test.ldc
 				if ldc == 0 {
@@ -72,7 +73,7 @@ func Dorm2rTest(t *testing.T, impl Dorm2rer) {
 				// Compute random C matrix
 				c := make([]float64, mc*ldc)
 				for i := range c {
-					c[i] = rand.Float64()
+					c[i] = rnd.Float64()
 				}
 
 				// Compute QR

testlapack/dormbr.go

@@ -20,6 +20,7 @@ type Dormbrer interface {
 }
 
 func DormbrTest(t *testing.T, impl Dormbrer) {
+	rnd := rand.New(rand.NewSource(1))
 	bi := blas64.Implementation()
 	for _, vect := range []lapack.DecompUpdate{lapack.ApplyQ, lapack.ApplyP} {
 		for _, side := range []blas.Side{blas.Left, blas.Right} {
@@ -69,7 +70,7 @@ func DormbrTest(t *testing.T, impl Dormbrer) {
 					}
 					a = make([]float64, ma*lda)
 					for i := range a {
-						a[i] = rand.NormFloat64()
+						a[i] = rnd.NormFloat64()
 					}
 					nTau := min(nq, k)
 					tauP := make([]float64, nTau)
@@ -87,7 +88,7 @@ func DormbrTest(t *testing.T, impl Dormbrer) {
 					// Apply and compare update.
 					c := make([]float64, m*ldc)
 					for i := range c {
-						c[i] = rand.NormFloat64()
+						c[i] = rnd.NormFloat64()
 					}
 
 					cCopy := make([]float64, len(c))

testlapack/dorml2.go

@@ -19,6 +19,7 @@ type Dorml2er interface {
 }
 
 func Dorml2Test(t *testing.T, impl Dorml2er) {
+	rnd := rand.New(rand.NewSource(1))
 	// TODO(btracey): This test is not complete, because it
 	// doesn't test individual values of m, n, and k, instead only testing
 	// a specific subset of possible k values.
@@ -66,7 +67,7 @@ func Dorml2Test(t *testing.T, impl Dorml2er) {
 				}
 				a := make([]float64, ma*lda)
 				for i := range a {
-					a[i] = rand.Float64()
+					a[i] = rnd.Float64()
 				}
 				ldc := test.ldc
 				if ldc == 0 {
@@ -75,7 +76,7 @@ func Dorml2Test(t *testing.T, impl Dorml2er) {
 				// Compute random C matrix
 				c := make([]float64, mc*ldc)
 				for i := range c {
-					c[i] = rand.Float64()
+					c[i] = rnd.Float64()
 				}
 
 				// Compute LQ

testlapack/dormlq.go

@@ -19,6 +19,7 @@ type Dormlqer interface {
 }
 
 func DormlqTest(t *testing.T, impl Dormlqer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, side := range []blas.Side{blas.Left, blas.Right} {
 		for _, trans := range []blas.Transpose{blas.NoTrans, blas.Trans} {
 			for _, test := range []struct {
@@ -68,7 +69,7 @@ func DormlqTest(t *testing.T, impl Dormlqer) {
 				}
 				a := make([]float64, ma*lda)
 				for i := range a {
-					a[i] = rand.Float64()
+					a[i] = rnd.Float64()
 				}
 				// Compute random C matrix
 				ldc := test.ldc
@@ -77,7 +78,7 @@ func DormlqTest(t *testing.T, impl Dormlqer) {
 				}
 				c := make([]float64, mc*ldc)
 				for i := range c {
-					c[i] = rand.Float64()
+					c[i] = rnd.Float64()
 				}
 
 				// Compute LQ
@@ -102,7 +103,7 @@ func DormlqTest(t *testing.T, impl Dormlqer) {
 
 				// Make sure Dorml2 and Dormlq match with small work
 				for i := range work {
-					work[i] = rand.Float64()
+					work[i] = rnd.Float64()
 				}
 				lwork := len(work)
 				copy(c, cCopy)
@@ -117,7 +118,7 @@ func DormlqTest(t *testing.T, impl Dormlqer) {
 				work = make([]float64, int(work[0]))
 				lwork = len(work)
 				for i := range work {
-					work[i] = rand.Float64()
+					work[i] = rnd.Float64()
 				}
 				impl.Dormlq(side, trans, mc, nc, k, a, lda, tau, c, ldc, work, lwork)
 				if !floats.EqualApprox(c, ans, 1e-12) {

testlapack/dormqr.go

@@ -19,6 +19,7 @@ type Dormqrer interface {
 }
 
 func DormqrTest(t *testing.T, impl Dormqrer) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, side := range []blas.Side{blas.Left, blas.Right} {
 		for _, trans := range []blas.Transpose{blas.NoTrans, blas.Trans} {
 			for _, test := range []struct {
@@ -68,7 +69,7 @@ func DormqrTest(t *testing.T, impl Dormqrer) {
 				}
 				a := make([]float64, ma*lda)
 				for i := range a {
-					a[i] = rand.Float64()
+					a[i] = rnd.Float64()
 				}
 				// Compute random C matrix
 				ldc := test.ldc
@@ -77,7 +78,7 @@ func DormqrTest(t *testing.T, impl Dormqrer) {
 				}
 				c := make([]float64, mc*ldc)
 				for i := range c {
-					c[i] = rand.Float64()
+					c[i] = rnd.Float64()
 				}
 
 				// Compute QR
@@ -102,7 +103,7 @@ func DormqrTest(t *testing.T, impl Dormqrer) {
 
 				// Make sure Dorm2r and Dormqr match with small work
 				for i := range work {
-					work[i] = rand.Float64()
+					work[i] = rnd.Float64()
 				}
 				lwork := len(work)
 				copy(c, cCopy)
@@ -117,7 +118,7 @@ func DormqrTest(t *testing.T, impl Dormqrer) {
 				work = make([]float64, int(work[0]))
 				lwork = len(work)
 				for i := range work {
-					work[i] = rand.Float64()
+					work[i] = rnd.Float64()
 				}
 				_ = lwork
 				impl.Dormqr(side, trans, mc, nc, k, a, lda, tau, c, ldc, work, lwork)

testlapack/dpocon.go

@@ -79,6 +79,7 @@ func DpoconTest(t *testing.T, impl Dpoconer) {
 			log.Printf("Dpocon cond mismatch. Want %v, got %v.", test.cond, cond)
 		}
 	}
+	rnd := rand.New(rand.NewSource(1))
 	bi := blas64.Implementation()
 	// Randomized tests compared against Dgecon.
 	for _, uplo := range []blas.Uplo{blas.Lower, blas.Upper} {
@@ -96,7 +97,7 @@ func DpoconTest(t *testing.T, impl Dpoconer) {
 				}
 				a := make([]float64, n*lda)
 				for i := range a {
-					a[i] = rand.NormFloat64()
+					a[i] = rnd.NormFloat64()
 				}
 
 				// Multiply a by itself to make it symmetric positive definite.

testlapack/dpotrf.go

@@ -18,6 +18,7 @@ type Dpotrfer interface {
 }
 
 func DpotrfTest(t *testing.T, impl Dpotrfer) {
+	rnd := rand.New(rand.NewSource(1))
 	bi := blas64.Implementation()
 	for i, test := range []struct {
 		n int
@@ -33,7 +34,7 @@ func DpotrfTest(t *testing.T, impl Dpotrfer) {
 		// Construct a positive-definite symmetric matrix
 		base := make([]float64, n*n)
 		for i := range base {
-			base[i] = rand.Float64()
+			base[i] = rnd.Float64()
 		}
 		a := make([]float64, len(base))
 		bi.Dgemm(blas.Trans, blas.NoTrans, n, n, n, 1, base, n, base, n, 0, a, n)

testlapack/dsterf.go

@@ -53,18 +53,19 @@ func DsterfTest(t *testing.T, impl Dsterfer) {
 		}
 	}
 
+	rnd := rand.New(rand.NewSource(1))
 	// Probabilistic tests.
 	for _, n := range []int{4, 6, 10} {
 		for cas := 0; cas < 10; cas++ {
 			d := make([]float64, n)
 			for i := range d {
-				d[i] = rand.NormFloat64()
+				d[i] = rnd.NormFloat64()
 			}
 			dCopy := make([]float64, len(d))
 			copy(dCopy, d)
 			e := make([]float64, n-1)
 			for i := range e {
-				e[i] = rand.NormFloat64()
+				e[i] = rnd.NormFloat64()
 			}
 			eCopy := make([]float64, len(e))
 			copy(eCopy, e)

testlapack/dsytd2.go

@@ -18,6 +18,7 @@ type Dsytd2er interface {
 }
 
 func Dsytd2Test(t *testing.T, impl Dsytd2er) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
 		for _, test := range []struct {
 			n, lda int
@@ -37,7 +38,7 @@ func Dsytd2Test(t *testing.T, impl Dsytd2er) {
 			}
 			a := make([]float64, n*lda)
 			for i := range a {
-				a[i] = rand.NormFloat64()
+				a[i] = rnd.NormFloat64()
 			}
 			aCopy := make([]float64, len(a))
 			copy(aCopy, a)

testlapack/dsytrd.go

@@ -19,6 +19,7 @@ type Dsytrder interface {
 }
 
 func DsytrdTest(t *testing.T, impl Dsytrder) {
+	rnd := rand.New(rand.NewSource(1))
 	for _, uplo := range []blas.Uplo{blas.Upper} {
 		for _, test := range []struct {
 			n, lda int
@@ -42,7 +43,7 @@ func DsytrdTest(t *testing.T, impl Dsytrder) {
 			}
 			a := make([]float64, n*lda)
 			for i := range a {
-				a[i] = rand.NormFloat64()
+				a[i] = rnd.NormFloat64()
 			}
 			d2 := make([]float64, n)
 			e2 := make([]float64, n)

testlapack/dtrcon.go

@@ -16,6 +16,7 @@ type Dtrconer interface {
 }
 
 func DtrconTest(t *testing.T, impl Dtrconer) {
+	rnd := rand.New(rand.NewSource(1))
 	// Hand crafted tests.
 	for _, test := range []struct {
 		a       []float64
@@ -77,11 +78,11 @@ func DtrconTest(t *testing.T, impl Dtrconer) {
 		lda := test.n
 		work := make([]float64, 3*test.n)
 		for i := range work {
-			work[i] = rand.Float64()
+			work[i] = rnd.Float64()
 		}
 		iwork := make([]int, test.n)
 		for i := range iwork {
-			iwork[i] = rand.Int()
+			iwork[i] = rnd.Int()
 		}
 		aCopy := make([]float64, len(test.a))
 		copy(aCopy, test.a)
@@ -128,7 +129,7 @@ func DtrconTest(t *testing.T, impl Dtrconer) {
 							}
 						} else {
 							for i := range a {
-								a[i] = rand.NormFloat64()
+								a[i] = rnd.NormFloat64()
 							}
 						}
 

testlapack/dtrti2.go

@@ -84,6 +84,7 @@ func Dtrti2Test(t *testing.T, impl Dtrti2er) {
 			t.Errorf("Matrix inverse mismatch. Want %v, got %v.", test.ans, test.a)
 		}
 	}
+	rnd := rand.New(rand.NewSource(1))
 	bi := blas64.Implementation()
 	for _, uplo := range []blas.Uplo{blas.Upper} {
 		for _, diag := range []blas.Diag{blas.NonUnit, blas.Unit} {
@@ -100,7 +101,7 @@ func Dtrti2Test(t *testing.T, impl Dtrti2er) {
 				}
 				a := make([]float64, n*lda)
 				for i := range a {
-					a[i] = rand.Float64()
+					a[i] = rnd.Float64()
 				}
 				aCopy := make([]float64, len(a))
 				copy(aCopy, a)

testlapack/dtrtri.go

@@ -15,6 +15,7 @@ type Dtrtrier interface {
 }
 
 func DtrtriTest(t *testing.T, impl Dtrtrier) {
+	rnd := rand.New(rand.NewSource(1))
 	bi := blas64.Implementation()
 	for _, uplo := range []blas.Uplo{blas.Upper} {
 		for _, diag := range []blas.Diag{blas.NonUnit, blas.Unit} {
@@ -35,7 +36,7 @@ func DtrtriTest(t *testing.T, impl Dtrtrier) {
 				}
 				a := make([]float64, n*lda)
 				for i := range a {
-					a[i] = rand.Float64() + 1 // This keeps the matrices well conditioned.
+					a[i] = rnd.Float64() + 1 // This keeps the matrices well conditioned.
 				}
 				aCopy := make([]float64, len(a))
 				copy(aCopy, a)