github.com/wzzhu/tensor@v0.9.24/dense_arith_test.go (about)

     1  // Code generated by genlib2. DO NOT EDIT.
     2  
     3  package tensor
     4  
     5  import (
     6  	"testing"
     7  	"testing/quick"
     8  )
     9  
    10  func TestDense_Add(t *testing.T) {
    11  	iden := func(a *Dense) bool {
    12  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
    13  		correct := a.Clone().(*Dense)
    14  		we, willFailEq := willerr(a, numberTypes, nil)
    15  		_, ok := a.Engine().(Adder)
    16  		we = we || !ok
    17  
    18  		ret, err := a.Add(b)
    19  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
    20  			if err != nil {
    21  				return false
    22  			}
    23  			return true
    24  		}
    25  
    26  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
    27  			return false
    28  		}
    29  		return true
    30  	}
    31  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
    32  		t.Errorf("Identity test for Add failed: %v", err)
    33  	}
    34  
    35  }
    36  func TestDense_Sub(t *testing.T) {
    37  	inv := func(a *Dense) bool {
    38  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
    39  		correct := a.Clone().(*Dense)
    40  		we, willFailEq := willerr(a, numberTypes, nil)
    41  		_, ok := a.Engine().(Suber)
    42  		we = we || !ok
    43  
    44  		ret, err := a.Sub(b)
    45  		if err, retEarly := qcErrCheck(t, "Sub", a, b, we, err); retEarly {
    46  			if err != nil {
    47  				return false
    48  			}
    49  			return true
    50  		}
    51  		ret, err = ret.Add(b, UseUnsafe())
    52  
    53  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
    54  			return false
    55  		}
    56  		return true
    57  	}
    58  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
    59  		t.Errorf("Inv test for Sub failed: %v", err)
    60  	}
    61  }
    62  func TestDense_Mul(t *testing.T) {
    63  	iden := func(a *Dense) bool {
    64  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
    65  		b.Memset(identityVal(1, a.t))
    66  		correct := a.Clone().(*Dense)
    67  		we, willFailEq := willerr(a, numberTypes, nil)
    68  		_, ok := a.Engine().(Muler)
    69  		we = we || !ok
    70  
    71  		ret, err := a.Mul(b)
    72  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
    73  			if err != nil {
    74  				return false
    75  			}
    76  			return true
    77  		}
    78  
    79  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
    80  			return false
    81  		}
    82  		return true
    83  	}
    84  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
    85  		t.Errorf("Identity test for Mul failed: %v", err)
    86  	}
    87  
    88  }
    89  func TestDense_Div(t *testing.T) {
    90  	inv := func(a *Dense) bool {
    91  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
    92  		b.Memset(identityVal(1, a.t))
    93  		correct := a.Clone().(*Dense)
    94  		we, willFailEq := willerr(a, numberTypes, nil)
    95  		_, ok := a.Engine().(Diver)
    96  		we = we || !ok
    97  
    98  		ret, err := a.Div(b)
    99  		if err, retEarly := qcErrCheck(t, "Div", a, b, we, err); retEarly {
   100  			if err != nil {
   101  				return false
   102  			}
   103  			return true
   104  		}
   105  		ret, err = ret.Mul(b, UseUnsafe())
   106  
   107  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   108  			return false
   109  		}
   110  		return true
   111  	}
   112  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   113  		t.Errorf("Inv test for Div failed: %v", err)
   114  	}
   115  }
   116  func TestDense_Pow(t *testing.T) {
   117  	iden := func(a *Dense) bool {
   118  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   119  		b.Memset(identityVal(1, a.t))
   120  		correct := a.Clone().(*Dense)
   121  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
   122  		_, ok := a.Engine().(Power)
   123  		we = we || !ok
   124  
   125  		ret, err := a.Pow(b)
   126  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
   127  			if err != nil {
   128  				return false
   129  			}
   130  			return true
   131  		}
   132  
   133  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   134  			return false
   135  		}
   136  		return true
   137  	}
   138  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   139  		t.Errorf("Identity test for Pow failed: %v", err)
   140  	}
   141  
   142  }
   143  func TestDense_Add_unsafe(t *testing.T) {
   144  	iden := func(a *Dense) bool {
   145  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   146  		correct := a.Clone().(*Dense)
   147  		we, willFailEq := willerr(a, numberTypes, nil)
   148  		_, ok := a.Engine().(Adder)
   149  		we = we || !ok
   150  
   151  		ret, err := a.Add(b, UseUnsafe())
   152  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   153  			if err != nil {
   154  				return false
   155  			}
   156  			return true
   157  		}
   158  
   159  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   160  			return false
   161  		}
   162  		if ret != a {
   163  			t.Errorf("Expected ret to be the same as a")
   164  			return false
   165  		}
   166  
   167  		return true
   168  	}
   169  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   170  		t.Errorf("Identity test for Add failed: %v", err)
   171  	}
   172  
   173  }
   174  func TestDense_Sub_unsafe(t *testing.T) {
   175  	inv := func(a *Dense) bool {
   176  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   177  		correct := a.Clone().(*Dense)
   178  		we, willFailEq := willerr(a, numberTypes, nil)
   179  		_, ok := a.Engine().(Suber)
   180  		we = we || !ok
   181  
   182  		ret, err := a.Sub(b, UseUnsafe())
   183  		if err, retEarly := qcErrCheck(t, "Sub", a, b, we, err); retEarly {
   184  			if err != nil {
   185  				return false
   186  			}
   187  			return true
   188  		}
   189  		ret, err = ret.Add(b, UseUnsafe())
   190  
   191  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   192  			return false
   193  		}
   194  		if ret != a {
   195  			t.Errorf("Expected ret to be the same as a")
   196  			return false
   197  		}
   198  
   199  		return true
   200  	}
   201  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   202  		t.Errorf("Inv test for Sub failed: %v", err)
   203  	}
   204  }
   205  func TestDense_Mul_unsafe(t *testing.T) {
   206  	iden := func(a *Dense) bool {
   207  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   208  		b.Memset(identityVal(1, a.t))
   209  		correct := a.Clone().(*Dense)
   210  		we, willFailEq := willerr(a, numberTypes, nil)
   211  		_, ok := a.Engine().(Muler)
   212  		we = we || !ok
   213  
   214  		ret, err := a.Mul(b, UseUnsafe())
   215  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
   216  			if err != nil {
   217  				return false
   218  			}
   219  			return true
   220  		}
   221  
   222  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   223  			return false
   224  		}
   225  		if ret != a {
   226  			t.Errorf("Expected ret to be the same as a")
   227  			return false
   228  		}
   229  
   230  		return true
   231  	}
   232  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   233  		t.Errorf("Identity test for Mul failed: %v", err)
   234  	}
   235  
   236  }
   237  func TestDense_Div_unsafe(t *testing.T) {
   238  	inv := func(a *Dense) bool {
   239  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   240  		b.Memset(identityVal(1, a.t))
   241  		correct := a.Clone().(*Dense)
   242  		we, willFailEq := willerr(a, numberTypes, nil)
   243  		_, ok := a.Engine().(Diver)
   244  		we = we || !ok
   245  
   246  		ret, err := a.Div(b, UseUnsafe())
   247  		if err, retEarly := qcErrCheck(t, "Div", a, b, we, err); retEarly {
   248  			if err != nil {
   249  				return false
   250  			}
   251  			return true
   252  		}
   253  		ret, err = ret.Mul(b, UseUnsafe())
   254  
   255  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   256  			return false
   257  		}
   258  		if ret != a {
   259  			t.Errorf("Expected ret to be the same as a")
   260  			return false
   261  		}
   262  
   263  		return true
   264  	}
   265  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   266  		t.Errorf("Inv test for Div failed: %v", err)
   267  	}
   268  }
   269  func TestDense_Pow_unsafe(t *testing.T) {
   270  	iden := func(a *Dense) bool {
   271  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   272  		b.Memset(identityVal(1, a.t))
   273  		correct := a.Clone().(*Dense)
   274  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
   275  		_, ok := a.Engine().(Power)
   276  		we = we || !ok
   277  
   278  		ret, err := a.Pow(b, UseUnsafe())
   279  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
   280  			if err != nil {
   281  				return false
   282  			}
   283  			return true
   284  		}
   285  
   286  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   287  			return false
   288  		}
   289  		if ret != a {
   290  			t.Errorf("Expected ret to be the same as a")
   291  			return false
   292  		}
   293  
   294  		return true
   295  	}
   296  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   297  		t.Errorf("Identity test for Pow failed: %v", err)
   298  	}
   299  
   300  }
   301  func TestDense_Add_reuse(t *testing.T) {
   302  	iden := func(a *Dense) bool {
   303  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   304  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
   305  		correct := a.Clone().(*Dense)
   306  		we, willFailEq := willerr(a, numberTypes, nil)
   307  		_, ok := a.Engine().(Adder)
   308  		we = we || !ok
   309  
   310  		ret, err := a.Add(b, WithReuse(reuse))
   311  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   312  			if err != nil {
   313  				return false
   314  			}
   315  			return true
   316  		}
   317  
   318  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   319  			return false
   320  		}
   321  		if reuse != ret {
   322  			t.Errorf("Expected reuse to be the same as retVal")
   323  			return false
   324  		}
   325  
   326  		return true
   327  	}
   328  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   329  		t.Errorf("Identity test for Add failed: %v", err)
   330  	}
   331  
   332  	mut := func(a, b *Dense, reuseA bool) bool {
   333  		// req because we're only testing on one kind of tensor/engine combo
   334  		a.e = StdEng{}
   335  		a.oe = StdEng{}
   336  		a.flag = 0
   337  		b.e = StdEng{}
   338  		b.oe = StdEng{}
   339  		b.flag = 0
   340  
   341  		if a.Dtype() != b.Dtype() {
   342  			return true
   343  		}
   344  		if !a.Shape().Eq(b.Shape()) {
   345  			return true
   346  		}
   347  
   348  		correct, err := a.Add(b)
   349  		we, willFailEq := willerr(a, numberTypes, nil)
   350  		_, ok := a.Engine().(Adder)
   351  		we = we || !ok
   352  
   353  		var ret, reuse *Dense
   354  		if reuseA {
   355  			ret, err = a.Add(b, WithReuse(a))
   356  			reuse = a
   357  		} else {
   358  			ret, err = a.Add(b, WithReuse(b))
   359  			reuse = b
   360  		}
   361  
   362  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   363  			if err != nil {
   364  				return false
   365  			}
   366  			return true
   367  		}
   368  
   369  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   370  			return false
   371  		}
   372  
   373  		if reuse != ret {
   374  			t.Errorf("Expected reuse to be the same as retVal")
   375  			return false
   376  		}
   377  
   378  		return true
   379  	}
   380  	if err := quick.Check(mut, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   381  		t.Errorf("Reuse Mutation test for Add failed: %v", err)
   382  	}
   383  
   384  }
   385  func TestDense_Sub_reuse(t *testing.T) {
   386  	inv := func(a *Dense) bool {
   387  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   388  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
   389  		correct := a.Clone().(*Dense)
   390  		we, willFailEq := willerr(a, numberTypes, nil)
   391  		_, ok := a.Engine().(Suber)
   392  		we = we || !ok
   393  
   394  		ret, err := a.Sub(b, WithReuse(reuse))
   395  		if err, retEarly := qcErrCheck(t, "Sub", a, b, we, err); retEarly {
   396  			if err != nil {
   397  				return false
   398  			}
   399  			return true
   400  		}
   401  		ret, err = ret.Add(b, UseUnsafe())
   402  
   403  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   404  			return false
   405  		}
   406  		if reuse != ret {
   407  			t.Errorf("Expected reuse to be the same as retVal")
   408  			return false
   409  		}
   410  
   411  		return true
   412  	}
   413  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   414  		t.Errorf("Inv test for Sub failed: %v", err)
   415  	}
   416  	mut := func(a, b *Dense, reuseA bool) bool {
   417  		// req because we're only testing on one kind of tensor/engine combo
   418  		a.e = StdEng{}
   419  		a.oe = StdEng{}
   420  		a.flag = 0
   421  		b.e = StdEng{}
   422  		b.oe = StdEng{}
   423  		b.flag = 0
   424  
   425  		if a.Dtype() != b.Dtype() {
   426  			return true
   427  		}
   428  		if !a.Shape().Eq(b.Shape()) {
   429  			return true
   430  		}
   431  
   432  		correct, err := a.Sub(b)
   433  		we, willFailEq := willerr(a, numberTypes, nil)
   434  		_, ok := a.Engine().(Suber)
   435  		we = we || !ok
   436  
   437  		var ret, reuse *Dense
   438  		if reuseA {
   439  			ret, err = a.Sub(b, WithReuse(a))
   440  			reuse = a
   441  		} else {
   442  			ret, err = a.Sub(b, WithReuse(b))
   443  			reuse = b
   444  		}
   445  
   446  		if err, retEarly := qcErrCheck(t, "Sub", a, b, we, err); retEarly {
   447  			if err != nil {
   448  				return false
   449  			}
   450  			return true
   451  		}
   452  
   453  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   454  			return false
   455  		}
   456  
   457  		if reuse != ret {
   458  			t.Errorf("Expected reuse to be the same as retVal")
   459  			return false
   460  		}
   461  
   462  		return true
   463  	}
   464  	if err := quick.Check(mut, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   465  		t.Errorf("Reuse Mutation test for Sub failed: %v", err)
   466  	}
   467  
   468  }
   469  func TestDense_Mul_reuse(t *testing.T) {
   470  	iden := func(a *Dense) bool {
   471  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   472  		b.Memset(identityVal(1, a.t))
   473  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
   474  		correct := a.Clone().(*Dense)
   475  		we, willFailEq := willerr(a, numberTypes, nil)
   476  		_, ok := a.Engine().(Muler)
   477  		we = we || !ok
   478  
   479  		ret, err := a.Mul(b, WithReuse(reuse))
   480  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
   481  			if err != nil {
   482  				return false
   483  			}
   484  			return true
   485  		}
   486  
   487  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   488  			return false
   489  		}
   490  		if reuse != ret {
   491  			t.Errorf("Expected reuse to be the same as retVal")
   492  			return false
   493  		}
   494  
   495  		return true
   496  	}
   497  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   498  		t.Errorf("Identity test for Mul failed: %v", err)
   499  	}
   500  
   501  	mut := func(a, b *Dense, reuseA bool) bool {
   502  		// req because we're only testing on one kind of tensor/engine combo
   503  		a.e = StdEng{}
   504  		a.oe = StdEng{}
   505  		a.flag = 0
   506  		b.e = StdEng{}
   507  		b.oe = StdEng{}
   508  		b.flag = 0
   509  
   510  		if a.Dtype() != b.Dtype() {
   511  			return true
   512  		}
   513  		if !a.Shape().Eq(b.Shape()) {
   514  			return true
   515  		}
   516  
   517  		correct, err := a.Mul(b)
   518  		we, willFailEq := willerr(a, numberTypes, nil)
   519  		_, ok := a.Engine().(Muler)
   520  		we = we || !ok
   521  
   522  		var ret, reuse *Dense
   523  		if reuseA {
   524  			ret, err = a.Mul(b, WithReuse(a))
   525  			reuse = a
   526  		} else {
   527  			ret, err = a.Mul(b, WithReuse(b))
   528  			reuse = b
   529  		}
   530  
   531  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
   532  			if err != nil {
   533  				return false
   534  			}
   535  			return true
   536  		}
   537  
   538  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   539  			return false
   540  		}
   541  
   542  		if reuse != ret {
   543  			t.Errorf("Expected reuse to be the same as retVal")
   544  			return false
   545  		}
   546  
   547  		return true
   548  	}
   549  	if err := quick.Check(mut, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   550  		t.Errorf("Reuse Mutation test for Mul failed: %v", err)
   551  	}
   552  
   553  }
   554  func TestDense_Div_reuse(t *testing.T) {
   555  	inv := func(a *Dense) bool {
   556  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   557  		b.Memset(identityVal(1, a.t))
   558  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
   559  		correct := a.Clone().(*Dense)
   560  		we, willFailEq := willerr(a, numberTypes, nil)
   561  		_, ok := a.Engine().(Diver)
   562  		we = we || !ok
   563  
   564  		ret, err := a.Div(b, WithReuse(reuse))
   565  		if err, retEarly := qcErrCheck(t, "Div", a, b, we, err); retEarly {
   566  			if err != nil {
   567  				return false
   568  			}
   569  			return true
   570  		}
   571  		ret, err = ret.Mul(b, UseUnsafe())
   572  
   573  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   574  			return false
   575  		}
   576  		if reuse != ret {
   577  			t.Errorf("Expected reuse to be the same as retVal")
   578  			return false
   579  		}
   580  
   581  		return true
   582  	}
   583  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   584  		t.Errorf("Inv test for Div failed: %v", err)
   585  	}
   586  	mut := func(a, b *Dense, reuseA bool) bool {
   587  		// req because we're only testing on one kind of tensor/engine combo
   588  		a.e = StdEng{}
   589  		a.oe = StdEng{}
   590  		a.flag = 0
   591  		b.e = StdEng{}
   592  		b.oe = StdEng{}
   593  		b.flag = 0
   594  
   595  		if a.Dtype() != b.Dtype() {
   596  			return true
   597  		}
   598  		if !a.Shape().Eq(b.Shape()) {
   599  			return true
   600  		}
   601  
   602  		correct, err := a.Div(b)
   603  		we, willFailEq := willerr(a, numberTypes, nil)
   604  		_, ok := a.Engine().(Diver)
   605  		we = we || !ok
   606  
   607  		var ret, reuse *Dense
   608  		if reuseA {
   609  			ret, err = a.Div(b, WithReuse(a))
   610  			reuse = a
   611  		} else {
   612  			ret, err = a.Div(b, WithReuse(b))
   613  			reuse = b
   614  		}
   615  
   616  		if err, retEarly := qcErrCheck(t, "Div", a, b, we, err); retEarly {
   617  			if err != nil {
   618  				return false
   619  			}
   620  			return true
   621  		}
   622  
   623  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   624  			return false
   625  		}
   626  
   627  		if reuse != ret {
   628  			t.Errorf("Expected reuse to be the same as retVal")
   629  			return false
   630  		}
   631  
   632  		return true
   633  	}
   634  	if err := quick.Check(mut, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   635  		t.Errorf("Reuse Mutation test for Div failed: %v", err)
   636  	}
   637  
   638  }
   639  func TestDense_Pow_reuse(t *testing.T) {
   640  	iden := func(a *Dense) bool {
   641  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   642  		b.Memset(identityVal(1, a.t))
   643  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
   644  		correct := a.Clone().(*Dense)
   645  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
   646  		_, ok := a.Engine().(Power)
   647  		we = we || !ok
   648  
   649  		ret, err := a.Pow(b, WithReuse(reuse))
   650  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
   651  			if err != nil {
   652  				return false
   653  			}
   654  			return true
   655  		}
   656  
   657  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   658  			return false
   659  		}
   660  		if reuse != ret {
   661  			t.Errorf("Expected reuse to be the same as retVal")
   662  			return false
   663  		}
   664  
   665  		return true
   666  	}
   667  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   668  		t.Errorf("Identity test for Pow failed: %v", err)
   669  	}
   670  
   671  }
   672  func TestDense_Add_incr(t *testing.T) {
   673  	iden := func(a *Dense) bool {
   674  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   675  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   676  		correct := a.Clone().(*Dense)
   677  		incr.Memset(identityVal(100, a.t))
   678  		correct.Add(incr, UseUnsafe())
   679  		we, willFailEq := willerr(a, numberTypes, nil)
   680  		_, ok := a.Engine().(Adder)
   681  		we = we || !ok
   682  
   683  		ret, err := a.Add(b, WithIncr(incr))
   684  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   685  			if err != nil {
   686  				return false
   687  			}
   688  			return true
   689  		}
   690  
   691  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   692  			return false
   693  		}
   694  		return true
   695  	}
   696  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   697  		t.Errorf("Identity test for Add failed: %v", err)
   698  	}
   699  
   700  }
   701  func TestDense_Sub_incr(t *testing.T) {
   702  	inv := func(a *Dense) bool {
   703  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   704  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   705  		correct := a.Clone().(*Dense)
   706  		incr.Memset(identityVal(100, a.t))
   707  		correct.Add(incr, UseUnsafe())
   708  		we, willFailEq := willerr(a, numberTypes, nil)
   709  		_, ok := a.Engine().(Suber)
   710  		we = we || !ok
   711  
   712  		ret, err := a.Sub(b, WithIncr(incr))
   713  		if err, retEarly := qcErrCheck(t, "Sub", a, b, we, err); retEarly {
   714  			if err != nil {
   715  				return false
   716  			}
   717  			return true
   718  		}
   719  		ret, err = ret.Add(b, UseUnsafe())
   720  
   721  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   722  			return false
   723  		}
   724  		return true
   725  	}
   726  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   727  		t.Errorf("Inv test for Sub failed: %v", err)
   728  	}
   729  }
   730  func TestDense_Mul_incr(t *testing.T) {
   731  	iden := func(a *Dense) bool {
   732  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   733  		b.Memset(identityVal(1, a.t))
   734  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   735  		correct := a.Clone().(*Dense)
   736  		incr.Memset(identityVal(100, a.t))
   737  		correct.Add(incr, UseUnsafe())
   738  		we, willFailEq := willerr(a, numberTypes, nil)
   739  		_, ok := a.Engine().(Muler)
   740  		we = we || !ok
   741  
   742  		ret, err := a.Mul(b, WithIncr(incr))
   743  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
   744  			if err != nil {
   745  				return false
   746  			}
   747  			return true
   748  		}
   749  
   750  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   751  			return false
   752  		}
   753  		return true
   754  	}
   755  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   756  		t.Errorf("Identity test for Mul failed: %v", err)
   757  	}
   758  
   759  }
   760  func TestDense_Div_incr(t *testing.T) {
   761  	inv := func(a *Dense) bool {
   762  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   763  		b.Memset(identityVal(1, a.t))
   764  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   765  		correct := a.Clone().(*Dense)
   766  		incr.Memset(identityVal(100, a.t))
   767  		correct.Add(incr, UseUnsafe())
   768  		we, willFailEq := willerr(a, numberTypes, nil)
   769  		_, ok := a.Engine().(Diver)
   770  		we = we || !ok
   771  
   772  		ret, err := a.Div(b, WithIncr(incr))
   773  		if err, retEarly := qcErrCheck(t, "Div", a, b, we, err); retEarly {
   774  			if err != nil {
   775  				return false
   776  			}
   777  			return true
   778  		}
   779  		ret, err = ret.Mul(b, UseUnsafe())
   780  
   781  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   782  			return false
   783  		}
   784  		return true
   785  	}
   786  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   787  		t.Errorf("Inv test for Div failed: %v", err)
   788  	}
   789  }
   790  func TestDense_Pow_incr(t *testing.T) {
   791  	iden := func(a *Dense) bool {
   792  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   793  		b.Memset(identityVal(1, a.t))
   794  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   795  		correct := a.Clone().(*Dense)
   796  		incr.Memset(identityVal(100, a.t))
   797  		correct.Add(incr, UseUnsafe())
   798  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
   799  		_, ok := a.Engine().(Power)
   800  		we = we || !ok
   801  
   802  		ret, err := a.Pow(b, WithIncr(incr))
   803  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
   804  			if err != nil {
   805  				return false
   806  			}
   807  			return true
   808  		}
   809  
   810  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   811  			return false
   812  		}
   813  		return true
   814  	}
   815  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   816  		t.Errorf("Identity test for Pow failed: %v", err)
   817  	}
   818  
   819  }
   820  func TestDense_AddScalar(t *testing.T) {
   821  	iden1 := func(q *Dense) bool {
   822  		a := q.Clone().(*Dense)
   823  		b := identityVal(0, q.t)
   824  
   825  		correct := a.Clone().(*Dense)
   826  		we, willFailEq := willerr(a, numberTypes, nil)
   827  		_, ok := q.Engine().(Adder)
   828  		we = we || !ok
   829  
   830  		ret, err := a.AddScalar(b, true)
   831  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   832  			if err != nil {
   833  				return false
   834  			}
   835  			return true
   836  		}
   837  
   838  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   839  			return false
   840  		}
   841  		return true
   842  	}
   843  
   844  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   845  		t.Errorf("Identity test for Add (tensor as left, scalar as right) failed: %v", err)
   846  	}
   847  
   848  	iden2 := func(q *Dense) bool {
   849  		a := q.Clone().(*Dense)
   850  		b := identityVal(0, q.t)
   851  		correct := a.Clone().(*Dense)
   852  		we, willFailEq := willerr(a, numberTypes, nil)
   853  		_, ok := q.Engine().(Adder)
   854  		we = we || !ok
   855  
   856  		ret, err := a.AddScalar(b, false)
   857  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   858  			if err != nil {
   859  				return false
   860  			}
   861  			return true
   862  		}
   863  
   864  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   865  			return false
   866  		}
   867  		return true
   868  	}
   869  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   870  		t.Errorf("Identity test for Add (scalar as left, tensor as right) failed: %v", err)
   871  	}
   872  
   873  	type Foo int
   874  	wt1 := func(a *Dense) bool {
   875  		b := Foo(0)
   876  		ret, err := Add(a, b)
   877  		if err == nil {
   878  			return false
   879  		}
   880  		_ = ret
   881  		return true
   882  	}
   883  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   884  		t.Errorf("WrongType test for Add (tensor as left, scalar as right) failed: %v", err)
   885  	}
   886  
   887  	wt2 := func(a *Dense) bool {
   888  		b := Foo(0)
   889  		ret, err := Add(b, a)
   890  		if err == nil {
   891  			return false
   892  		}
   893  		_ = ret
   894  		return true
   895  	}
   896  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   897  		t.Errorf("WrongType test for Add (tensor as right, scalar as left) failed: %v", err)
   898  	}
   899  }
   900  func TestDense_SubScalar(t *testing.T) {
   901  	inv1 := func(q *Dense) bool {
   902  		a := q.Clone().(*Dense)
   903  		b := identityVal(0, q.t)
   904  
   905  		correct := a.Clone().(*Dense)
   906  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
   907  		_, ok := q.Engine().(Suber)
   908  		we = we || !ok
   909  
   910  		ret, err := a.SubScalar(b, true)
   911  		if err, retEarly := qcErrCheck(t, "SubVS", a, b, we, err); retEarly {
   912  			if err != nil {
   913  				return false
   914  			}
   915  			return true
   916  		}
   917  		ret, err = ret.AddScalar(b, true, UseUnsafe())
   918  
   919  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   920  			return false
   921  		}
   922  		return true
   923  	}
   924  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   925  		t.Errorf("Inv test for Sub (tensor as left, scalar as right) failed: %v", err)
   926  	}
   927  
   928  	inv2 := func(q *Dense) bool {
   929  		a := q.Clone().(*Dense)
   930  		b := identityVal(0, q.t)
   931  		correct := a.Clone().(*Dense)
   932  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
   933  		_, ok := q.Engine().(Suber)
   934  		we = we || !ok
   935  
   936  		ret, err := a.SubScalar(b, false)
   937  		if err, retEarly := qcErrCheck(t, "SubSV", a, b, we, err); retEarly {
   938  			if err != nil {
   939  				return false
   940  			}
   941  			return true
   942  		}
   943  		ret, err = ret.SubScalar(b, false, UseUnsafe())
   944  
   945  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   946  			return false
   947  		}
   948  		return true
   949  	}
   950  	if err := quick.Check(inv2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   951  		t.Errorf("Inv test for Sub (scalar as left, tensor as right) failed: %v", err)
   952  	}
   953  	type Foo int
   954  	wt1 := func(a *Dense) bool {
   955  		b := Foo(0)
   956  		ret, err := Sub(a, b)
   957  		if err == nil {
   958  			return false
   959  		}
   960  		_ = ret
   961  		return true
   962  	}
   963  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   964  		t.Errorf("WrongType test for Sub (tensor as left, scalar as right) failed: %v", err)
   965  	}
   966  
   967  	wt2 := func(a *Dense) bool {
   968  		b := Foo(0)
   969  		ret, err := Sub(b, a)
   970  		if err == nil {
   971  			return false
   972  		}
   973  		_ = ret
   974  		return true
   975  	}
   976  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   977  		t.Errorf("WrongType test for Sub (tensor as right, scalar as left) failed: %v", err)
   978  	}
   979  }
   980  func TestDense_MulScalar(t *testing.T) {
   981  	iden1 := func(q *Dense) bool {
   982  		a := q.Clone().(*Dense)
   983  		b := identityVal(1, q.t)
   984  
   985  		correct := a.Clone().(*Dense)
   986  		we, willFailEq := willerr(a, numberTypes, nil)
   987  		_, ok := q.Engine().(Muler)
   988  		we = we || !ok
   989  
   990  		ret, err := a.MulScalar(b, true)
   991  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
   992  			if err != nil {
   993  				return false
   994  			}
   995  			return true
   996  		}
   997  
   998  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   999  			return false
  1000  		}
  1001  		return true
  1002  	}
  1003  
  1004  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1005  		t.Errorf("Identity test for Mul (tensor as left, scalar as right) failed: %v", err)
  1006  	}
  1007  
  1008  	iden2 := func(q *Dense) bool {
  1009  		a := q.Clone().(*Dense)
  1010  		b := identityVal(1, q.t)
  1011  		correct := a.Clone().(*Dense)
  1012  		we, willFailEq := willerr(a, numberTypes, nil)
  1013  		_, ok := q.Engine().(Muler)
  1014  		we = we || !ok
  1015  
  1016  		ret, err := a.MulScalar(b, false)
  1017  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1018  			if err != nil {
  1019  				return false
  1020  			}
  1021  			return true
  1022  		}
  1023  
  1024  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1025  			return false
  1026  		}
  1027  		return true
  1028  	}
  1029  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1030  		t.Errorf("Identity test for Mul (scalar as left, tensor as right) failed: %v", err)
  1031  	}
  1032  
  1033  	type Foo int
  1034  	wt1 := func(a *Dense) bool {
  1035  		b := Foo(0)
  1036  		ret, err := Mul(a, b)
  1037  		if err == nil {
  1038  			return false
  1039  		}
  1040  		_ = ret
  1041  		return true
  1042  	}
  1043  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1044  		t.Errorf("WrongType test for Mul (tensor as left, scalar as right) failed: %v", err)
  1045  	}
  1046  
  1047  	wt2 := func(a *Dense) bool {
  1048  		b := Foo(0)
  1049  		ret, err := Mul(b, a)
  1050  		if err == nil {
  1051  			return false
  1052  		}
  1053  		_ = ret
  1054  		return true
  1055  	}
  1056  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1057  		t.Errorf("WrongType test for Mul (tensor as right, scalar as left) failed: %v", err)
  1058  	}
  1059  }
  1060  func TestDense_DivScalar(t *testing.T) {
  1061  	inv1 := func(q *Dense) bool {
  1062  		a := q.Clone().(*Dense)
  1063  		b := identityVal(1, q.t)
  1064  
  1065  		correct := a.Clone().(*Dense)
  1066  		we, willFailEq := willerr(a, numberTypes, nil)
  1067  		_, ok := q.Engine().(Diver)
  1068  		we = we || !ok
  1069  
  1070  		ret, err := a.DivScalar(b, true)
  1071  		if err, retEarly := qcErrCheck(t, "DivVS", a, b, we, err); retEarly {
  1072  			if err != nil {
  1073  				return false
  1074  			}
  1075  			return true
  1076  		}
  1077  		ret, err = ret.MulScalar(b, true, UseUnsafe())
  1078  
  1079  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1080  			return false
  1081  		}
  1082  		return true
  1083  	}
  1084  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1085  		t.Errorf("Inv test for Div (tensor as left, scalar as right) failed: %v", err)
  1086  	}
  1087  
  1088  	type Foo int
  1089  	wt1 := func(a *Dense) bool {
  1090  		b := Foo(0)
  1091  		ret, err := Div(a, b)
  1092  		if err == nil {
  1093  			return false
  1094  		}
  1095  		_ = ret
  1096  		return true
  1097  	}
  1098  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1099  		t.Errorf("WrongType test for Div (tensor as left, scalar as right) failed: %v", err)
  1100  	}
  1101  
  1102  	wt2 := func(a *Dense) bool {
  1103  		b := Foo(0)
  1104  		ret, err := Div(b, a)
  1105  		if err == nil {
  1106  			return false
  1107  		}
  1108  		_ = ret
  1109  		return true
  1110  	}
  1111  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1112  		t.Errorf("WrongType test for Div (tensor as right, scalar as left) failed: %v", err)
  1113  	}
  1114  }
  1115  func TestDense_PowScalar(t *testing.T) {
  1116  	iden1 := func(q *Dense) bool {
  1117  		a := q.Clone().(*Dense)
  1118  		b := identityVal(1, q.t)
  1119  
  1120  		correct := a.Clone().(*Dense)
  1121  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
  1122  		_, ok := q.Engine().(Power)
  1123  		we = we || !ok
  1124  
  1125  		ret, err := a.PowScalar(b, true)
  1126  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
  1127  			if err != nil {
  1128  				return false
  1129  			}
  1130  			return true
  1131  		}
  1132  
  1133  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1134  			return false
  1135  		}
  1136  		return true
  1137  	}
  1138  
  1139  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1140  		t.Errorf("Identity test for Pow (tensor as left, scalar as right) failed: %v", err)
  1141  	}
  1142  
  1143  	type Foo int
  1144  	wt1 := func(a *Dense) bool {
  1145  		b := Foo(0)
  1146  		ret, err := Pow(a, b)
  1147  		if err == nil {
  1148  			return false
  1149  		}
  1150  		_ = ret
  1151  		return true
  1152  	}
  1153  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1154  		t.Errorf("WrongType test for Pow (tensor as left, scalar as right) failed: %v", err)
  1155  	}
  1156  
  1157  	wt2 := func(a *Dense) bool {
  1158  		b := Foo(0)
  1159  		ret, err := Pow(b, a)
  1160  		if err == nil {
  1161  			return false
  1162  		}
  1163  		_ = ret
  1164  		return true
  1165  	}
  1166  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1167  		t.Errorf("WrongType test for Pow (tensor as right, scalar as left) failed: %v", err)
  1168  	}
  1169  }
  1170  func TestDense_AddScalar_unsafe(t *testing.T) {
  1171  	iden1 := func(q *Dense) bool {
  1172  		a := q.Clone().(*Dense)
  1173  		b := identityVal(0, q.t)
  1174  
  1175  		correct := a.Clone().(*Dense)
  1176  		we, willFailEq := willerr(a, numberTypes, nil)
  1177  		_, ok := q.Engine().(Adder)
  1178  		we = we || !ok
  1179  
  1180  		ret, err := a.AddScalar(b, true, UseUnsafe())
  1181  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1182  			if err != nil {
  1183  				return false
  1184  			}
  1185  			return true
  1186  		}
  1187  
  1188  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1189  			return false
  1190  		}
  1191  		if ret != a {
  1192  			t.Errorf("Expected ret to be the same as a")
  1193  			return false
  1194  		}
  1195  
  1196  		return true
  1197  	}
  1198  
  1199  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1200  		t.Errorf("Identity test for Add (tensor as left, scalar as right) failed: %v", err)
  1201  	}
  1202  
  1203  	iden2 := func(q *Dense) bool {
  1204  		a := q.Clone().(*Dense)
  1205  		b := identityVal(0, q.t)
  1206  		correct := a.Clone().(*Dense)
  1207  		we, willFailEq := willerr(a, numberTypes, nil)
  1208  		_, ok := q.Engine().(Adder)
  1209  		we = we || !ok
  1210  
  1211  		ret, err := a.AddScalar(b, false, UseUnsafe())
  1212  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1213  			if err != nil {
  1214  				return false
  1215  			}
  1216  			return true
  1217  		}
  1218  
  1219  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1220  			return false
  1221  		}
  1222  		if ret != a {
  1223  			t.Errorf("Expected ret to be the same as a")
  1224  			return false
  1225  		}
  1226  
  1227  		return true
  1228  	}
  1229  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1230  		t.Errorf("Identity test for Add (scalar as left, tensor as right) failed: %v", err)
  1231  	}
  1232  
  1233  }
  1234  func TestDense_SubScalar_unsafe(t *testing.T) {
  1235  	inv1 := func(q *Dense) bool {
  1236  		a := q.Clone().(*Dense)
  1237  		b := identityVal(0, q.t)
  1238  
  1239  		correct := a.Clone().(*Dense)
  1240  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1241  		_, ok := q.Engine().(Suber)
  1242  		we = we || !ok
  1243  
  1244  		ret, err := a.SubScalar(b, true, UseUnsafe())
  1245  		if err, retEarly := qcErrCheck(t, "SubVS", a, b, we, err); retEarly {
  1246  			if err != nil {
  1247  				return false
  1248  			}
  1249  			return true
  1250  		}
  1251  		ret, err = ret.AddScalar(b, true, UseUnsafe())
  1252  
  1253  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1254  			return false
  1255  		}
  1256  		if ret != a {
  1257  			t.Errorf("Expected ret to be the same as a")
  1258  			return false
  1259  		}
  1260  
  1261  		return true
  1262  	}
  1263  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1264  		t.Errorf("Inv test for Sub (tensor as left, scalar as right) failed: %v", err)
  1265  	}
  1266  
  1267  	inv2 := func(q *Dense) bool {
  1268  		a := q.Clone().(*Dense)
  1269  		b := identityVal(0, q.t)
  1270  		correct := a.Clone().(*Dense)
  1271  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1272  		_, ok := q.Engine().(Suber)
  1273  		we = we || !ok
  1274  
  1275  		ret, err := a.SubScalar(b, false, UseUnsafe())
  1276  		if err, retEarly := qcErrCheck(t, "SubSV", a, b, we, err); retEarly {
  1277  			if err != nil {
  1278  				return false
  1279  			}
  1280  			return true
  1281  		}
  1282  		ret, err = ret.SubScalar(b, false, UseUnsafe())
  1283  
  1284  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1285  			return false
  1286  		}
  1287  		if ret != a {
  1288  			t.Errorf("Expected ret to be the same as a")
  1289  			return false
  1290  		}
  1291  
  1292  		return true
  1293  	}
  1294  	if err := quick.Check(inv2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1295  		t.Errorf("Inv test for Sub (scalar as left, tensor as right) failed: %v", err)
  1296  	}
  1297  }
  1298  func TestDense_MulScalar_unsafe(t *testing.T) {
  1299  	iden1 := func(q *Dense) bool {
  1300  		a := q.Clone().(*Dense)
  1301  		b := identityVal(1, q.t)
  1302  
  1303  		correct := a.Clone().(*Dense)
  1304  		we, willFailEq := willerr(a, numberTypes, nil)
  1305  		_, ok := q.Engine().(Muler)
  1306  		we = we || !ok
  1307  
  1308  		ret, err := a.MulScalar(b, true, UseUnsafe())
  1309  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1310  			if err != nil {
  1311  				return false
  1312  			}
  1313  			return true
  1314  		}
  1315  
  1316  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1317  			return false
  1318  		}
  1319  		if ret != a {
  1320  			t.Errorf("Expected ret to be the same as a")
  1321  			return false
  1322  		}
  1323  
  1324  		return true
  1325  	}
  1326  
  1327  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1328  		t.Errorf("Identity test for Mul (tensor as left, scalar as right) failed: %v", err)
  1329  	}
  1330  
  1331  	iden2 := func(q *Dense) bool {
  1332  		a := q.Clone().(*Dense)
  1333  		b := identityVal(1, q.t)
  1334  		correct := a.Clone().(*Dense)
  1335  		we, willFailEq := willerr(a, numberTypes, nil)
  1336  		_, ok := q.Engine().(Muler)
  1337  		we = we || !ok
  1338  
  1339  		ret, err := a.MulScalar(b, false, UseUnsafe())
  1340  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1341  			if err != nil {
  1342  				return false
  1343  			}
  1344  			return true
  1345  		}
  1346  
  1347  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1348  			return false
  1349  		}
  1350  		if ret != a {
  1351  			t.Errorf("Expected ret to be the same as a")
  1352  			return false
  1353  		}
  1354  
  1355  		return true
  1356  	}
  1357  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1358  		t.Errorf("Identity test for Mul (scalar as left, tensor as right) failed: %v", err)
  1359  	}
  1360  
  1361  }
  1362  func TestDense_DivScalar_unsafe(t *testing.T) {
  1363  	inv1 := func(q *Dense) bool {
  1364  		a := q.Clone().(*Dense)
  1365  		b := identityVal(1, q.t)
  1366  
  1367  		correct := a.Clone().(*Dense)
  1368  		we, willFailEq := willerr(a, numberTypes, nil)
  1369  		_, ok := q.Engine().(Diver)
  1370  		we = we || !ok
  1371  
  1372  		ret, err := a.DivScalar(b, true, UseUnsafe())
  1373  		if err, retEarly := qcErrCheck(t, "DivVS", a, b, we, err); retEarly {
  1374  			if err != nil {
  1375  				return false
  1376  			}
  1377  			return true
  1378  		}
  1379  		ret, err = ret.MulScalar(b, true, UseUnsafe())
  1380  
  1381  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1382  			return false
  1383  		}
  1384  		if ret != a {
  1385  			t.Errorf("Expected ret to be the same as a")
  1386  			return false
  1387  		}
  1388  
  1389  		return true
  1390  	}
  1391  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1392  		t.Errorf("Inv test for Div (tensor as left, scalar as right) failed: %v", err)
  1393  	}
  1394  
  1395  }
  1396  func TestDense_PowScalar_unsafe(t *testing.T) {
  1397  	iden1 := func(q *Dense) bool {
  1398  		a := q.Clone().(*Dense)
  1399  		b := identityVal(1, q.t)
  1400  
  1401  		correct := a.Clone().(*Dense)
  1402  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
  1403  		_, ok := q.Engine().(Power)
  1404  		we = we || !ok
  1405  
  1406  		ret, err := a.PowScalar(b, true, UseUnsafe())
  1407  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
  1408  			if err != nil {
  1409  				return false
  1410  			}
  1411  			return true
  1412  		}
  1413  
  1414  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1415  			return false
  1416  		}
  1417  		if ret != a {
  1418  			t.Errorf("Expected ret to be the same as a")
  1419  			return false
  1420  		}
  1421  
  1422  		return true
  1423  	}
  1424  
  1425  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1426  		t.Errorf("Identity test for Pow (tensor as left, scalar as right) failed: %v", err)
  1427  	}
  1428  
  1429  }
  1430  func TestDense_AddScalar_reuse(t *testing.T) {
  1431  	iden1 := func(q *Dense) bool {
  1432  		a := q.Clone().(*Dense)
  1433  		b := identityVal(0, q.t)
  1434  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1435  
  1436  		correct := a.Clone().(*Dense)
  1437  		we, willFailEq := willerr(a, numberTypes, nil)
  1438  		_, ok := q.Engine().(Adder)
  1439  		we = we || !ok
  1440  
  1441  		ret, err := a.AddScalar(b, true, WithReuse(reuse))
  1442  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1443  			if err != nil {
  1444  				return false
  1445  			}
  1446  			return true
  1447  		}
  1448  
  1449  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1450  			return false
  1451  		}
  1452  		if reuse != ret {
  1453  			t.Errorf("Expected reuse to be the same as retVal")
  1454  			return false
  1455  		}
  1456  
  1457  		return true
  1458  	}
  1459  
  1460  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1461  		t.Errorf("Identity test for Add (tensor as left, scalar as right) failed: %v", err)
  1462  	}
  1463  
  1464  	iden2 := func(q *Dense) bool {
  1465  		a := q.Clone().(*Dense)
  1466  		b := identityVal(0, q.t)
  1467  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1468  		correct := a.Clone().(*Dense)
  1469  		we, willFailEq := willerr(a, numberTypes, nil)
  1470  		_, ok := q.Engine().(Adder)
  1471  		we = we || !ok
  1472  
  1473  		ret, err := a.AddScalar(b, false, WithReuse(reuse))
  1474  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1475  			if err != nil {
  1476  				return false
  1477  			}
  1478  			return true
  1479  		}
  1480  
  1481  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1482  			return false
  1483  		}
  1484  		if reuse != ret {
  1485  			t.Errorf("Expected reuse to be the same as retVal")
  1486  			return false
  1487  		}
  1488  
  1489  		return true
  1490  	}
  1491  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1492  		t.Errorf("Identity test for Add (scalar as left, tensor as right) failed: %v", err)
  1493  	}
  1494  
  1495  	mut := func(a, b *Dense, reuseA bool) bool {
  1496  		// req because we're only testing on one kind of tensor/engine combo
  1497  		a.e = StdEng{}
  1498  		a.oe = StdEng{}
  1499  		a.flag = 0
  1500  		b.e = StdEng{}
  1501  		b.oe = StdEng{}
  1502  		b.flag = 0
  1503  
  1504  		if a.Dtype() != b.Dtype() {
  1505  			return true
  1506  		}
  1507  		if !a.Shape().Eq(b.Shape()) {
  1508  			return true
  1509  		}
  1510  
  1511  		correct, err := a.Add(b)
  1512  		we, willFailEq := willerr(a, numberTypes, nil)
  1513  		_, ok := a.Engine().(Adder)
  1514  		we = we || !ok
  1515  
  1516  		var ret, reuse *Dense
  1517  		if reuseA {
  1518  			ret, err = a.Add(b, WithReuse(a))
  1519  			reuse = a
  1520  		} else {
  1521  			ret, err = a.Add(b, WithReuse(b))
  1522  			reuse = b
  1523  		}
  1524  
  1525  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1526  			if err != nil {
  1527  				return false
  1528  			}
  1529  			return true
  1530  		}
  1531  
  1532  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1533  			return false
  1534  		}
  1535  
  1536  		if reuse != ret {
  1537  			t.Errorf("Expected reuse to be the same as retVal")
  1538  			return false
  1539  		}
  1540  
  1541  		return true
  1542  	}
  1543  	if err := quick.Check(mut, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1544  		t.Errorf("Reuse Mutation test for Add failed: %v", err)
  1545  	}
  1546  
  1547  }
  1548  func TestDense_SubScalar_reuse(t *testing.T) {
  1549  	inv1 := func(q *Dense) bool {
  1550  		a := q.Clone().(*Dense)
  1551  		b := identityVal(0, q.t)
  1552  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1553  
  1554  		correct := a.Clone().(*Dense)
  1555  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1556  		_, ok := q.Engine().(Suber)
  1557  		we = we || !ok
  1558  
  1559  		ret, err := a.SubScalar(b, true, WithReuse(reuse))
  1560  		if err, retEarly := qcErrCheck(t, "SubVS", a, b, we, err); retEarly {
  1561  			if err != nil {
  1562  				return false
  1563  			}
  1564  			return true
  1565  		}
  1566  		ret, err = ret.AddScalar(b, true, UseUnsafe())
  1567  
  1568  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1569  			return false
  1570  		}
  1571  		if reuse != ret {
  1572  			t.Errorf("Expected reuse to be the same as retVal")
  1573  			return false
  1574  		}
  1575  
  1576  		return true
  1577  	}
  1578  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1579  		t.Errorf("Inv test for Sub (tensor as left, scalar as right) failed: %v", err)
  1580  	}
  1581  
  1582  	inv2 := func(q *Dense) bool {
  1583  		a := q.Clone().(*Dense)
  1584  		b := identityVal(0, q.t)
  1585  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1586  		correct := a.Clone().(*Dense)
  1587  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1588  		_, ok := q.Engine().(Suber)
  1589  		we = we || !ok
  1590  
  1591  		ret, err := a.SubScalar(b, false, WithReuse(reuse))
  1592  		if err, retEarly := qcErrCheck(t, "SubSV", a, b, we, err); retEarly {
  1593  			if err != nil {
  1594  				return false
  1595  			}
  1596  			return true
  1597  		}
  1598  		ret, err = ret.SubScalar(b, false, UseUnsafe())
  1599  
  1600  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1601  			return false
  1602  		}
  1603  		if reuse != ret {
  1604  			t.Errorf("Expected reuse to be the same as retVal")
  1605  			return false
  1606  		}
  1607  
  1608  		return true
  1609  	}
  1610  	if err := quick.Check(inv2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1611  		t.Errorf("Inv test for Sub (scalar as left, tensor as right) failed: %v", err)
  1612  	}
  1613  	mut := func(a, b *Dense, reuseA bool) bool {
  1614  		// req because we're only testing on one kind of tensor/engine combo
  1615  		a.e = StdEng{}
  1616  		a.oe = StdEng{}
  1617  		a.flag = 0
  1618  		b.e = StdEng{}
  1619  		b.oe = StdEng{}
  1620  		b.flag = 0
  1621  
  1622  		if a.Dtype() != b.Dtype() {
  1623  			return true
  1624  		}
  1625  		if !a.Shape().Eq(b.Shape()) {
  1626  			return true
  1627  		}
  1628  
  1629  		correct, err := a.Sub(b)
  1630  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1631  		_, ok := a.Engine().(Suber)
  1632  		we = we || !ok
  1633  
  1634  		var ret, reuse *Dense
  1635  		if reuseA {
  1636  			ret, err = a.Sub(b, WithReuse(a))
  1637  			reuse = a
  1638  		} else {
  1639  			ret, err = a.Sub(b, WithReuse(b))
  1640  			reuse = b
  1641  		}
  1642  
  1643  		if err, retEarly := qcErrCheck(t, "Sub", a, b, we, err); retEarly {
  1644  			if err != nil {
  1645  				return false
  1646  			}
  1647  			return true
  1648  		}
  1649  
  1650  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1651  			return false
  1652  		}
  1653  
  1654  		if reuse != ret {
  1655  			t.Errorf("Expected reuse to be the same as retVal")
  1656  			return false
  1657  		}
  1658  
  1659  		return true
  1660  	}
  1661  	if err := quick.Check(mut, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1662  		t.Errorf("Reuse Mutation test for Sub failed: %v", err)
  1663  	}
  1664  
  1665  }
  1666  func TestDense_MulScalar_reuse(t *testing.T) {
  1667  	iden1 := func(q *Dense) bool {
  1668  		a := q.Clone().(*Dense)
  1669  		b := identityVal(1, q.t)
  1670  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1671  
  1672  		correct := a.Clone().(*Dense)
  1673  		we, willFailEq := willerr(a, numberTypes, nil)
  1674  		_, ok := q.Engine().(Muler)
  1675  		we = we || !ok
  1676  
  1677  		ret, err := a.MulScalar(b, true, WithReuse(reuse))
  1678  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1679  			if err != nil {
  1680  				return false
  1681  			}
  1682  			return true
  1683  		}
  1684  
  1685  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1686  			return false
  1687  		}
  1688  		if reuse != ret {
  1689  			t.Errorf("Expected reuse to be the same as retVal")
  1690  			return false
  1691  		}
  1692  
  1693  		return true
  1694  	}
  1695  
  1696  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1697  		t.Errorf("Identity test for Mul (tensor as left, scalar as right) failed: %v", err)
  1698  	}
  1699  
  1700  	iden2 := func(q *Dense) bool {
  1701  		a := q.Clone().(*Dense)
  1702  		b := identityVal(1, q.t)
  1703  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1704  		correct := a.Clone().(*Dense)
  1705  		we, willFailEq := willerr(a, numberTypes, nil)
  1706  		_, ok := q.Engine().(Muler)
  1707  		we = we || !ok
  1708  
  1709  		ret, err := a.MulScalar(b, false, WithReuse(reuse))
  1710  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1711  			if err != nil {
  1712  				return false
  1713  			}
  1714  			return true
  1715  		}
  1716  
  1717  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1718  			return false
  1719  		}
  1720  		if reuse != ret {
  1721  			t.Errorf("Expected reuse to be the same as retVal")
  1722  			return false
  1723  		}
  1724  
  1725  		return true
  1726  	}
  1727  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1728  		t.Errorf("Identity test for Mul (scalar as left, tensor as right) failed: %v", err)
  1729  	}
  1730  
  1731  	mut := func(a, b *Dense, reuseA bool) bool {
  1732  		// req because we're only testing on one kind of tensor/engine combo
  1733  		a.e = StdEng{}
  1734  		a.oe = StdEng{}
  1735  		a.flag = 0
  1736  		b.e = StdEng{}
  1737  		b.oe = StdEng{}
  1738  		b.flag = 0
  1739  
  1740  		if a.Dtype() != b.Dtype() {
  1741  			return true
  1742  		}
  1743  		if !a.Shape().Eq(b.Shape()) {
  1744  			return true
  1745  		}
  1746  
  1747  		correct, err := a.Mul(b)
  1748  		we, willFailEq := willerr(a, numberTypes, nil)
  1749  		_, ok := a.Engine().(Muler)
  1750  		we = we || !ok
  1751  
  1752  		var ret, reuse *Dense
  1753  		if reuseA {
  1754  			ret, err = a.Mul(b, WithReuse(a))
  1755  			reuse = a
  1756  		} else {
  1757  			ret, err = a.Mul(b, WithReuse(b))
  1758  			reuse = b
  1759  		}
  1760  
  1761  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1762  			if err != nil {
  1763  				return false
  1764  			}
  1765  			return true
  1766  		}
  1767  
  1768  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1769  			return false
  1770  		}
  1771  
  1772  		if reuse != ret {
  1773  			t.Errorf("Expected reuse to be the same as retVal")
  1774  			return false
  1775  		}
  1776  
  1777  		return true
  1778  	}
  1779  	if err := quick.Check(mut, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1780  		t.Errorf("Reuse Mutation test for Mul failed: %v", err)
  1781  	}
  1782  
  1783  }
  1784  func TestDense_DivScalar_reuse(t *testing.T) {
  1785  	inv1 := func(q *Dense) bool {
  1786  		a := q.Clone().(*Dense)
  1787  		b := identityVal(1, q.t)
  1788  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1789  
  1790  		correct := a.Clone().(*Dense)
  1791  		we, willFailEq := willerr(a, numberTypes, nil)
  1792  		_, ok := q.Engine().(Diver)
  1793  		we = we || !ok
  1794  
  1795  		ret, err := a.DivScalar(b, true, WithReuse(reuse))
  1796  		if err, retEarly := qcErrCheck(t, "DivVS", a, b, we, err); retEarly {
  1797  			if err != nil {
  1798  				return false
  1799  			}
  1800  			return true
  1801  		}
  1802  		ret, err = ret.MulScalar(b, true, UseUnsafe())
  1803  
  1804  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1805  			return false
  1806  		}
  1807  		if reuse != ret {
  1808  			t.Errorf("Expected reuse to be the same as retVal")
  1809  			return false
  1810  		}
  1811  
  1812  		return true
  1813  	}
  1814  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1815  		t.Errorf("Inv test for Div (tensor as left, scalar as right) failed: %v", err)
  1816  	}
  1817  
  1818  	mut := func(a, b *Dense, reuseA bool) bool {
  1819  		// req because we're only testing on one kind of tensor/engine combo
  1820  		a.e = StdEng{}
  1821  		a.oe = StdEng{}
  1822  		a.flag = 0
  1823  		b.e = StdEng{}
  1824  		b.oe = StdEng{}
  1825  		b.flag = 0
  1826  
  1827  		if a.Dtype() != b.Dtype() {
  1828  			return true
  1829  		}
  1830  		if !a.Shape().Eq(b.Shape()) {
  1831  			return true
  1832  		}
  1833  
  1834  		correct, err := a.Div(b)
  1835  		we, willFailEq := willerr(a, numberTypes, nil)
  1836  		_, ok := a.Engine().(Diver)
  1837  		we = we || !ok
  1838  
  1839  		var ret, reuse *Dense
  1840  		if reuseA {
  1841  			ret, err = a.Div(b, WithReuse(a))
  1842  			reuse = a
  1843  		} else {
  1844  			ret, err = a.Div(b, WithReuse(b))
  1845  			reuse = b
  1846  		}
  1847  
  1848  		if err, retEarly := qcErrCheck(t, "Div", a, b, we, err); retEarly {
  1849  			if err != nil {
  1850  				return false
  1851  			}
  1852  			return true
  1853  		}
  1854  
  1855  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1856  			return false
  1857  		}
  1858  
  1859  		if reuse != ret {
  1860  			t.Errorf("Expected reuse to be the same as retVal")
  1861  			return false
  1862  		}
  1863  
  1864  		return true
  1865  	}
  1866  	if err := quick.Check(mut, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1867  		t.Errorf("Reuse Mutation test for Div failed: %v", err)
  1868  	}
  1869  
  1870  }
  1871  func TestDense_PowScalar_reuse(t *testing.T) {
  1872  	iden1 := func(q *Dense) bool {
  1873  		a := q.Clone().(*Dense)
  1874  		b := identityVal(1, q.t)
  1875  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1876  
  1877  		correct := a.Clone().(*Dense)
  1878  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
  1879  		_, ok := q.Engine().(Power)
  1880  		we = we || !ok
  1881  
  1882  		ret, err := a.PowScalar(b, true, WithReuse(reuse))
  1883  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
  1884  			if err != nil {
  1885  				return false
  1886  			}
  1887  			return true
  1888  		}
  1889  
  1890  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1891  			return false
  1892  		}
  1893  		if reuse != ret {
  1894  			t.Errorf("Expected reuse to be the same as retVal")
  1895  			return false
  1896  		}
  1897  
  1898  		return true
  1899  	}
  1900  
  1901  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1902  		t.Errorf("Identity test for Pow (tensor as left, scalar as right) failed: %v", err)
  1903  	}
  1904  
  1905  }
  1906  func TestDense_AddScalar_incr(t *testing.T) {
  1907  	iden1 := func(q *Dense) bool {
  1908  		a := q.Clone().(*Dense)
  1909  		b := identityVal(0, q.t)
  1910  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1911  
  1912  		correct := a.Clone().(*Dense)
  1913  		incr.Memset(identityVal(100, a.t))
  1914  		correct.Add(incr, UseUnsafe())
  1915  		we, willFailEq := willerr(a, numberTypes, nil)
  1916  		_, ok := q.Engine().(Adder)
  1917  		we = we || !ok
  1918  
  1919  		ret, err := a.AddScalar(b, true, WithIncr(incr))
  1920  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1921  			if err != nil {
  1922  				return false
  1923  			}
  1924  			return true
  1925  		}
  1926  
  1927  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1928  			return false
  1929  		}
  1930  		return true
  1931  	}
  1932  
  1933  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1934  		t.Errorf("Identity test for Add (tensor as left, scalar as right) failed: %v", err)
  1935  	}
  1936  
  1937  	iden2 := func(q *Dense) bool {
  1938  		a := q.Clone().(*Dense)
  1939  		b := identityVal(0, q.t)
  1940  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1941  		correct := a.Clone().(*Dense)
  1942  		incr.Memset(identityVal(100, a.t))
  1943  		correct.Add(incr, UseUnsafe())
  1944  		we, willFailEq := willerr(a, numberTypes, nil)
  1945  		_, ok := q.Engine().(Adder)
  1946  		we = we || !ok
  1947  
  1948  		ret, err := a.AddScalar(b, false, WithIncr(incr))
  1949  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1950  			if err != nil {
  1951  				return false
  1952  			}
  1953  			return true
  1954  		}
  1955  
  1956  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1957  			return false
  1958  		}
  1959  		return true
  1960  	}
  1961  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1962  		t.Errorf("Identity test for Add (scalar as left, tensor as right) failed: %v", err)
  1963  	}
  1964  
  1965  }
  1966  func TestDense_SubScalar_incr(t *testing.T) {
  1967  	inv1 := func(q *Dense) bool {
  1968  		a := q.Clone().(*Dense)
  1969  		b := identityVal(0, q.t)
  1970  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1971  
  1972  		correct := a.Clone().(*Dense)
  1973  		incr.Memset(identityVal(100, a.t))
  1974  		correct.Add(incr, UseUnsafe())
  1975  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1976  		_, ok := q.Engine().(Suber)
  1977  		we = we || !ok
  1978  
  1979  		ret, err := a.SubScalar(b, true, WithIncr(incr))
  1980  		if err, retEarly := qcErrCheck(t, "SubVS", a, b, we, err); retEarly {
  1981  			if err != nil {
  1982  				return false
  1983  			}
  1984  			return true
  1985  		}
  1986  		ret, err = ret.AddScalar(b, true, UseUnsafe())
  1987  
  1988  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1989  			return false
  1990  		}
  1991  		return true
  1992  	}
  1993  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1994  		t.Errorf("Inv test for Sub (tensor as left, scalar as right) failed: %v", err)
  1995  	}
  1996  
  1997  }
  1998  func TestDense_MulScalar_incr(t *testing.T) {
  1999  	iden1 := func(q *Dense) bool {
  2000  		a := q.Clone().(*Dense)
  2001  		b := identityVal(1, q.t)
  2002  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  2003  
  2004  		correct := a.Clone().(*Dense)
  2005  		incr.Memset(identityVal(100, a.t))
  2006  		correct.Add(incr, UseUnsafe())
  2007  		we, willFailEq := willerr(a, numberTypes, nil)
  2008  		_, ok := q.Engine().(Muler)
  2009  		we = we || !ok
  2010  
  2011  		ret, err := a.MulScalar(b, true, WithIncr(incr))
  2012  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  2013  			if err != nil {
  2014  				return false
  2015  			}
  2016  			return true
  2017  		}
  2018  
  2019  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  2020  			return false
  2021  		}
  2022  		return true
  2023  	}
  2024  
  2025  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  2026  		t.Errorf("Identity test for Mul (tensor as left, scalar as right) failed: %v", err)
  2027  	}
  2028  
  2029  	iden2 := func(q *Dense) bool {
  2030  		a := q.Clone().(*Dense)
  2031  		b := identityVal(1, q.t)
  2032  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  2033  		correct := a.Clone().(*Dense)
  2034  		incr.Memset(identityVal(100, a.t))
  2035  		correct.Add(incr, UseUnsafe())
  2036  		we, willFailEq := willerr(a, numberTypes, nil)
  2037  		_, ok := q.Engine().(Muler)
  2038  		we = we || !ok
  2039  
  2040  		ret, err := a.MulScalar(b, false, WithIncr(incr))
  2041  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  2042  			if err != nil {
  2043  				return false
  2044  			}
  2045  			return true
  2046  		}
  2047  
  2048  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  2049  			return false
  2050  		}
  2051  		return true
  2052  	}
  2053  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  2054  		t.Errorf("Identity test for Mul (scalar as left, tensor as right) failed: %v", err)
  2055  	}
  2056  
  2057  }
  2058  func TestDense_DivScalar_incr(t *testing.T) {
  2059  	inv1 := func(q *Dense) bool {
  2060  		a := q.Clone().(*Dense)
  2061  		b := identityVal(1, q.t)
  2062  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  2063  
  2064  		correct := a.Clone().(*Dense)
  2065  		incr.Memset(identityVal(100, a.t))
  2066  		correct.Add(incr, UseUnsafe())
  2067  		we, willFailEq := willerr(a, numberTypes, nil)
  2068  		_, ok := q.Engine().(Diver)
  2069  		we = we || !ok
  2070  
  2071  		ret, err := a.DivScalar(b, true, WithIncr(incr))
  2072  		if err, retEarly := qcErrCheck(t, "DivVS", a, b, we, err); retEarly {
  2073  			if err != nil {
  2074  				return false
  2075  			}
  2076  			return true
  2077  		}
  2078  		ret, err = ret.MulScalar(b, true, UseUnsafe())
  2079  
  2080  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  2081  			return false
  2082  		}
  2083  		return true
  2084  	}
  2085  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  2086  		t.Errorf("Inv test for Div (tensor as left, scalar as right) failed: %v", err)
  2087  	}
  2088  
  2089  }
  2090  func TestDense_PowScalar_incr(t *testing.T) {
  2091  	iden1 := func(q *Dense) bool {
  2092  		a := q.Clone().(*Dense)
  2093  		b := identityVal(1, q.t)
  2094  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  2095  
  2096  		correct := a.Clone().(*Dense)
  2097  		incr.Memset(identityVal(100, a.t))
  2098  		correct.Add(incr, UseUnsafe())
  2099  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
  2100  		_, ok := q.Engine().(Power)
  2101  		we = we || !ok
  2102  
  2103  		ret, err := a.PowScalar(b, true, WithIncr(incr))
  2104  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
  2105  			if err != nil {
  2106  				return false
  2107  			}
  2108  			return true
  2109  		}
  2110  
  2111  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  2112  			return false
  2113  		}
  2114  		return true
  2115  	}
  2116  
  2117  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  2118  		t.Errorf("Identity test for Pow (tensor as left, scalar as right) failed: %v", err)
  2119  	}
  2120  
  2121  }