gorgonia.org/tensor@v0.9.24/known_issues_test.go (about)

     1  package tensor
     2  
     3  import (
     4  	"testing"
     5  	"testing/quick"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func TestIssue70(t *testing.T) {
    11  	a := 2.0
    12  	b := NewDense(Float64, Shape{1, 1}, WithBacking([]float64{3}))
    13  	var correct interface{} = []float64{6.0}
    14  
    15  	res, err := Mul(a, b)
    16  	if err != nil {
    17  		t.Fatalf("Error: %v", err)
    18  	}
    19  	assert.Equal(t, correct, res.Data())
    20  	t.Logf("a %v b %v, res %v", a, b, res)
    21  }
    22  
    23  func TestIssue72(t *testing.T) {
    24  	a := New(FromScalar(3.14))
    25  	b := 0.0
    26  
    27  	bsa, err := Sub(b, a)
    28  	if err != nil {
    29  		t.Fatal(err)
    30  	}
    31  	t.Logf("%v", bsa)
    32  	ret, err := Sub(b, bsa, UseUnsafe())
    33  	if err != nil {
    34  		t.Fatal(err)
    35  	}
    36  	t.Logf("%v %v", ret, bsa)
    37  
    38  	invReuseScalar := func(q *Dense) bool {
    39  		a := q.Clone().(*Dense)
    40  		//if !a.Shape().IsScalarEquiv() {
    41  		//	return true
    42  		//}
    43  		b := identityVal(0, q.t)
    44  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
    45  		correct := a.Clone().(*Dense)
    46  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
    47  		_, ok := q.Engine().(Suber)
    48  		we = we || !ok
    49  		//log.Printf("b-a(r) | b:%v, a %v, r %v", b, a.Shape(), reuse.Shape())
    50  
    51  		ret, err := Sub(b, a, WithReuse(reuse))
    52  		if err, retEarly := qcErrCheck(t, "SubSV", a, b, we, err); retEarly {
    53  			if err != nil {
    54  				t.Logf("err %v", err)
    55  				return false
    56  			}
    57  			return true
    58  		}
    59  		//log.Printf("b-a(r) | b:%v, a %v, r %v, ret %v", b, a.Shape(), reuse.Shape(), ret.Shape())
    60  		ret, err = Sub(b, ret, UseUnsafe())
    61  
    62  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
    63  			t.Errorf("a %v ", a.Shape())
    64  			return false
    65  		}
    66  		if reuse != ret {
    67  			t.Errorf("Expected reuse to be the same as retVal")
    68  			return false
    69  		}
    70  
    71  		return true
    72  	}
    73  	if err := quick.Check(invReuseScalar, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
    74  		t.Errorf("Inv test for Sub (scalar as left, tensor as right) failed: %v", err)
    75  	}
    76  
    77  }
    78  
    79  func TestIssue83(t *testing.T) {
    80  	backing := []float64{-1, 0, 1}
    81  	var TT Tensor
    82  	TT = New(
    83  		WithShape(1, 3),
    84  		WithBacking(backing))
    85  	TT, _ = T(TT)
    86  
    87  	it := IteratorFromDense(TT.(*Dense))
    88  	for i, ierr := it.Next(); ierr == nil; i, ierr = it.Next() {
    89  		if ierr != nil {
    90  			t.Error(ierr)
    91  		}
    92  		if i >= len(backing) {
    93  			t.Errorf("Iterator should not return an `i` greater than %v", i)
    94  		}
    95  	}
    96  
    97  	backing = []float64{1, 2, 3, 4, 5, 5, 4, 3, 2, 1}
    98  	TT = New(WithShape(10, 1, 1, 1), WithBacking(backing))
    99  	it = IteratorFromDense(TT.(*Dense))
   100  
   101  	var vals []float64
   102  	for i, ierr := it.Next(); ierr == nil; i, ierr = it.Next() {
   103  		if ierr != nil {
   104  			t.Error(ierr)
   105  		}
   106  		v := TT.Data().([]float64)[i]
   107  		vals = append(vals, v)
   108  	}
   109  	t.Logf("%v", vals)
   110  
   111  }
   112  
   113  func TestIssue88(t *testing.T) {
   114  	a := New(WithShape(4, 2), WithBacking([]float64{1, 1, 1, 1, 1, 1, 1, 1}))
   115  	b := New(WithShape(2, 4), WithBacking([]float64{0, 1, 0, 1, 0, 1, 0, 1}))
   116  	c, _ := a.MatMul(b)
   117  	_, err := Div(c, 2)
   118  	if err == nil {
   119  		t.Fatal("Expected an error")
   120  	}
   121  }
   122  
   123  var ltoiTestCases = []struct {
   124  	name        string
   125  	shape       Shape
   126  	strides     []int
   127  	coordinates []int
   128  	correct     int
   129  	willErr     bool
   130  }{
   131  	{"\"scalar\" - scalarshape", Shape{}, nil, []int{0}, 0, false},
   132  	{"\"scalar\" - scalarshape, non empty strides", Shape{}, []int{1}, []int{0}, 0, false},
   133  	{"\"scalar\" - scalarlike", Shape{1, 1, 1}, []int{1, 1, 1}, []int{0, 0, 0}, 0, false},
   134  	{"vector", Shape{10}, []int{1}, []int{1}, 1, false},
   135  	{"rowvec", Shape{1, 10}, []int{10, 1}, []int{0, 1}, 1, false},
   136  	{"colvec", Shape{10, 1}, []int{1, 1}, []int{1, 0}, 1, false},
   137  	{"rowvec- funny strides", Shape{1, 10}, []int{1}, []int{0, 1}, 1, false},
   138  	{"colvec - funny strides", Shape{10, 1}, []int{1}, []int{1, 0}, 1, false},
   139  }
   140  
   141  func TestIssue90(t *testing.T) {
   142  	for i, c := range ltoiTestCases {
   143  		at, err := Ltoi(c.shape, c.strides, c.coordinates...)
   144  		if !checkErr(t, c.willErr, err, c.name, i) {
   145  			continue
   146  		}
   147  		if at != c.correct {
   148  			t.Errorf("Expected Ltoi(%v, %v, %v) to be %v. Got %v instead", c.shape, c.strides, c.coordinates, c.correct, at)
   149  		}
   150  	}
   151  }