gorgonia.org/tensor@v0.9.24/api_arith_generated_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 TestAdd(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 := Add(a, 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 TestSub(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 := Sub(a, 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 = Add(ret, 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 TestMul(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 := Mul(a, 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 TestDiv(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 := Div(a, 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 = Mul(ret, 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 TestPow(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 := Pow(a, 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 TestAdd_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 := Add(a, 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 TestSub_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 := Sub(a, 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 = Add(ret, 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 TestMul_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 := Mul(a, 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 TestDiv_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 := Div(a, 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 = Mul(ret, 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 TestPow_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 := Pow(a, 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 TestAdd_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 := Add(a, 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  }
   333  func TestSub_reuse(t *testing.T) {
   334  	inv := func(a *Dense) bool {
   335  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   336  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
   337  		correct := a.Clone().(*Dense)
   338  		we, willFailEq := willerr(a, numberTypes, nil)
   339  		_, ok := a.Engine().(Suber)
   340  		we = we || !ok
   341  
   342  		ret, err := Sub(a, b, WithReuse(reuse))
   343  		if err, retEarly := qcErrCheck(t, "Sub", a, b, we, err); retEarly {
   344  			if err != nil {
   345  				return false
   346  			}
   347  			return true
   348  		}
   349  		ret, err = Add(ret, b, UseUnsafe())
   350  
   351  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   352  			return false
   353  		}
   354  		if reuse != ret {
   355  			t.Errorf("Expected reuse to be the same as retVal")
   356  			return false
   357  		}
   358  
   359  		return true
   360  	}
   361  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   362  		t.Errorf("Inv test for Sub failed: %v", err)
   363  	}
   364  }
   365  func TestMul_reuse(t *testing.T) {
   366  	iden := func(a *Dense) bool {
   367  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   368  		b.Memset(identityVal(1, a.t))
   369  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
   370  		correct := a.Clone().(*Dense)
   371  		we, willFailEq := willerr(a, numberTypes, nil)
   372  		_, ok := a.Engine().(Muler)
   373  		we = we || !ok
   374  
   375  		ret, err := Mul(a, b, WithReuse(reuse))
   376  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
   377  			if err != nil {
   378  				return false
   379  			}
   380  			return true
   381  		}
   382  
   383  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   384  			return false
   385  		}
   386  		if reuse != ret {
   387  			t.Errorf("Expected reuse to be the same as retVal")
   388  			return false
   389  		}
   390  
   391  		return true
   392  	}
   393  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   394  		t.Errorf("Identity test for Mul failed: %v", err)
   395  	}
   396  
   397  }
   398  func TestDiv_reuse(t *testing.T) {
   399  	inv := func(a *Dense) bool {
   400  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   401  		b.Memset(identityVal(1, a.t))
   402  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
   403  		correct := a.Clone().(*Dense)
   404  		we, willFailEq := willerr(a, numberTypes, nil)
   405  		_, ok := a.Engine().(Diver)
   406  		we = we || !ok
   407  
   408  		ret, err := Div(a, b, WithReuse(reuse))
   409  		if err, retEarly := qcErrCheck(t, "Div", a, b, we, err); retEarly {
   410  			if err != nil {
   411  				return false
   412  			}
   413  			return true
   414  		}
   415  		ret, err = Mul(ret, b, UseUnsafe())
   416  
   417  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   418  			return false
   419  		}
   420  		if reuse != ret {
   421  			t.Errorf("Expected reuse to be the same as retVal")
   422  			return false
   423  		}
   424  
   425  		return true
   426  	}
   427  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   428  		t.Errorf("Inv test for Div failed: %v", err)
   429  	}
   430  }
   431  func TestPow_reuse(t *testing.T) {
   432  	iden := func(a *Dense) bool {
   433  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   434  		b.Memset(identityVal(1, a.t))
   435  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
   436  		correct := a.Clone().(*Dense)
   437  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
   438  		_, ok := a.Engine().(Power)
   439  		we = we || !ok
   440  
   441  		ret, err := Pow(a, b, WithReuse(reuse))
   442  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
   443  			if err != nil {
   444  				return false
   445  			}
   446  			return true
   447  		}
   448  
   449  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   450  			return false
   451  		}
   452  		if reuse != ret {
   453  			t.Errorf("Expected reuse to be the same as retVal")
   454  			return false
   455  		}
   456  
   457  		return true
   458  	}
   459  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   460  		t.Errorf("Identity test for Pow failed: %v", err)
   461  	}
   462  
   463  }
   464  func TestAdd_incr(t *testing.T) {
   465  	iden := func(a *Dense) bool {
   466  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   467  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   468  		correct := a.Clone().(*Dense)
   469  		incr.Memset(identityVal(100, a.t))
   470  		correct.Add(incr, UseUnsafe())
   471  		we, willFailEq := willerr(a, numberTypes, nil)
   472  		_, ok := a.Engine().(Adder)
   473  		we = we || !ok
   474  
   475  		ret, err := Add(a, b, WithIncr(incr))
   476  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   477  			if err != nil {
   478  				return false
   479  			}
   480  			return true
   481  		}
   482  
   483  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   484  			return false
   485  		}
   486  		return true
   487  	}
   488  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   489  		t.Errorf("Identity test for Add failed: %v", err)
   490  	}
   491  
   492  }
   493  func TestSub_incr(t *testing.T) {
   494  	inv := func(a *Dense) bool {
   495  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   496  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   497  		correct := a.Clone().(*Dense)
   498  		incr.Memset(identityVal(100, a.t))
   499  		correct.Add(incr, UseUnsafe())
   500  		we, willFailEq := willerr(a, numberTypes, nil)
   501  		_, ok := a.Engine().(Suber)
   502  		we = we || !ok
   503  
   504  		ret, err := Sub(a, b, WithIncr(incr))
   505  		if err, retEarly := qcErrCheck(t, "Sub", a, b, we, err); retEarly {
   506  			if err != nil {
   507  				return false
   508  			}
   509  			return true
   510  		}
   511  		ret, err = Add(ret, b, UseUnsafe())
   512  
   513  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   514  			return false
   515  		}
   516  		return true
   517  	}
   518  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   519  		t.Errorf("Inv test for Sub failed: %v", err)
   520  	}
   521  }
   522  func TestMul_incr(t *testing.T) {
   523  	iden := func(a *Dense) bool {
   524  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   525  		b.Memset(identityVal(1, a.t))
   526  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   527  		correct := a.Clone().(*Dense)
   528  		incr.Memset(identityVal(100, a.t))
   529  		correct.Add(incr, UseUnsafe())
   530  		we, willFailEq := willerr(a, numberTypes, nil)
   531  		_, ok := a.Engine().(Muler)
   532  		we = we || !ok
   533  
   534  		ret, err := Mul(a, b, WithIncr(incr))
   535  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
   536  			if err != nil {
   537  				return false
   538  			}
   539  			return true
   540  		}
   541  
   542  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   543  			return false
   544  		}
   545  		return true
   546  	}
   547  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   548  		t.Errorf("Identity test for Mul failed: %v", err)
   549  	}
   550  
   551  }
   552  func TestDiv_incr(t *testing.T) {
   553  	inv := func(a *Dense) bool {
   554  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   555  		b.Memset(identityVal(1, a.t))
   556  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   557  		correct := a.Clone().(*Dense)
   558  		incr.Memset(identityVal(100, a.t))
   559  		correct.Add(incr, UseUnsafe())
   560  		we, willFailEq := willerr(a, numberTypes, nil)
   561  		_, ok := a.Engine().(Diver)
   562  		we = we || !ok
   563  
   564  		ret, err := Div(a, b, WithIncr(incr))
   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 = Mul(ret, b, UseUnsafe())
   572  
   573  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   574  			return false
   575  		}
   576  		return true
   577  	}
   578  	if err := quick.Check(inv, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   579  		t.Errorf("Inv test for Div failed: %v", err)
   580  	}
   581  }
   582  func TestPow_incr(t *testing.T) {
   583  	iden := func(a *Dense) bool {
   584  		b := New(Of(a.t), WithShape(a.Shape().Clone()...), WithEngine(a.Engine()))
   585  		b.Memset(identityVal(1, a.t))
   586  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
   587  		correct := a.Clone().(*Dense)
   588  		incr.Memset(identityVal(100, a.t))
   589  		correct.Add(incr, UseUnsafe())
   590  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
   591  		_, ok := a.Engine().(Power)
   592  		we = we || !ok
   593  
   594  		ret, err := Pow(a, b, WithIncr(incr))
   595  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
   596  			if err != nil {
   597  				return false
   598  			}
   599  			return true
   600  		}
   601  
   602  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   603  			return false
   604  		}
   605  		return true
   606  	}
   607  	if err := quick.Check(iden, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   608  		t.Errorf("Identity test for Pow failed: %v", err)
   609  	}
   610  
   611  }
   612  func TestAddScalar(t *testing.T) {
   613  	iden1 := func(q *Dense) bool {
   614  		a := q.Clone().(*Dense)
   615  		b := identityVal(0, q.t)
   616  
   617  		correct := a.Clone().(*Dense)
   618  		we, willFailEq := willerr(a, numberTypes, nil)
   619  		_, ok := q.Engine().(Adder)
   620  		we = we || !ok
   621  
   622  		ret, err := Add(a, b)
   623  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   624  			if err != nil {
   625  				return false
   626  			}
   627  			return true
   628  		}
   629  
   630  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   631  			return false
   632  		}
   633  		return true
   634  	}
   635  
   636  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   637  		t.Errorf("Identity test for Add (tensor as left, scalar as right) failed: %v", err)
   638  	}
   639  
   640  	iden2 := func(q *Dense) bool {
   641  		a := q.Clone().(*Dense)
   642  		b := identityVal(0, q.t)
   643  		correct := a.Clone().(*Dense)
   644  		we, willFailEq := willerr(a, numberTypes, nil)
   645  		_, ok := q.Engine().(Adder)
   646  		we = we || !ok
   647  
   648  		ret, err := Add(b, a)
   649  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   650  			if err != nil {
   651  				return false
   652  			}
   653  			return true
   654  		}
   655  
   656  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   657  			return false
   658  		}
   659  		return true
   660  	}
   661  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   662  		t.Errorf("Identity test for Add (scalar as left, tensor as right) failed: %v", err)
   663  	}
   664  
   665  	type Foo int
   666  	wt1 := func(a *Dense) bool {
   667  		b := Foo(0)
   668  		ret, err := Add(a, b)
   669  		if err == nil {
   670  			return false
   671  		}
   672  		_ = ret
   673  		return true
   674  	}
   675  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   676  		t.Errorf("WrongType test for Add (tensor as left, scalar as right) failed: %v", err)
   677  	}
   678  
   679  	wt2 := func(a *Dense) bool {
   680  		b := Foo(0)
   681  		ret, err := Add(b, a)
   682  		if err == nil {
   683  			return false
   684  		}
   685  		_ = ret
   686  		return true
   687  	}
   688  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   689  		t.Errorf("WrongType test for Add (tensor as right, scalar as left) failed: %v", err)
   690  	}
   691  }
   692  func TestSubScalar(t *testing.T) {
   693  	inv1 := func(q *Dense) bool {
   694  		a := q.Clone().(*Dense)
   695  		b := identityVal(0, q.t)
   696  
   697  		correct := a.Clone().(*Dense)
   698  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
   699  		_, ok := q.Engine().(Suber)
   700  		we = we || !ok
   701  
   702  		ret, err := Sub(a, b)
   703  		if err, retEarly := qcErrCheck(t, "SubVS", a, b, we, err); retEarly {
   704  			if err != nil {
   705  				return false
   706  			}
   707  			return true
   708  		}
   709  		ret, err = Add(ret, b, UseUnsafe())
   710  
   711  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   712  			return false
   713  		}
   714  		return true
   715  	}
   716  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   717  		t.Errorf("Inv test for Sub (tensor as left, scalar as right) failed: %v", err)
   718  	}
   719  
   720  	inv2 := func(q *Dense) bool {
   721  		a := q.Clone().(*Dense)
   722  		b := identityVal(0, q.t)
   723  		correct := a.Clone().(*Dense)
   724  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
   725  		_, ok := q.Engine().(Suber)
   726  		we = we || !ok
   727  
   728  		ret, err := Sub(b, a)
   729  		if err, retEarly := qcErrCheck(t, "SubSV", a, b, we, err); retEarly {
   730  			if err != nil {
   731  				return false
   732  			}
   733  			return true
   734  		}
   735  		ret, err = Sub(b, ret, UseUnsafe())
   736  
   737  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   738  			return false
   739  		}
   740  		return true
   741  	}
   742  	if err := quick.Check(inv2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   743  		t.Errorf("Inv test for Sub (scalar as left, tensor as right) failed: %v", err)
   744  	}
   745  	type Foo int
   746  	wt1 := func(a *Dense) bool {
   747  		b := Foo(0)
   748  		ret, err := Sub(a, b)
   749  		if err == nil {
   750  			return false
   751  		}
   752  		_ = ret
   753  		return true
   754  	}
   755  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   756  		t.Errorf("WrongType test for Sub (tensor as left, scalar as right) failed: %v", err)
   757  	}
   758  
   759  	wt2 := func(a *Dense) bool {
   760  		b := Foo(0)
   761  		ret, err := Sub(b, a)
   762  		if err == nil {
   763  			return false
   764  		}
   765  		_ = ret
   766  		return true
   767  	}
   768  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   769  		t.Errorf("WrongType test for Sub (tensor as right, scalar as left) failed: %v", err)
   770  	}
   771  }
   772  func TestMulScalar(t *testing.T) {
   773  	iden1 := func(q *Dense) bool {
   774  		a := q.Clone().(*Dense)
   775  		b := identityVal(1, q.t)
   776  
   777  		correct := a.Clone().(*Dense)
   778  		we, willFailEq := willerr(a, numberTypes, nil)
   779  		_, ok := q.Engine().(Muler)
   780  		we = we || !ok
   781  
   782  		ret, err := Mul(a, b)
   783  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
   784  			if err != nil {
   785  				return false
   786  			}
   787  			return true
   788  		}
   789  
   790  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   791  			return false
   792  		}
   793  		return true
   794  	}
   795  
   796  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   797  		t.Errorf("Identity test for Mul (tensor as left, scalar as right) failed: %v", err)
   798  	}
   799  
   800  	iden2 := func(q *Dense) bool {
   801  		a := q.Clone().(*Dense)
   802  		b := identityVal(1, q.t)
   803  		correct := a.Clone().(*Dense)
   804  		we, willFailEq := willerr(a, numberTypes, nil)
   805  		_, ok := q.Engine().(Muler)
   806  		we = we || !ok
   807  
   808  		ret, err := Mul(b, a)
   809  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
   810  			if err != nil {
   811  				return false
   812  			}
   813  			return true
   814  		}
   815  
   816  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   817  			return false
   818  		}
   819  		return true
   820  	}
   821  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   822  		t.Errorf("Identity test for Mul (scalar as left, tensor as right) failed: %v", err)
   823  	}
   824  
   825  	type Foo int
   826  	wt1 := func(a *Dense) bool {
   827  		b := Foo(0)
   828  		ret, err := Mul(a, b)
   829  		if err == nil {
   830  			return false
   831  		}
   832  		_ = ret
   833  		return true
   834  	}
   835  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   836  		t.Errorf("WrongType test for Mul (tensor as left, scalar as right) failed: %v", err)
   837  	}
   838  
   839  	wt2 := func(a *Dense) bool {
   840  		b := Foo(0)
   841  		ret, err := Mul(b, a)
   842  		if err == nil {
   843  			return false
   844  		}
   845  		_ = ret
   846  		return true
   847  	}
   848  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   849  		t.Errorf("WrongType test for Mul (tensor as right, scalar as left) failed: %v", err)
   850  	}
   851  }
   852  func TestDivScalar(t *testing.T) {
   853  	inv1 := func(q *Dense) bool {
   854  		a := q.Clone().(*Dense)
   855  		b := identityVal(1, q.t)
   856  
   857  		correct := a.Clone().(*Dense)
   858  		we, willFailEq := willerr(a, numberTypes, nil)
   859  		_, ok := q.Engine().(Diver)
   860  		we = we || !ok
   861  
   862  		ret, err := Div(a, b)
   863  		if err, retEarly := qcErrCheck(t, "DivVS", a, b, we, err); retEarly {
   864  			if err != nil {
   865  				return false
   866  			}
   867  			return true
   868  		}
   869  		ret, err = Mul(ret, b, UseUnsafe())
   870  
   871  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   872  			return false
   873  		}
   874  		return true
   875  	}
   876  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   877  		t.Errorf("Inv test for Div (tensor as left, scalar as right) failed: %v", err)
   878  	}
   879  
   880  	type Foo int
   881  	wt1 := func(a *Dense) bool {
   882  		b := Foo(0)
   883  		ret, err := Div(a, b)
   884  		if err == nil {
   885  			return false
   886  		}
   887  		_ = ret
   888  		return true
   889  	}
   890  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   891  		t.Errorf("WrongType test for Div (tensor as left, scalar as right) failed: %v", err)
   892  	}
   893  
   894  	wt2 := func(a *Dense) bool {
   895  		b := Foo(0)
   896  		ret, err := Div(b, a)
   897  		if err == nil {
   898  			return false
   899  		}
   900  		_ = ret
   901  		return true
   902  	}
   903  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   904  		t.Errorf("WrongType test for Div (tensor as right, scalar as left) failed: %v", err)
   905  	}
   906  }
   907  func TestPowScalar(t *testing.T) {
   908  	iden1 := func(q *Dense) bool {
   909  		a := q.Clone().(*Dense)
   910  		b := identityVal(1, q.t)
   911  
   912  		correct := a.Clone().(*Dense)
   913  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
   914  		_, ok := q.Engine().(Power)
   915  		we = we || !ok
   916  
   917  		ret, err := Pow(a, b)
   918  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
   919  			if err != nil {
   920  				return false
   921  			}
   922  			return true
   923  		}
   924  
   925  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   926  			return false
   927  		}
   928  		return true
   929  	}
   930  
   931  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   932  		t.Errorf("Identity test for Pow (tensor as left, scalar as right) failed: %v", err)
   933  	}
   934  
   935  	type Foo int
   936  	wt1 := func(a *Dense) bool {
   937  		b := Foo(0)
   938  		ret, err := Pow(a, b)
   939  		if err == nil {
   940  			return false
   941  		}
   942  		_ = ret
   943  		return true
   944  	}
   945  	if err := quick.Check(wt1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   946  		t.Errorf("WrongType test for Pow (tensor as left, scalar as right) failed: %v", err)
   947  	}
   948  
   949  	wt2 := func(a *Dense) bool {
   950  		b := Foo(0)
   951  		ret, err := Pow(b, a)
   952  		if err == nil {
   953  			return false
   954  		}
   955  		_ = ret
   956  		return true
   957  	}
   958  	if err := quick.Check(wt2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   959  		t.Errorf("WrongType test for Pow (tensor as right, scalar as left) failed: %v", err)
   960  	}
   961  }
   962  func TestAddScalar_unsafe(t *testing.T) {
   963  	iden1 := func(q *Dense) bool {
   964  		a := q.Clone().(*Dense)
   965  		b := identityVal(0, q.t)
   966  
   967  		correct := a.Clone().(*Dense)
   968  		we, willFailEq := willerr(a, numberTypes, nil)
   969  		_, ok := q.Engine().(Adder)
   970  		we = we || !ok
   971  
   972  		ret, err := Add(a, b, UseUnsafe())
   973  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
   974  			if err != nil {
   975  				return false
   976  			}
   977  			return true
   978  		}
   979  
   980  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
   981  			return false
   982  		}
   983  		if ret != a {
   984  			t.Errorf("Expected ret to be the same as a")
   985  			return false
   986  		}
   987  
   988  		return true
   989  	}
   990  
   991  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   992  		t.Errorf("Identity test for Add (tensor as left, scalar as right) failed: %v", err)
   993  	}
   994  
   995  	iden2 := func(q *Dense) bool {
   996  		a := q.Clone().(*Dense)
   997  		b := identityVal(0, q.t)
   998  		correct := a.Clone().(*Dense)
   999  		we, willFailEq := willerr(a, numberTypes, nil)
  1000  		_, ok := q.Engine().(Adder)
  1001  		we = we || !ok
  1002  
  1003  		ret, err := Add(b, a, UseUnsafe())
  1004  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1005  			if err != nil {
  1006  				return false
  1007  			}
  1008  			return true
  1009  		}
  1010  
  1011  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1012  			return false
  1013  		}
  1014  		if ret != a {
  1015  			t.Errorf("Expected ret to be the same as a")
  1016  			return false
  1017  		}
  1018  
  1019  		return true
  1020  	}
  1021  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1022  		t.Errorf("Identity test for Add (scalar as left, tensor as right) failed: %v", err)
  1023  	}
  1024  
  1025  }
  1026  func TestSubScalar_unsafe(t *testing.T) {
  1027  	inv1 := func(q *Dense) bool {
  1028  		a := q.Clone().(*Dense)
  1029  		b := identityVal(0, q.t)
  1030  
  1031  		correct := a.Clone().(*Dense)
  1032  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1033  		_, ok := q.Engine().(Suber)
  1034  		we = we || !ok
  1035  
  1036  		ret, err := Sub(a, b, UseUnsafe())
  1037  		if err, retEarly := qcErrCheck(t, "SubVS", a, b, we, err); retEarly {
  1038  			if err != nil {
  1039  				return false
  1040  			}
  1041  			return true
  1042  		}
  1043  		ret, err = Add(ret, b, UseUnsafe())
  1044  
  1045  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1046  			return false
  1047  		}
  1048  		if ret != a {
  1049  			t.Errorf("Expected ret to be the same as a")
  1050  			return false
  1051  		}
  1052  
  1053  		return true
  1054  	}
  1055  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1056  		t.Errorf("Inv test for Sub (tensor as left, scalar as right) failed: %v", err)
  1057  	}
  1058  
  1059  	inv2 := func(q *Dense) bool {
  1060  		a := q.Clone().(*Dense)
  1061  		b := identityVal(0, q.t)
  1062  		correct := a.Clone().(*Dense)
  1063  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1064  		_, ok := q.Engine().(Suber)
  1065  		we = we || !ok
  1066  
  1067  		ret, err := Sub(b, a, UseUnsafe())
  1068  		if err, retEarly := qcErrCheck(t, "SubSV", a, b, we, err); retEarly {
  1069  			if err != nil {
  1070  				return false
  1071  			}
  1072  			return true
  1073  		}
  1074  		ret, err = Sub(b, ret, UseUnsafe())
  1075  
  1076  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1077  			return false
  1078  		}
  1079  		if ret != a {
  1080  			t.Errorf("Expected ret to be the same as a")
  1081  			return false
  1082  		}
  1083  
  1084  		return true
  1085  	}
  1086  	if err := quick.Check(inv2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1087  		t.Errorf("Inv test for Sub (scalar as left, tensor as right) failed: %v", err)
  1088  	}
  1089  }
  1090  func TestMulScalar_unsafe(t *testing.T) {
  1091  	iden1 := func(q *Dense) bool {
  1092  		a := q.Clone().(*Dense)
  1093  		b := identityVal(1, q.t)
  1094  
  1095  		correct := a.Clone().(*Dense)
  1096  		we, willFailEq := willerr(a, numberTypes, nil)
  1097  		_, ok := q.Engine().(Muler)
  1098  		we = we || !ok
  1099  
  1100  		ret, err := Mul(a, b, UseUnsafe())
  1101  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1102  			if err != nil {
  1103  				return false
  1104  			}
  1105  			return true
  1106  		}
  1107  
  1108  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1109  			return false
  1110  		}
  1111  		if ret != a {
  1112  			t.Errorf("Expected ret to be the same as a")
  1113  			return false
  1114  		}
  1115  
  1116  		return true
  1117  	}
  1118  
  1119  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1120  		t.Errorf("Identity test for Mul (tensor as left, scalar as right) failed: %v", err)
  1121  	}
  1122  
  1123  	iden2 := func(q *Dense) bool {
  1124  		a := q.Clone().(*Dense)
  1125  		b := identityVal(1, q.t)
  1126  		correct := a.Clone().(*Dense)
  1127  		we, willFailEq := willerr(a, numberTypes, nil)
  1128  		_, ok := q.Engine().(Muler)
  1129  		we = we || !ok
  1130  
  1131  		ret, err := Mul(b, a, UseUnsafe())
  1132  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1133  			if err != nil {
  1134  				return false
  1135  			}
  1136  			return true
  1137  		}
  1138  
  1139  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1140  			return false
  1141  		}
  1142  		if ret != a {
  1143  			t.Errorf("Expected ret to be the same as a")
  1144  			return false
  1145  		}
  1146  
  1147  		return true
  1148  	}
  1149  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1150  		t.Errorf("Identity test for Mul (scalar as left, tensor as right) failed: %v", err)
  1151  	}
  1152  
  1153  }
  1154  func TestDivScalar_unsafe(t *testing.T) {
  1155  	inv1 := func(q *Dense) bool {
  1156  		a := q.Clone().(*Dense)
  1157  		b := identityVal(1, q.t)
  1158  
  1159  		correct := a.Clone().(*Dense)
  1160  		we, willFailEq := willerr(a, numberTypes, nil)
  1161  		_, ok := q.Engine().(Diver)
  1162  		we = we || !ok
  1163  
  1164  		ret, err := Div(a, b, UseUnsafe())
  1165  		if err, retEarly := qcErrCheck(t, "DivVS", a, b, we, err); retEarly {
  1166  			if err != nil {
  1167  				return false
  1168  			}
  1169  			return true
  1170  		}
  1171  		ret, err = Mul(ret, b, UseUnsafe())
  1172  
  1173  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1174  			return false
  1175  		}
  1176  		if ret != a {
  1177  			t.Errorf("Expected ret to be the same as a")
  1178  			return false
  1179  		}
  1180  
  1181  		return true
  1182  	}
  1183  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1184  		t.Errorf("Inv test for Div (tensor as left, scalar as right) failed: %v", err)
  1185  	}
  1186  
  1187  }
  1188  func TestPowScalar_unsafe(t *testing.T) {
  1189  	iden1 := func(q *Dense) bool {
  1190  		a := q.Clone().(*Dense)
  1191  		b := identityVal(1, q.t)
  1192  
  1193  		correct := a.Clone().(*Dense)
  1194  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
  1195  		_, ok := q.Engine().(Power)
  1196  		we = we || !ok
  1197  
  1198  		ret, err := Pow(a, b, UseUnsafe())
  1199  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
  1200  			if err != nil {
  1201  				return false
  1202  			}
  1203  			return true
  1204  		}
  1205  
  1206  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1207  			return false
  1208  		}
  1209  		if ret != a {
  1210  			t.Errorf("Expected ret to be the same as a")
  1211  			return false
  1212  		}
  1213  
  1214  		return true
  1215  	}
  1216  
  1217  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1218  		t.Errorf("Identity test for Pow (tensor as left, scalar as right) failed: %v", err)
  1219  	}
  1220  
  1221  }
  1222  func TestAddScalar_reuse(t *testing.T) {
  1223  	iden1 := func(q *Dense) bool {
  1224  		a := q.Clone().(*Dense)
  1225  		b := identityVal(0, q.t)
  1226  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1227  
  1228  		correct := a.Clone().(*Dense)
  1229  		we, willFailEq := willerr(a, numberTypes, nil)
  1230  		_, ok := q.Engine().(Adder)
  1231  		we = we || !ok
  1232  
  1233  		ret, err := Add(a, b, WithReuse(reuse))
  1234  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1235  			if err != nil {
  1236  				return false
  1237  			}
  1238  			return true
  1239  		}
  1240  
  1241  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1242  			return false
  1243  		}
  1244  		if reuse != ret {
  1245  			t.Errorf("Expected reuse to be the same as retVal")
  1246  			return false
  1247  		}
  1248  
  1249  		return true
  1250  	}
  1251  
  1252  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1253  		t.Errorf("Identity test for Add (tensor as left, scalar as right) failed: %v", err)
  1254  	}
  1255  
  1256  	iden2 := func(q *Dense) bool {
  1257  		a := q.Clone().(*Dense)
  1258  		b := identityVal(0, q.t)
  1259  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1260  		correct := a.Clone().(*Dense)
  1261  		we, willFailEq := willerr(a, numberTypes, nil)
  1262  		_, ok := q.Engine().(Adder)
  1263  		we = we || !ok
  1264  
  1265  		ret, err := Add(b, a, WithReuse(reuse))
  1266  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1267  			if err != nil {
  1268  				return false
  1269  			}
  1270  			return true
  1271  		}
  1272  
  1273  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1274  			return false
  1275  		}
  1276  		if reuse != ret {
  1277  			t.Errorf("Expected reuse to be the same as retVal")
  1278  			return false
  1279  		}
  1280  
  1281  		return true
  1282  	}
  1283  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1284  		t.Errorf("Identity test for Add (scalar as left, tensor as right) failed: %v", err)
  1285  	}
  1286  
  1287  }
  1288  func TestSubScalar_reuse(t *testing.T) {
  1289  	inv1 := func(q *Dense) bool {
  1290  		a := q.Clone().(*Dense)
  1291  		b := identityVal(0, q.t)
  1292  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1293  
  1294  		correct := a.Clone().(*Dense)
  1295  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1296  		_, ok := q.Engine().(Suber)
  1297  		we = we || !ok
  1298  
  1299  		ret, err := Sub(a, b, WithReuse(reuse))
  1300  		if err, retEarly := qcErrCheck(t, "SubVS", a, b, we, err); retEarly {
  1301  			if err != nil {
  1302  				return false
  1303  			}
  1304  			return true
  1305  		}
  1306  		ret, err = Add(ret, b, UseUnsafe())
  1307  
  1308  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1309  			return false
  1310  		}
  1311  		if reuse != ret {
  1312  			t.Errorf("Expected reuse to be the same as retVal")
  1313  			return false
  1314  		}
  1315  
  1316  		return true
  1317  	}
  1318  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1319  		t.Errorf("Inv test for Sub (tensor as left, scalar as right) failed: %v", err)
  1320  	}
  1321  
  1322  	inv2 := func(q *Dense) bool {
  1323  		a := q.Clone().(*Dense)
  1324  		b := identityVal(0, q.t)
  1325  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1326  		correct := a.Clone().(*Dense)
  1327  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1328  		_, ok := q.Engine().(Suber)
  1329  		we = we || !ok
  1330  
  1331  		ret, err := Sub(b, a, WithReuse(reuse))
  1332  		if err, retEarly := qcErrCheck(t, "SubSV", a, b, we, err); retEarly {
  1333  			if err != nil {
  1334  				return false
  1335  			}
  1336  			return true
  1337  		}
  1338  		ret, err = Sub(b, ret, UseUnsafe())
  1339  
  1340  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1341  			return false
  1342  		}
  1343  		if reuse != ret {
  1344  			t.Errorf("Expected reuse to be the same as retVal")
  1345  			return false
  1346  		}
  1347  
  1348  		return true
  1349  	}
  1350  	if err := quick.Check(inv2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1351  		t.Errorf("Inv test for Sub (scalar as left, tensor as right) failed: %v", err)
  1352  	}
  1353  }
  1354  func TestMulScalar_reuse(t *testing.T) {
  1355  	iden1 := func(q *Dense) bool {
  1356  		a := q.Clone().(*Dense)
  1357  		b := identityVal(1, q.t)
  1358  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1359  
  1360  		correct := a.Clone().(*Dense)
  1361  		we, willFailEq := willerr(a, numberTypes, nil)
  1362  		_, ok := q.Engine().(Muler)
  1363  		we = we || !ok
  1364  
  1365  		ret, err := Mul(a, b, WithReuse(reuse))
  1366  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1367  			if err != nil {
  1368  				return false
  1369  			}
  1370  			return true
  1371  		}
  1372  
  1373  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1374  			return false
  1375  		}
  1376  		if reuse != ret {
  1377  			t.Errorf("Expected reuse to be the same as retVal")
  1378  			return false
  1379  		}
  1380  
  1381  		return true
  1382  	}
  1383  
  1384  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1385  		t.Errorf("Identity test for Mul (tensor as left, scalar as right) failed: %v", err)
  1386  	}
  1387  
  1388  	iden2 := func(q *Dense) bool {
  1389  		a := q.Clone().(*Dense)
  1390  		b := identityVal(1, q.t)
  1391  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1392  		correct := a.Clone().(*Dense)
  1393  		we, willFailEq := willerr(a, numberTypes, nil)
  1394  		_, ok := q.Engine().(Muler)
  1395  		we = we || !ok
  1396  
  1397  		ret, err := Mul(b, a, WithReuse(reuse))
  1398  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1399  			if err != nil {
  1400  				return false
  1401  			}
  1402  			return true
  1403  		}
  1404  
  1405  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1406  			return false
  1407  		}
  1408  		if reuse != ret {
  1409  			t.Errorf("Expected reuse to be the same as retVal")
  1410  			return false
  1411  		}
  1412  
  1413  		return true
  1414  	}
  1415  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1416  		t.Errorf("Identity test for Mul (scalar as left, tensor as right) failed: %v", err)
  1417  	}
  1418  
  1419  }
  1420  func TestDivScalar_reuse(t *testing.T) {
  1421  	inv1 := func(q *Dense) bool {
  1422  		a := q.Clone().(*Dense)
  1423  		b := identityVal(1, q.t)
  1424  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1425  
  1426  		correct := a.Clone().(*Dense)
  1427  		we, willFailEq := willerr(a, numberTypes, nil)
  1428  		_, ok := q.Engine().(Diver)
  1429  		we = we || !ok
  1430  
  1431  		ret, err := Div(a, b, WithReuse(reuse))
  1432  		if err, retEarly := qcErrCheck(t, "DivVS", a, b, we, err); retEarly {
  1433  			if err != nil {
  1434  				return false
  1435  			}
  1436  			return true
  1437  		}
  1438  		ret, err = Mul(ret, b, UseUnsafe())
  1439  
  1440  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1441  			return false
  1442  		}
  1443  		if reuse != ret {
  1444  			t.Errorf("Expected reuse to be the same as retVal")
  1445  			return false
  1446  		}
  1447  
  1448  		return true
  1449  	}
  1450  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1451  		t.Errorf("Inv test for Div (tensor as left, scalar as right) failed: %v", err)
  1452  	}
  1453  
  1454  }
  1455  func TestPowScalar_reuse(t *testing.T) {
  1456  	iden1 := func(q *Dense) bool {
  1457  		a := q.Clone().(*Dense)
  1458  		b := identityVal(1, q.t)
  1459  		reuse := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1460  
  1461  		correct := a.Clone().(*Dense)
  1462  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
  1463  		_, ok := q.Engine().(Power)
  1464  		we = we || !ok
  1465  
  1466  		ret, err := Pow(a, b, WithReuse(reuse))
  1467  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
  1468  			if err != nil {
  1469  				return false
  1470  			}
  1471  			return true
  1472  		}
  1473  
  1474  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1475  			return false
  1476  		}
  1477  		if reuse != ret {
  1478  			t.Errorf("Expected reuse to be the same as retVal")
  1479  			return false
  1480  		}
  1481  
  1482  		return true
  1483  	}
  1484  
  1485  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1486  		t.Errorf("Identity test for Pow (tensor as left, scalar as right) failed: %v", err)
  1487  	}
  1488  
  1489  }
  1490  func TestAddScalar_incr(t *testing.T) {
  1491  	iden1 := func(q *Dense) bool {
  1492  		a := q.Clone().(*Dense)
  1493  		b := identityVal(0, q.t)
  1494  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1495  
  1496  		correct := a.Clone().(*Dense)
  1497  		incr.Memset(identityVal(100, a.t))
  1498  		correct.Add(incr, UseUnsafe())
  1499  		we, willFailEq := willerr(a, numberTypes, nil)
  1500  		_, ok := q.Engine().(Adder)
  1501  		we = we || !ok
  1502  
  1503  		ret, err := Add(a, b, WithIncr(incr))
  1504  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1505  			if err != nil {
  1506  				return false
  1507  			}
  1508  			return true
  1509  		}
  1510  
  1511  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1512  			return false
  1513  		}
  1514  		return true
  1515  	}
  1516  
  1517  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1518  		t.Errorf("Identity test for Add (tensor as left, scalar as right) failed: %v", err)
  1519  	}
  1520  
  1521  	iden2 := func(q *Dense) bool {
  1522  		a := q.Clone().(*Dense)
  1523  		b := identityVal(0, q.t)
  1524  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1525  		correct := a.Clone().(*Dense)
  1526  		incr.Memset(identityVal(100, a.t))
  1527  		correct.Add(incr, UseUnsafe())
  1528  		we, willFailEq := willerr(a, numberTypes, nil)
  1529  		_, ok := q.Engine().(Adder)
  1530  		we = we || !ok
  1531  
  1532  		ret, err := Add(b, a, WithIncr(incr))
  1533  		if err, retEarly := qcErrCheck(t, "Add", a, b, we, err); retEarly {
  1534  			if err != nil {
  1535  				return false
  1536  			}
  1537  			return true
  1538  		}
  1539  
  1540  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1541  			return false
  1542  		}
  1543  		return true
  1544  	}
  1545  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1546  		t.Errorf("Identity test for Add (scalar as left, tensor as right) failed: %v", err)
  1547  	}
  1548  
  1549  }
  1550  func TestSubScalar_incr(t *testing.T) {
  1551  	inv1 := func(q *Dense) bool {
  1552  		a := q.Clone().(*Dense)
  1553  		b := identityVal(0, q.t)
  1554  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1555  
  1556  		correct := a.Clone().(*Dense)
  1557  		incr.Memset(identityVal(100, a.t))
  1558  		correct.Add(incr, UseUnsafe())
  1559  		we, willFailEq := willerr(a, numberTypes, unsignedTypes)
  1560  		_, ok := q.Engine().(Suber)
  1561  		we = we || !ok
  1562  
  1563  		ret, err := Sub(a, b, WithIncr(incr))
  1564  		if err, retEarly := qcErrCheck(t, "SubVS", a, b, we, err); retEarly {
  1565  			if err != nil {
  1566  				return false
  1567  			}
  1568  			return true
  1569  		}
  1570  		ret, err = Add(ret, b, UseUnsafe())
  1571  
  1572  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1573  			return false
  1574  		}
  1575  		return true
  1576  	}
  1577  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1578  		t.Errorf("Inv test for Sub (tensor as left, scalar as right) failed: %v", err)
  1579  	}
  1580  
  1581  }
  1582  func TestMulScalar_incr(t *testing.T) {
  1583  	iden1 := func(q *Dense) bool {
  1584  		a := q.Clone().(*Dense)
  1585  		b := identityVal(1, q.t)
  1586  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1587  
  1588  		correct := a.Clone().(*Dense)
  1589  		incr.Memset(identityVal(100, a.t))
  1590  		correct.Add(incr, UseUnsafe())
  1591  		we, willFailEq := willerr(a, numberTypes, nil)
  1592  		_, ok := q.Engine().(Muler)
  1593  		we = we || !ok
  1594  
  1595  		ret, err := Mul(a, b, WithIncr(incr))
  1596  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1597  			if err != nil {
  1598  				return false
  1599  			}
  1600  			return true
  1601  		}
  1602  
  1603  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1604  			return false
  1605  		}
  1606  		return true
  1607  	}
  1608  
  1609  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1610  		t.Errorf("Identity test for Mul (tensor as left, scalar as right) failed: %v", err)
  1611  	}
  1612  
  1613  	iden2 := func(q *Dense) bool {
  1614  		a := q.Clone().(*Dense)
  1615  		b := identityVal(1, q.t)
  1616  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1617  		correct := a.Clone().(*Dense)
  1618  		incr.Memset(identityVal(100, a.t))
  1619  		correct.Add(incr, UseUnsafe())
  1620  		we, willFailEq := willerr(a, numberTypes, nil)
  1621  		_, ok := q.Engine().(Muler)
  1622  		we = we || !ok
  1623  
  1624  		ret, err := Mul(b, a, WithIncr(incr))
  1625  		if err, retEarly := qcErrCheck(t, "Mul", a, b, we, err); retEarly {
  1626  			if err != nil {
  1627  				return false
  1628  			}
  1629  			return true
  1630  		}
  1631  
  1632  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1633  			return false
  1634  		}
  1635  		return true
  1636  	}
  1637  	if err := quick.Check(iden2, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1638  		t.Errorf("Identity test for Mul (scalar as left, tensor as right) failed: %v", err)
  1639  	}
  1640  
  1641  }
  1642  func TestDivScalar_incr(t *testing.T) {
  1643  	inv1 := func(q *Dense) bool {
  1644  		a := q.Clone().(*Dense)
  1645  		b := identityVal(1, q.t)
  1646  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1647  
  1648  		correct := a.Clone().(*Dense)
  1649  		incr.Memset(identityVal(100, a.t))
  1650  		correct.Add(incr, UseUnsafe())
  1651  		we, willFailEq := willerr(a, numberTypes, nil)
  1652  		_, ok := q.Engine().(Diver)
  1653  		we = we || !ok
  1654  
  1655  		ret, err := Div(a, b, WithIncr(incr))
  1656  		if err, retEarly := qcErrCheck(t, "DivVS", a, b, we, err); retEarly {
  1657  			if err != nil {
  1658  				return false
  1659  			}
  1660  			return true
  1661  		}
  1662  		ret, err = Mul(ret, b, UseUnsafe())
  1663  
  1664  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1665  			return false
  1666  		}
  1667  		return true
  1668  	}
  1669  	if err := quick.Check(inv1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1670  		t.Errorf("Inv test for Div (tensor as left, scalar as right) failed: %v", err)
  1671  	}
  1672  
  1673  }
  1674  func TestPowScalar_incr(t *testing.T) {
  1675  	iden1 := func(q *Dense) bool {
  1676  		a := q.Clone().(*Dense)
  1677  		b := identityVal(1, q.t)
  1678  		incr := New(Of(a.t), WithShape(a.Shape().Clone()...))
  1679  
  1680  		correct := a.Clone().(*Dense)
  1681  		incr.Memset(identityVal(100, a.t))
  1682  		correct.Add(incr, UseUnsafe())
  1683  		we, willFailEq := willerr(a, floatcmplxTypes, complexTypes)
  1684  		_, ok := q.Engine().(Power)
  1685  		we = we || !ok
  1686  
  1687  		ret, err := Pow(a, b, WithIncr(incr))
  1688  		if err, retEarly := qcErrCheck(t, "Pow", a, b, we, err); retEarly {
  1689  			if err != nil {
  1690  				return false
  1691  			}
  1692  			return true
  1693  		}
  1694  
  1695  		if !qcEqCheck(t, a.Dtype(), willFailEq, correct.Data(), ret.Data()) {
  1696  			return false
  1697  		}
  1698  		return true
  1699  	}
  1700  
  1701  	if err := quick.Check(iden1, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1702  		t.Errorf("Identity test for Pow (tensor as left, scalar as right) failed: %v", err)
  1703  	}
  1704  
  1705  }