vendor/gonum.org/v1/gonum/internal/asm/c64/util_test.go

   1 // Copyright ©2017 The Gonum 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 c64
   6
   7 import (
   8         "math/cmplx"
   9         "testing"
  10 )
  11
  12 func same(x, y complex64) bool {
  13         return x == y || (cmplx.IsNaN(complex128(x)) && cmplx.IsNaN(complex128(y)))
  14 }
  15
  16 func guardVector(vec []complex64, gdVal complex64, gdLen int) (guarded []complex64) {
  17         guarded = make([]complex64, len(vec)+gdLen*2)
  18         copy(guarded[gdLen:], vec)
  19         for i := 0; i < gdLen; i++ {
  20                 guarded[i] = gdVal
  21                 guarded[len(guarded)-1-i] = gdVal
  22         }
  23         return guarded
  24 }
  25
  26 func isValidGuard(vec []complex64, gdVal complex64, gdLen int) bool {
  27         for i := 0; i < gdLen; i++ {
  28                 if !same(vec[i], gdVal) || !same(vec[len(vec)-1-i], gdVal) {
  29                         return false
  30                 }
  31         }
  32         return true
  33 }
  34
  35 func guardIncVector(vec []complex64, gdVal complex64, inc, gdLen int) (guarded []complex64) {
  36         if inc < 0 {
  37                 inc = -inc
  38         }
  39         inrLen := len(vec) * inc
  40         guarded = make([]complex64, inrLen+gdLen*2)
  41         for i := range guarded {
  42                 guarded[i] = gdVal
  43         }
  44         for i, v := range vec {
  45                 guarded[gdLen+i*inc] = v
  46         }
  47         return guarded
  48 }
  49
  50 func checkValidIncGuard(t *testing.T, vec []complex64, gdVal complex64, inc, gdLen int) {
  51         srcLen := len(vec) - 2*gdLen
  52         if inc < 0 {
  53                 srcLen = len(vec) * -inc
  54         }
  55
  56         for i := range vec {
  57                 switch {
  58                 case same(vec[i], gdVal):
  59                         // Correct value
  60                 case (i-gdLen)%inc == 0 && (i-gdLen)/inc < len(vec):
  61                         // Ignore input values
  62                 case i < gdLen:
  63                         t.Errorf("Front guard violated at %d %v", i, vec[:gdLen])
  64                 case i > gdLen+srcLen:
  65                         t.Errorf("Back guard violated at %d %v", i-gdLen-srcLen, vec[gdLen+srcLen:])
  66                 default:
  67                         t.Errorf("Internal guard violated at %d %v", i-gdLen, vec[gdLen:gdLen+srcLen])
  68                 }
  69         }
  70 }
  71
  72 var ( // Offset sets for testing alignment handling in Unitary assembly functions.
  73         align1 = []int{0, 1}
  74         align2 = newIncSet(0, 1)
  75         align3 = newIncToSet(0, 1)
  76 )
  77
  78 type incSet struct {
  79         x, y int
  80 }
  81
  82 // genInc will generate all (x,y) combinations of the input increment set.
  83 func newIncSet(inc ...int) []incSet {
  84         n := len(inc)
  85         is := make([]incSet, n*n)
  86         for x := range inc {
  87                 for y := range inc {
  88                         is[x*n+y] = incSet{inc[x], inc[y]}
  89                 }
  90         }
  91         return is
  92 }
  93
  94 type incToSet struct {
  95         dst, x, y int
  96 }
  97
  98 // genIncTo will generate all (dst,x,y) combinations of the input increment set.
  99 func newIncToSet(inc ...int) []incToSet {
 100         n := len(inc)
 101         is := make([]incToSet, n*n*n)
 102         for i, dst := range inc {
 103                 for x := range inc {
 104                         for y := range inc {
 105                                 is[i*n*n+x*n+y] = incToSet{dst, inc[x], inc[y]}
 106                         }
 107                 }
 108         }
 109         return is
 110 }