--- /dev/null
+// Copyright ©2015 The Gonum 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 f64
+
+import (
+ "math"
+ "testing"
+
+ "golang.org/x/exp/rand"
+)
+
+var (
+ nan = math.NaN()
+ inf = math.Inf(1)
+)
+
+// newGuardedVector allocates a new slice and returns it as three subslices.
+// v is a strided vector that contains elements of data at indices i*inc and
+// NaN elsewhere. frontGuard and backGuard are filled with NaN values, and
+// their backing arrays are directly adjacent to v in memory. The three slices
+// can be used to detect invalid memory reads and writes.
+func newGuardedVector(data []float64, inc int) (v, frontGuard, backGuard []float64) {
+ if inc < 0 {
+ inc = -inc
+ }
+ guard := 2 * inc
+ size := (len(data)-1)*inc + 1
+ whole := make([]float64, size+2*guard)
+ v = whole[guard : len(whole)-guard]
+ for i := range whole {
+ whole[i] = math.NaN()
+ }
+ for i, d := range data {
+ v[i*inc] = d
+ }
+ return v, whole[:guard], whole[len(whole)-guard:]
+}
+
+// allNaN returns true if x contains only NaN values, and false otherwise.
+func allNaN(x []float64) bool {
+ for _, v := range x {
+ if !math.IsNaN(v) {
+ return false
+ }
+ }
+ return true
+}
+
+// equalStrided returns true if the strided vector x contains elements of the
+// dense vector ref at indices i*inc, false otherwise.
+func equalStrided(ref, x []float64, inc int) bool {
+ if inc < 0 {
+ inc = -inc
+ }
+ for i, v := range ref {
+ if !same(x[i*inc], v) {
+ return false
+ }
+ }
+ return true
+}
+
+// nonStridedWrite returns false if all elements of x at non-stride indices are
+// equal to NaN, true otherwise.
+func nonStridedWrite(x []float64, inc int) bool {
+ if inc < 0 {
+ inc = -inc
+ }
+ for i, v := range x {
+ if i%inc != 0 && !math.IsNaN(v) {
+ return true
+ }
+ }
+ return false
+}
+
+// guardVector copies the source vector (vec) into a new slice with guards.
+// Guards guarded[:gdLn] and guarded[len-gdLn:] will be filled with sigil value gdVal.
+func guardVector(vec []float64, gdVal float64, gdLn int) (guarded []float64) {
+ guarded = make([]float64, len(vec)+gdLn*2)
+ copy(guarded[gdLn:], vec)
+ for i := 0; i < gdLn; i++ {
+ guarded[i] = gdVal
+ guarded[len(guarded)-1-i] = gdVal
+ }
+ return guarded
+}
+
+// isValidGuard will test for violated guards, generated by guardVector.
+func isValidGuard(vec []float64, gdVal float64, gdLn int) bool {
+ for i := 0; i < gdLn; i++ {
+ if !same(vec[i], gdVal) || !same(vec[len(vec)-1-i], gdVal) {
+ return false
+ }
+ }
+ return true
+}
+
+// guardIncVector copies the source vector (vec) into a new incremented slice with guards.
+// End guards will be length gdLen.
+// Internal and end guards will be filled with sigil value gdVal.
+func guardIncVector(vec []float64, gdVal float64, inc, gdLen int) (guarded []float64) {
+ if inc < 0 {
+ inc = -inc
+ }
+ inrLen := len(vec) * inc
+ guarded = make([]float64, inrLen+gdLen*2)
+ for i := range guarded {
+ guarded[i] = gdVal
+ }
+ for i, v := range vec {
+ guarded[gdLen+i*inc] = v
+ }
+ return guarded
+}
+
+// checkValidIncGuard will test for violated guards, generated by guardIncVector
+func checkValidIncGuard(t *testing.T, vec []float64, gdVal float64, inc, gdLen int) {
+ srcLn := len(vec) - 2*gdLen
+ for i := range vec {
+ switch {
+ case same(vec[i], gdVal):
+ // Correct value
+ case (i-gdLen)%inc == 0 && (i-gdLen)/inc < len(vec):
+ // Ignore input values
+ case i < gdLen:
+ t.Errorf("Front guard violated at %d %v", i, vec[:gdLen])
+ case i > gdLen+srcLn:
+ t.Errorf("Back guard violated at %d %v", i-gdLen-srcLn, vec[gdLen+srcLn:])
+ default:
+ t.Errorf("Internal guard violated at %d %v", i-gdLen, vec[gdLen:gdLen+srcLn])
+ }
+ }
+}
+
+// same tests for nan-aware equality.
+func same(a, b float64) bool {
+ return a == b || (math.IsNaN(a) && math.IsNaN(b))
+}
+
+var ( // Offset sets for testing alignment handling in Unitary assembly functions.
+ align1 = []int{0, 1}
+ align2 = newIncSet(0, 1)
+ align3 = newIncToSet(0, 1)
+)
+
+type incSet struct {
+ x, y int
+}
+
+// genInc will generate all (x,y) combinations of the input increment set.
+func newIncSet(inc ...int) []incSet {
+ n := len(inc)
+ is := make([]incSet, n*n)
+ for x := range inc {
+ for y := range inc {
+ is[x*n+y] = incSet{inc[x], inc[y]}
+ }
+ }
+ return is
+}
+
+type incToSet struct {
+ dst, x, y int
+}
+
+// genIncTo will generate all (dst,x,y) combinations of the input increment set.
+func newIncToSet(inc ...int) []incToSet {
+ n := len(inc)
+ is := make([]incToSet, n*n*n)
+ for i, dst := range inc {
+ for x := range inc {
+ for y := range inc {
+ is[i*n*n+x*n+y] = incToSet{dst, inc[x], inc[y]}
+ }
+ }
+ }
+ return is
+}
+
+var benchSink []float64
+
+func randomSlice(n, inc int) []float64 {
+ if inc < 0 {
+ inc = -inc
+ }
+ x := make([]float64, (n-1)*inc+1)
+ for i := range x {
+ x[i] = rand.Float64()
+ }
+ return x
+}
+
+func randSlice(n, inc int, r *rand.Rand) []float64 {
+ if inc < 0 {
+ inc = -inc
+ }
+ x := make([]float64, (n-1)*inc+1)
+ for i := range x {
+ x[i] = r.Float64()
+ }
+ return x
+}
OSDN Git Service
