vendor/gonum.org/v1/gonum/mat/shadow_test.go

   1 // Copyright ©2015 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 mat
   6
   7 import (
   8         "testing"
   9
  10         "golang.org/x/exp/rand"
  11 )
  12
  13 func TestDenseOverlaps(t *testing.T) {
  14         type view struct {
  15                 i, j, r, c int
  16                 *Dense
  17         }
  18
  19         rnd := rand.New(rand.NewSource(1))
  20
  21         for r := 1; r < 20; r++ {
  22                 for c := 1; c < 20; c++ {
  23                         m := NewDense(r, c, nil)
  24                         panicked, message := panics(func() { m.checkOverlap(m.RawMatrix()) })
  25                         if !panicked {
  26                                 t.Error("expected matrix overlap with self")
  27                         }
  28                         if message != regionIdentity {
  29                                 t.Errorf("unexpected panic message for self overlap: got: %q want: %q", message, regionIdentity)
  30                         }
  31
  32                         for i := 0; i < 1000; i++ {
  33                                 var views [2]view
  34                                 for k := range views {
  35                                         if r > 1 {
  36                                                 views[k].i = rnd.Intn(r - 1)
  37                                                 views[k].r = rnd.Intn(r-views[k].i-1) + 1
  38                                         } else {
  39                                                 views[k].r = 1
  40                                         }
  41                                         if c > 1 {
  42                                                 views[k].j = rnd.Intn(c - 1)
  43                                                 views[k].c = rnd.Intn(c-views[k].j-1) + 1
  44                                         } else {
  45                                                 views[k].c = 1
  46                                         }
  47                                         views[k].Dense = m.Slice(views[k].i, views[k].i+views[k].r, views[k].j, views[k].j+views[k].c).(*Dense)
  48
  49                                         panicked, _ = panics(func() { m.checkOverlap(views[k].RawMatrix()) })
  50                                         if !panicked {
  51                                                 t.Errorf("expected matrix (%d×%d) overlap with view {rows=%d:%d, cols=%d:%d}",
  52                                                         r, c, views[k].i, views[k].i+views[k].r, views[k].j, views[k].j+views[k].c)
  53                                         }
  54                                         panicked, _ = panics(func() { views[k].checkOverlap(m.RawMatrix()) })
  55                                         if !panicked {
  56                                                 t.Errorf("expected view {rows=%d:%d, cols=%d:%d} overlap with parent (%d×%d)",
  57                                                         views[k].i, views[k].i+views[k].r, views[k].j, views[k].j+views[k].c, r, c)
  58                                         }
  59                                 }
  60
  61                                 overlapRows := intervalsOverlap(
  62                                         interval{views[0].i, views[0].i + views[0].r},
  63                                         interval{views[1].i, views[1].i + views[1].r},
  64                                 )
  65                                 overlapCols := intervalsOverlap(
  66                                         interval{views[0].j, views[0].j + views[0].c},
  67                                         interval{views[1].j, views[1].j + views[1].c},
  68                                 )
  69                                 want := overlapRows && overlapCols
  70
  71                                 for k, v := range views {
  72                                         w := views[1-k]
  73                                         got, _ := panics(func() { v.checkOverlap(w.RawMatrix()) })
  74                                         if got != want {
  75                                                 t.Errorf("unexpected result for overlap test for {rows=%d:%d, cols=%d:%d} with {rows=%d:%d, cols=%d:%d}: got: %t want: %t",
  76                                                         v.i, v.i+v.r, v.j, v.j+v.c,
  77                                                         w.i, w.i+w.r, w.j, w.j+w.c,
  78                                                         got, want)
  79                                         }
  80                                 }
  81                         }
  82                 }
  83         }
  84 }
  85
  86 type interval struct{ from, to int }
  87
  88 func intervalsOverlap(a, b interval) bool {
  89         return a.to > b.from && b.to > a.from
  90 }
  91
  92 func overlapsParentTriangle(i, j, n int, parent, view TriKind) bool {
  93         switch parent {
  94         case Upper:
  95                 if i <= j {
  96                         return true
  97                 }
  98                 if view == Upper {
  99                         return i < j+n
 100                 }
 101
 102         case Lower:
 103                 if i >= j {
 104                         return true
 105                 }
 106                 if view == Lower {
 107                         return i+n > j
 108                 }
 109         }
 110
 111         return false
 112 }
 113
 114 func overlapSiblingTriangles(ai, aj, an int, aKind TriKind, bi, bj, bn int, bKind TriKind) bool {
 115         for i := max(ai, bi); i < min(ai+an, bi+bn); i++ {
 116                 var a, b interval
 117
 118                 if aKind == Upper {
 119                         a = interval{from: aj - ai + i, to: aj + an}
 120                 } else {
 121                         a = interval{from: aj, to: aj - ai + i + 1}
 122                 }
 123
 124                 if bKind == Upper {
 125                         b = interval{from: bj - bi + i, to: bj + bn}
 126                 } else {
 127                         b = interval{from: bj, to: bj - bi + i + 1}
 128                 }
 129
 130                 if intervalsOverlap(a, b) {
 131                         return true
 132                 }
 133         }
 134         return false
 135 }
 136
 137 // See https://github.com/gonum/matrix/issues/359 for details.
 138 func TestIssue359(t *testing.T) {
 139         for xi := 0; xi < 2; xi++ {
 140                 for xj := 0; xj < 2; xj++ {
 141                         for yi := 0; yi < 2; yi++ {
 142                                 for yj := 0; yj < 2; yj++ {
 143                                         a := NewDense(3, 3, []float64{
 144                                                 1, 2, 3,
 145                                                 4, 5, 6,
 146                                                 7, 8, 9,
 147                                         })
 148                                         x := a.Slice(xi, xi+2, xj, xj+2).(*Dense)
 149                                         y := a.Slice(yi, yi+2, yj, yj+2).(*Dense)
 150
 151                                         panicked, _ := panics(func() { x.checkOverlap(y.mat) })
 152                                         if !panicked {
 153                                                 t.Errorf("expected panic for aliased with offsets x(%d,%d) y(%d,%d):\nx:\n%v\ny:\n%v",
 154                                                         xi, xj, yi, yj, Formatted(x), Formatted(y),
 155                                                 )
 156                                         }
 157                                 }
 158                         }
 159                 }
 160         }
 161 }