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

     1  // Code generated by genlib2. DO NOT EDIT.
     2  
     3  package tensor
     4  
     5  import (
     6  	"reflect"
     7  	"testing"
     8  	"testing/quick"
     9  )
    10  
    11  func TestGt(t *testing.T) {
    12  	transFn := func(q *Dense) bool {
    13  		we, _ := willerr(q, ordTypes, nil)
    14  		_, ok := q.Engine().(Gter)
    15  		we = we || !ok
    16  
    17  		r := newRand()
    18  		a := q.Clone().(*Dense)
    19  		b := q.Clone().(*Dense)
    20  		c := q.Clone().(*Dense)
    21  
    22  		bv, _ := quick.Value(b.Dtype().Type, r)
    23  		cv, _ := quick.Value(c.Dtype().Type, r)
    24  		b.Memset(bv.Interface())
    25  		c.Memset(cv.Interface())
    26  
    27  		axb, err := Gt(a, b)
    28  		if err, retEarly := qcErrCheck(t, "Gt - a∙b", a, b, we, err); retEarly {
    29  			if err != nil {
    30  				return false
    31  			}
    32  			return true
    33  		}
    34  
    35  		bxc, err := Gt(b, c)
    36  		if err, retEarly := qcErrCheck(t, "Gt - b∙c", b, c, we, err); retEarly {
    37  			if err != nil {
    38  				return false
    39  			}
    40  			return true
    41  		}
    42  
    43  		axc, err := Gt(a, c)
    44  		if err, retEarly := qcErrCheck(t, "Gt - a∙c", a, c, we, err); retEarly {
    45  			if err != nil {
    46  				return false
    47  			}
    48  			return true
    49  		}
    50  
    51  		ab := axb.(*Dense).Bools()
    52  		bc := bxc.(*Dense).Bools()
    53  		ac := axc.(*Dense).Bools()
    54  		for i, vab := range ab {
    55  			if vab && bc[i] {
    56  				if !ac[i] {
    57  					return false
    58  				}
    59  			}
    60  		}
    61  
    62  		return true
    63  	}
    64  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
    65  		t.Errorf("Transitivity test for Gt failed: %v", err)
    66  	}
    67  
    68  }
    69  func TestGte(t *testing.T) {
    70  	transFn := func(q *Dense) bool {
    71  		we, _ := willerr(q, ordTypes, nil)
    72  		_, ok := q.Engine().(Gteer)
    73  		we = we || !ok
    74  
    75  		r := newRand()
    76  		a := q.Clone().(*Dense)
    77  		b := q.Clone().(*Dense)
    78  		c := q.Clone().(*Dense)
    79  
    80  		bv, _ := quick.Value(b.Dtype().Type, r)
    81  		cv, _ := quick.Value(c.Dtype().Type, r)
    82  		b.Memset(bv.Interface())
    83  		c.Memset(cv.Interface())
    84  
    85  		axb, err := Gte(a, b)
    86  		if err, retEarly := qcErrCheck(t, "Gte - a∙b", a, b, we, err); retEarly {
    87  			if err != nil {
    88  				return false
    89  			}
    90  			return true
    91  		}
    92  
    93  		bxc, err := Gte(b, c)
    94  		if err, retEarly := qcErrCheck(t, "Gte - b∙c", b, c, we, err); retEarly {
    95  			if err != nil {
    96  				return false
    97  			}
    98  			return true
    99  		}
   100  
   101  		axc, err := Gte(a, c)
   102  		if err, retEarly := qcErrCheck(t, "Gte - a∙c", a, c, we, err); retEarly {
   103  			if err != nil {
   104  				return false
   105  			}
   106  			return true
   107  		}
   108  
   109  		ab := axb.(*Dense).Bools()
   110  		bc := bxc.(*Dense).Bools()
   111  		ac := axc.(*Dense).Bools()
   112  		for i, vab := range ab {
   113  			if vab && bc[i] {
   114  				if !ac[i] {
   115  					return false
   116  				}
   117  			}
   118  		}
   119  
   120  		return true
   121  	}
   122  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   123  		t.Errorf("Transitivity test for Gte failed: %v", err)
   124  	}
   125  
   126  }
   127  func TestLt(t *testing.T) {
   128  	transFn := func(q *Dense) bool {
   129  		we, _ := willerr(q, ordTypes, nil)
   130  		_, ok := q.Engine().(Lter)
   131  		we = we || !ok
   132  
   133  		r := newRand()
   134  		a := q.Clone().(*Dense)
   135  		b := q.Clone().(*Dense)
   136  		c := q.Clone().(*Dense)
   137  
   138  		bv, _ := quick.Value(b.Dtype().Type, r)
   139  		cv, _ := quick.Value(c.Dtype().Type, r)
   140  		b.Memset(bv.Interface())
   141  		c.Memset(cv.Interface())
   142  
   143  		axb, err := Lt(a, b)
   144  		if err, retEarly := qcErrCheck(t, "Lt - a∙b", a, b, we, err); retEarly {
   145  			if err != nil {
   146  				return false
   147  			}
   148  			return true
   149  		}
   150  
   151  		bxc, err := Lt(b, c)
   152  		if err, retEarly := qcErrCheck(t, "Lt - b∙c", b, c, we, err); retEarly {
   153  			if err != nil {
   154  				return false
   155  			}
   156  			return true
   157  		}
   158  
   159  		axc, err := Lt(a, c)
   160  		if err, retEarly := qcErrCheck(t, "Lt - a∙c", a, c, we, err); retEarly {
   161  			if err != nil {
   162  				return false
   163  			}
   164  			return true
   165  		}
   166  
   167  		ab := axb.(*Dense).Bools()
   168  		bc := bxc.(*Dense).Bools()
   169  		ac := axc.(*Dense).Bools()
   170  		for i, vab := range ab {
   171  			if vab && bc[i] {
   172  				if !ac[i] {
   173  					return false
   174  				}
   175  			}
   176  		}
   177  
   178  		return true
   179  	}
   180  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   181  		t.Errorf("Transitivity test for Lt failed: %v", err)
   182  	}
   183  
   184  }
   185  func TestLte(t *testing.T) {
   186  	transFn := func(q *Dense) bool {
   187  		we, _ := willerr(q, ordTypes, nil)
   188  		_, ok := q.Engine().(Lteer)
   189  		we = we || !ok
   190  
   191  		r := newRand()
   192  		a := q.Clone().(*Dense)
   193  		b := q.Clone().(*Dense)
   194  		c := q.Clone().(*Dense)
   195  
   196  		bv, _ := quick.Value(b.Dtype().Type, r)
   197  		cv, _ := quick.Value(c.Dtype().Type, r)
   198  		b.Memset(bv.Interface())
   199  		c.Memset(cv.Interface())
   200  
   201  		axb, err := Lte(a, b)
   202  		if err, retEarly := qcErrCheck(t, "Lte - a∙b", a, b, we, err); retEarly {
   203  			if err != nil {
   204  				return false
   205  			}
   206  			return true
   207  		}
   208  
   209  		bxc, err := Lte(b, c)
   210  		if err, retEarly := qcErrCheck(t, "Lte - b∙c", b, c, we, err); retEarly {
   211  			if err != nil {
   212  				return false
   213  			}
   214  			return true
   215  		}
   216  
   217  		axc, err := Lte(a, c)
   218  		if err, retEarly := qcErrCheck(t, "Lte - a∙c", a, c, we, err); retEarly {
   219  			if err != nil {
   220  				return false
   221  			}
   222  			return true
   223  		}
   224  
   225  		ab := axb.(*Dense).Bools()
   226  		bc := bxc.(*Dense).Bools()
   227  		ac := axc.(*Dense).Bools()
   228  		for i, vab := range ab {
   229  			if vab && bc[i] {
   230  				if !ac[i] {
   231  					return false
   232  				}
   233  			}
   234  		}
   235  
   236  		return true
   237  	}
   238  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   239  		t.Errorf("Transitivity test for Lte failed: %v", err)
   240  	}
   241  
   242  }
   243  func TestEq(t *testing.T) {
   244  	transFn := func(q *Dense) bool {
   245  		we, _ := willerr(q, eqTypes, nil)
   246  		_, ok := q.Engine().(ElEqer)
   247  		we = we || !ok
   248  
   249  		r := newRand()
   250  		a := q.Clone().(*Dense)
   251  		b := q.Clone().(*Dense)
   252  		c := q.Clone().(*Dense)
   253  
   254  		bv, _ := quick.Value(b.Dtype().Type, r)
   255  		cv, _ := quick.Value(c.Dtype().Type, r)
   256  		b.Memset(bv.Interface())
   257  		c.Memset(cv.Interface())
   258  
   259  		axb, err := ElEq(a, b)
   260  		if err, retEarly := qcErrCheck(t, "ElEq - a∙b", a, b, we, err); retEarly {
   261  			if err != nil {
   262  				return false
   263  			}
   264  			return true
   265  		}
   266  
   267  		bxc, err := ElEq(b, c)
   268  		if err, retEarly := qcErrCheck(t, "ElEq - b∙c", b, c, we, err); retEarly {
   269  			if err != nil {
   270  				return false
   271  			}
   272  			return true
   273  		}
   274  
   275  		axc, err := ElEq(a, c)
   276  		if err, retEarly := qcErrCheck(t, "ElEq - a∙c", a, c, we, err); retEarly {
   277  			if err != nil {
   278  				return false
   279  			}
   280  			return true
   281  		}
   282  
   283  		ab := axb.(*Dense).Bools()
   284  		bc := bxc.(*Dense).Bools()
   285  		ac := axc.(*Dense).Bools()
   286  		for i, vab := range ab {
   287  			if vab && bc[i] {
   288  				if !ac[i] {
   289  					return false
   290  				}
   291  			}
   292  		}
   293  
   294  		return true
   295  	}
   296  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   297  		t.Errorf("Transitivity test for ElEq failed: %v", err)
   298  	}
   299  
   300  	symFn := func(q *Dense) bool {
   301  		we, _ := willerr(q, eqTypes, nil)
   302  		_, ok := q.Engine().(ElEqer)
   303  		we = we || !ok
   304  
   305  		r := newRand()
   306  		a := q.Clone().(*Dense)
   307  		b := q.Clone().(*Dense)
   308  
   309  		bv, _ := quick.Value(b.Dtype().Type, r)
   310  		b.Memset(bv.Interface())
   311  
   312  		axb, err := ElEq(a, b)
   313  		if err, retEarly := qcErrCheck(t, "ElEq - a∙b", a, b, we, err); retEarly {
   314  			if err != nil {
   315  				return false
   316  			}
   317  			return true
   318  		}
   319  
   320  		bxa, err := ElEq(b, a)
   321  		if err, retEarly := qcErrCheck(t, "ElEq - b∙a", a, b, we, err); retEarly {
   322  			if err != nil {
   323  				return false
   324  			}
   325  			return true
   326  		}
   327  		return reflect.DeepEqual(axb.Data(), bxa.Data())
   328  
   329  	}
   330  	if err := quick.Check(symFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   331  		t.Errorf("Transitivity test for ElEq failed: %v", err)
   332  	}
   333  }
   334  func TestNe(t *testing.T) {
   335  	symFn := func(q *Dense) bool {
   336  		we, _ := willerr(q, eqTypes, nil)
   337  		_, ok := q.Engine().(ElEqer)
   338  		we = we || !ok
   339  
   340  		r := newRand()
   341  		a := q.Clone().(*Dense)
   342  		b := q.Clone().(*Dense)
   343  
   344  		bv, _ := quick.Value(b.Dtype().Type, r)
   345  		b.Memset(bv.Interface())
   346  
   347  		axb, err := ElNe(a, b)
   348  		if err, retEarly := qcErrCheck(t, "ElNe - a∙b", a, b, we, err); retEarly {
   349  			if err != nil {
   350  				return false
   351  			}
   352  			return true
   353  		}
   354  
   355  		bxa, err := ElNe(b, a)
   356  		if err, retEarly := qcErrCheck(t, "ElNe - b∙a", a, b, we, err); retEarly {
   357  			if err != nil {
   358  				return false
   359  			}
   360  			return true
   361  		}
   362  		return reflect.DeepEqual(axb.Data(), bxa.Data())
   363  
   364  	}
   365  	if err := quick.Check(symFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   366  		t.Errorf("Transitivity test for ElNe failed: %v", err)
   367  	}
   368  }
   369  func TestGt_assame(t *testing.T) {
   370  	transFn := func(q *Dense) bool {
   371  		we, _ := willerr(q, nonComplexNumberTypes, nil)
   372  		_, ok := q.Engine().(Gter)
   373  		we = we || !ok
   374  
   375  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
   376  			return true // we exit early if the generated type is not something we can handle
   377  		}
   378  		r := newRand()
   379  		a := q.Clone().(*Dense)
   380  		b := q.Clone().(*Dense)
   381  		c := q.Clone().(*Dense)
   382  
   383  		bv, _ := quick.Value(b.Dtype().Type, r)
   384  		cv, _ := quick.Value(c.Dtype().Type, r)
   385  		b.Memset(bv.Interface())
   386  		c.Memset(cv.Interface())
   387  
   388  		axb, err := Gt(a, b, AsSameType())
   389  		if err, retEarly := qcErrCheck(t, "Gt - a∙b", a, b, we, err); retEarly {
   390  			if err != nil {
   391  				return false
   392  			}
   393  			return true
   394  		}
   395  
   396  		bxc, err := Gt(b, c, AsSameType())
   397  		if err, retEarly := qcErrCheck(t, "Gt - b∙c", b, c, we, err); retEarly {
   398  			if err != nil {
   399  				return false
   400  			}
   401  			return true
   402  		}
   403  
   404  		axc, err := Gt(a, c, AsSameType())
   405  		if err, retEarly := qcErrCheck(t, "Gt - a∙c", a, c, we, err); retEarly {
   406  			if err != nil {
   407  				return false
   408  			}
   409  			return true
   410  		}
   411  
   412  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
   413  			t.Errorf("a: %-v", a)
   414  			t.Errorf("b: %-v", b)
   415  			t.Errorf("c: %-v", c)
   416  			t.Errorf("axb.Data() %v", axb.Data())
   417  			t.Errorf("bxc.Data() %v", bxc.Data())
   418  			t.Errorf("axc.Data() %v", axc.Data())
   419  			return false
   420  		}
   421  
   422  		return true
   423  	}
   424  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   425  		t.Errorf("Transitivity test for Gt failed: %v", err)
   426  	}
   427  
   428  }
   429  func TestGte_assame(t *testing.T) {
   430  	transFn := func(q *Dense) bool {
   431  		we, _ := willerr(q, nonComplexNumberTypes, nil)
   432  		_, ok := q.Engine().(Gteer)
   433  		we = we || !ok
   434  
   435  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
   436  			return true // we exit early if the generated type is not something we can handle
   437  		}
   438  		r := newRand()
   439  		a := q.Clone().(*Dense)
   440  		b := q.Clone().(*Dense)
   441  		c := q.Clone().(*Dense)
   442  
   443  		bv, _ := quick.Value(b.Dtype().Type, r)
   444  		cv, _ := quick.Value(c.Dtype().Type, r)
   445  		b.Memset(bv.Interface())
   446  		c.Memset(cv.Interface())
   447  
   448  		axb, err := Gte(a, b, AsSameType())
   449  		if err, retEarly := qcErrCheck(t, "Gte - a∙b", a, b, we, err); retEarly {
   450  			if err != nil {
   451  				return false
   452  			}
   453  			return true
   454  		}
   455  
   456  		bxc, err := Gte(b, c, AsSameType())
   457  		if err, retEarly := qcErrCheck(t, "Gte - b∙c", b, c, we, err); retEarly {
   458  			if err != nil {
   459  				return false
   460  			}
   461  			return true
   462  		}
   463  
   464  		axc, err := Gte(a, c, AsSameType())
   465  		if err, retEarly := qcErrCheck(t, "Gte - a∙c", a, c, we, err); retEarly {
   466  			if err != nil {
   467  				return false
   468  			}
   469  			return true
   470  		}
   471  
   472  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
   473  			t.Errorf("a: %-v", a)
   474  			t.Errorf("b: %-v", b)
   475  			t.Errorf("c: %-v", c)
   476  			t.Errorf("axb.Data() %v", axb.Data())
   477  			t.Errorf("bxc.Data() %v", bxc.Data())
   478  			t.Errorf("axc.Data() %v", axc.Data())
   479  			return false
   480  		}
   481  
   482  		return true
   483  	}
   484  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   485  		t.Errorf("Transitivity test for Gte failed: %v", err)
   486  	}
   487  
   488  }
   489  func TestLt_assame(t *testing.T) {
   490  	transFn := func(q *Dense) bool {
   491  		we, _ := willerr(q, nonComplexNumberTypes, nil)
   492  		_, ok := q.Engine().(Lter)
   493  		we = we || !ok
   494  
   495  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
   496  			return true // we exit early if the generated type is not something we can handle
   497  		}
   498  		r := newRand()
   499  		a := q.Clone().(*Dense)
   500  		b := q.Clone().(*Dense)
   501  		c := q.Clone().(*Dense)
   502  
   503  		bv, _ := quick.Value(b.Dtype().Type, r)
   504  		cv, _ := quick.Value(c.Dtype().Type, r)
   505  		b.Memset(bv.Interface())
   506  		c.Memset(cv.Interface())
   507  
   508  		axb, err := Lt(a, b, AsSameType())
   509  		if err, retEarly := qcErrCheck(t, "Lt - a∙b", a, b, we, err); retEarly {
   510  			if err != nil {
   511  				return false
   512  			}
   513  			return true
   514  		}
   515  
   516  		bxc, err := Lt(b, c, AsSameType())
   517  		if err, retEarly := qcErrCheck(t, "Lt - b∙c", b, c, we, err); retEarly {
   518  			if err != nil {
   519  				return false
   520  			}
   521  			return true
   522  		}
   523  
   524  		axc, err := Lt(a, c, AsSameType())
   525  		if err, retEarly := qcErrCheck(t, "Lt - a∙c", a, c, we, err); retEarly {
   526  			if err != nil {
   527  				return false
   528  			}
   529  			return true
   530  		}
   531  
   532  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
   533  			t.Errorf("a: %-v", a)
   534  			t.Errorf("b: %-v", b)
   535  			t.Errorf("c: %-v", c)
   536  			t.Errorf("axb.Data() %v", axb.Data())
   537  			t.Errorf("bxc.Data() %v", bxc.Data())
   538  			t.Errorf("axc.Data() %v", axc.Data())
   539  			return false
   540  		}
   541  
   542  		return true
   543  	}
   544  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   545  		t.Errorf("Transitivity test for Lt failed: %v", err)
   546  	}
   547  
   548  }
   549  func TestLte_assame(t *testing.T) {
   550  	transFn := func(q *Dense) bool {
   551  		we, _ := willerr(q, nonComplexNumberTypes, nil)
   552  		_, ok := q.Engine().(Lteer)
   553  		we = we || !ok
   554  
   555  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
   556  			return true // we exit early if the generated type is not something we can handle
   557  		}
   558  		r := newRand()
   559  		a := q.Clone().(*Dense)
   560  		b := q.Clone().(*Dense)
   561  		c := q.Clone().(*Dense)
   562  
   563  		bv, _ := quick.Value(b.Dtype().Type, r)
   564  		cv, _ := quick.Value(c.Dtype().Type, r)
   565  		b.Memset(bv.Interface())
   566  		c.Memset(cv.Interface())
   567  
   568  		axb, err := Lte(a, b, AsSameType())
   569  		if err, retEarly := qcErrCheck(t, "Lte - a∙b", a, b, we, err); retEarly {
   570  			if err != nil {
   571  				return false
   572  			}
   573  			return true
   574  		}
   575  
   576  		bxc, err := Lte(b, c, AsSameType())
   577  		if err, retEarly := qcErrCheck(t, "Lte - b∙c", b, c, we, err); retEarly {
   578  			if err != nil {
   579  				return false
   580  			}
   581  			return true
   582  		}
   583  
   584  		axc, err := Lte(a, c, AsSameType())
   585  		if err, retEarly := qcErrCheck(t, "Lte - a∙c", a, c, we, err); retEarly {
   586  			if err != nil {
   587  				return false
   588  			}
   589  			return true
   590  		}
   591  
   592  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
   593  			t.Errorf("a: %-v", a)
   594  			t.Errorf("b: %-v", b)
   595  			t.Errorf("c: %-v", c)
   596  			t.Errorf("axb.Data() %v", axb.Data())
   597  			t.Errorf("bxc.Data() %v", bxc.Data())
   598  			t.Errorf("axc.Data() %v", axc.Data())
   599  			return false
   600  		}
   601  
   602  		return true
   603  	}
   604  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   605  		t.Errorf("Transitivity test for Lte failed: %v", err)
   606  	}
   607  
   608  }
   609  func TestEq_assame(t *testing.T) {
   610  	transFn := func(q *Dense) bool {
   611  		we, _ := willerr(q, nonComplexNumberTypes, nil)
   612  		_, ok := q.Engine().(ElEqer)
   613  		we = we || !ok
   614  
   615  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
   616  			return true // we exit early if the generated type is not something we can handle
   617  		}
   618  		r := newRand()
   619  		a := q.Clone().(*Dense)
   620  		b := q.Clone().(*Dense)
   621  		c := q.Clone().(*Dense)
   622  
   623  		bv, _ := quick.Value(b.Dtype().Type, r)
   624  		cv, _ := quick.Value(c.Dtype().Type, r)
   625  		b.Memset(bv.Interface())
   626  		c.Memset(cv.Interface())
   627  
   628  		axb, err := ElEq(a, b, AsSameType())
   629  		if err, retEarly := qcErrCheck(t, "ElEq - a∙b", a, b, we, err); retEarly {
   630  			if err != nil {
   631  				return false
   632  			}
   633  			return true
   634  		}
   635  
   636  		bxc, err := ElEq(b, c, AsSameType())
   637  		if err, retEarly := qcErrCheck(t, "ElEq - b∙c", b, c, we, err); retEarly {
   638  			if err != nil {
   639  				return false
   640  			}
   641  			return true
   642  		}
   643  
   644  		axc, err := ElEq(a, c, AsSameType())
   645  		if err, retEarly := qcErrCheck(t, "ElEq - a∙c", a, c, we, err); retEarly {
   646  			if err != nil {
   647  				return false
   648  			}
   649  			return true
   650  		}
   651  
   652  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
   653  			t.Errorf("a: %-v", a)
   654  			t.Errorf("b: %-v", b)
   655  			t.Errorf("c: %-v", c)
   656  			t.Errorf("axb.Data() %v", axb.Data())
   657  			t.Errorf("bxc.Data() %v", bxc.Data())
   658  			t.Errorf("axc.Data() %v", axc.Data())
   659  			return false
   660  		}
   661  
   662  		return true
   663  	}
   664  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   665  		t.Errorf("Transitivity test for ElEq failed: %v", err)
   666  	}
   667  
   668  	symFn := func(q *Dense) bool {
   669  		we, _ := willerr(q, nonComplexNumberTypes, nil)
   670  		_, ok := q.Engine().(ElEqer)
   671  		we = we || !ok
   672  
   673  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
   674  			return true // we exit early if the generated type is not something we can handle
   675  		}
   676  		r := newRand()
   677  		a := q.Clone().(*Dense)
   678  		b := q.Clone().(*Dense)
   679  
   680  		bv, _ := quick.Value(b.Dtype().Type, r)
   681  		b.Memset(bv.Interface())
   682  
   683  		axb, err := ElEq(a, b, AsSameType())
   684  		if err, retEarly := qcErrCheck(t, "ElEq - a∙b", a, b, we, err); retEarly {
   685  			if err != nil {
   686  				return false
   687  			}
   688  			return true
   689  		}
   690  
   691  		bxa, err := ElEq(b, a, AsSameType())
   692  		if err, retEarly := qcErrCheck(t, "ElEq - b∙a", a, b, we, err); retEarly {
   693  			if err != nil {
   694  				return false
   695  			}
   696  			return true
   697  		}
   698  		return reflect.DeepEqual(axb.Data(), bxa.Data())
   699  
   700  	}
   701  	if err := quick.Check(symFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   702  		t.Errorf("Transitivity test for ElEq failed: %v", err)
   703  	}
   704  }
   705  func TestNe_assame(t *testing.T) {
   706  	symFn := func(q *Dense) bool {
   707  		we, _ := willerr(q, nonComplexNumberTypes, nil)
   708  		_, ok := q.Engine().(ElEqer)
   709  		we = we || !ok
   710  
   711  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
   712  			return true // we exit early if the generated type is not something we can handle
   713  		}
   714  		r := newRand()
   715  		a := q.Clone().(*Dense)
   716  		b := q.Clone().(*Dense)
   717  
   718  		bv, _ := quick.Value(b.Dtype().Type, r)
   719  		b.Memset(bv.Interface())
   720  
   721  		axb, err := ElNe(a, b, AsSameType())
   722  		if err, retEarly := qcErrCheck(t, "ElNe - a∙b", a, b, we, err); retEarly {
   723  			if err != nil {
   724  				return false
   725  			}
   726  			return true
   727  		}
   728  
   729  		bxa, err := ElNe(b, a, AsSameType())
   730  		if err, retEarly := qcErrCheck(t, "ElNe - b∙a", a, b, we, err); retEarly {
   731  			if err != nil {
   732  				return false
   733  			}
   734  			return true
   735  		}
   736  		return reflect.DeepEqual(axb.Data(), bxa.Data())
   737  
   738  	}
   739  	if err := quick.Check(symFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   740  		t.Errorf("Transitivity test for ElNe failed: %v", err)
   741  	}
   742  }
   743  func TestGtScalar(t *testing.T) {
   744  	transFn := func(q *Dense) bool {
   745  		we, _ := willerr(q, ordTypes, nil)
   746  		_, ok := q.Engine().(Gter)
   747  		we = we || !ok
   748  
   749  		r := newRand()
   750  		a := q.Clone().(*Dense)
   751  		bv, _ := quick.Value(a.Dtype().Type, r)
   752  		b := bv.Interface()
   753  		c := q.Clone().(*Dense)
   754  		cv, _ := quick.Value(c.Dtype().Type, r)
   755  		c.Memset(cv.Interface())
   756  
   757  		axb, err := Gt(a, b)
   758  		if err, retEarly := qcErrCheck(t, "Gt - a∙b", a, b, we, err); retEarly {
   759  			if err != nil {
   760  				return false
   761  			}
   762  			return true
   763  		}
   764  
   765  		bxc, err := Gt(b, c)
   766  		if err, retEarly := qcErrCheck(t, "Gt - b∙c", c, b, we, err); retEarly {
   767  			if err != nil {
   768  				return false
   769  			}
   770  			return true
   771  		}
   772  
   773  		axc, err := Gt(a, c)
   774  		if err, retEarly := qcErrCheck(t, "Gt - a∙c", a, c, we, err); retEarly {
   775  			if err != nil {
   776  				return false
   777  			}
   778  			return true
   779  		}
   780  
   781  		ab := axb.(*Dense).Bools()
   782  		bc := bxc.(*Dense).Bools()
   783  		ac := axc.(*Dense).Bools()
   784  		for i, vab := range ab {
   785  			if vab && bc[i] {
   786  				if !ac[i] {
   787  					return false
   788  				}
   789  			}
   790  		}
   791  
   792  		return true
   793  	}
   794  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   795  		t.Errorf("Transitivity test for Gt failed: %v", err)
   796  	}
   797  
   798  }
   799  func TestGteScalar(t *testing.T) {
   800  	transFn := func(q *Dense) bool {
   801  		we, _ := willerr(q, ordTypes, nil)
   802  		_, ok := q.Engine().(Gteer)
   803  		we = we || !ok
   804  
   805  		r := newRand()
   806  		a := q.Clone().(*Dense)
   807  		bv, _ := quick.Value(a.Dtype().Type, r)
   808  		b := bv.Interface()
   809  		c := q.Clone().(*Dense)
   810  		cv, _ := quick.Value(c.Dtype().Type, r)
   811  		c.Memset(cv.Interface())
   812  
   813  		axb, err := Gte(a, b)
   814  		if err, retEarly := qcErrCheck(t, "Gte - a∙b", a, b, we, err); retEarly {
   815  			if err != nil {
   816  				return false
   817  			}
   818  			return true
   819  		}
   820  
   821  		bxc, err := Gte(b, c)
   822  		if err, retEarly := qcErrCheck(t, "Gte - b∙c", c, b, we, err); retEarly {
   823  			if err != nil {
   824  				return false
   825  			}
   826  			return true
   827  		}
   828  
   829  		axc, err := Gte(a, c)
   830  		if err, retEarly := qcErrCheck(t, "Gte - a∙c", a, c, we, err); retEarly {
   831  			if err != nil {
   832  				return false
   833  			}
   834  			return true
   835  		}
   836  
   837  		ab := axb.(*Dense).Bools()
   838  		bc := bxc.(*Dense).Bools()
   839  		ac := axc.(*Dense).Bools()
   840  		for i, vab := range ab {
   841  			if vab && bc[i] {
   842  				if !ac[i] {
   843  					return false
   844  				}
   845  			}
   846  		}
   847  
   848  		return true
   849  	}
   850  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   851  		t.Errorf("Transitivity test for Gte failed: %v", err)
   852  	}
   853  
   854  }
   855  func TestLtScalar(t *testing.T) {
   856  	transFn := func(q *Dense) bool {
   857  		we, _ := willerr(q, ordTypes, nil)
   858  		_, ok := q.Engine().(Lter)
   859  		we = we || !ok
   860  
   861  		r := newRand()
   862  		a := q.Clone().(*Dense)
   863  		bv, _ := quick.Value(a.Dtype().Type, r)
   864  		b := bv.Interface()
   865  		c := q.Clone().(*Dense)
   866  		cv, _ := quick.Value(c.Dtype().Type, r)
   867  		c.Memset(cv.Interface())
   868  
   869  		axb, err := Lt(a, b)
   870  		if err, retEarly := qcErrCheck(t, "Lt - a∙b", a, b, we, err); retEarly {
   871  			if err != nil {
   872  				return false
   873  			}
   874  			return true
   875  		}
   876  
   877  		bxc, err := Lt(b, c)
   878  		if err, retEarly := qcErrCheck(t, "Lt - b∙c", c, b, we, err); retEarly {
   879  			if err != nil {
   880  				return false
   881  			}
   882  			return true
   883  		}
   884  
   885  		axc, err := Lt(a, c)
   886  		if err, retEarly := qcErrCheck(t, "Lt - a∙c", a, c, we, err); retEarly {
   887  			if err != nil {
   888  				return false
   889  			}
   890  			return true
   891  		}
   892  
   893  		ab := axb.(*Dense).Bools()
   894  		bc := bxc.(*Dense).Bools()
   895  		ac := axc.(*Dense).Bools()
   896  		for i, vab := range ab {
   897  			if vab && bc[i] {
   898  				if !ac[i] {
   899  					return false
   900  				}
   901  			}
   902  		}
   903  
   904  		return true
   905  	}
   906  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   907  		t.Errorf("Transitivity test for Lt failed: %v", err)
   908  	}
   909  
   910  }
   911  func TestLteScalar(t *testing.T) {
   912  	transFn := func(q *Dense) bool {
   913  		we, _ := willerr(q, ordTypes, nil)
   914  		_, ok := q.Engine().(Lteer)
   915  		we = we || !ok
   916  
   917  		r := newRand()
   918  		a := q.Clone().(*Dense)
   919  		bv, _ := quick.Value(a.Dtype().Type, r)
   920  		b := bv.Interface()
   921  		c := q.Clone().(*Dense)
   922  		cv, _ := quick.Value(c.Dtype().Type, r)
   923  		c.Memset(cv.Interface())
   924  
   925  		axb, err := Lte(a, b)
   926  		if err, retEarly := qcErrCheck(t, "Lte - a∙b", a, b, we, err); retEarly {
   927  			if err != nil {
   928  				return false
   929  			}
   930  			return true
   931  		}
   932  
   933  		bxc, err := Lte(b, c)
   934  		if err, retEarly := qcErrCheck(t, "Lte - b∙c", c, b, we, err); retEarly {
   935  			if err != nil {
   936  				return false
   937  			}
   938  			return true
   939  		}
   940  
   941  		axc, err := Lte(a, c)
   942  		if err, retEarly := qcErrCheck(t, "Lte - a∙c", a, c, we, err); retEarly {
   943  			if err != nil {
   944  				return false
   945  			}
   946  			return true
   947  		}
   948  
   949  		ab := axb.(*Dense).Bools()
   950  		bc := bxc.(*Dense).Bools()
   951  		ac := axc.(*Dense).Bools()
   952  		for i, vab := range ab {
   953  			if vab && bc[i] {
   954  				if !ac[i] {
   955  					return false
   956  				}
   957  			}
   958  		}
   959  
   960  		return true
   961  	}
   962  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
   963  		t.Errorf("Transitivity test for Lte failed: %v", err)
   964  	}
   965  
   966  }
   967  func TestEqScalar(t *testing.T) {
   968  	transFn := func(q *Dense) bool {
   969  		we, _ := willerr(q, eqTypes, nil)
   970  		_, ok := q.Engine().(ElEqer)
   971  		we = we || !ok
   972  
   973  		r := newRand()
   974  		a := q.Clone().(*Dense)
   975  		bv, _ := quick.Value(a.Dtype().Type, r)
   976  		b := bv.Interface()
   977  		c := q.Clone().(*Dense)
   978  		cv, _ := quick.Value(c.Dtype().Type, r)
   979  		c.Memset(cv.Interface())
   980  
   981  		axb, err := ElEq(a, b)
   982  		if err, retEarly := qcErrCheck(t, "ElEq - a∙b", a, b, we, err); retEarly {
   983  			if err != nil {
   984  				return false
   985  			}
   986  			return true
   987  		}
   988  
   989  		bxc, err := ElEq(b, c)
   990  		if err, retEarly := qcErrCheck(t, "ElEq - b∙c", c, b, we, err); retEarly {
   991  			if err != nil {
   992  				return false
   993  			}
   994  			return true
   995  		}
   996  
   997  		axc, err := ElEq(a, c)
   998  		if err, retEarly := qcErrCheck(t, "ElEq - a∙c", a, c, we, err); retEarly {
   999  			if err != nil {
  1000  				return false
  1001  			}
  1002  			return true
  1003  		}
  1004  
  1005  		ab := axb.(*Dense).Bools()
  1006  		bc := bxc.(*Dense).Bools()
  1007  		ac := axc.(*Dense).Bools()
  1008  		for i, vab := range ab {
  1009  			if vab && bc[i] {
  1010  				if !ac[i] {
  1011  					return false
  1012  				}
  1013  			}
  1014  		}
  1015  
  1016  		return true
  1017  	}
  1018  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1019  		t.Errorf("Transitivity test for ElEq failed: %v", err)
  1020  	}
  1021  
  1022  	symFn := func(q *Dense) bool {
  1023  		we, _ := willerr(q, eqTypes, nil)
  1024  		_, ok := q.Engine().(ElEqer)
  1025  		we = we || !ok
  1026  
  1027  		r := newRand()
  1028  		a := q.Clone().(*Dense)
  1029  		bv, _ := quick.Value(a.Dtype().Type, r)
  1030  		b := bv.Interface()
  1031  
  1032  		axb, err := ElEq(a, b)
  1033  		if err, retEarly := qcErrCheck(t, "ElEq - a∙b", a, b, we, err); retEarly {
  1034  			if err != nil {
  1035  				return false
  1036  			}
  1037  			return true
  1038  		}
  1039  
  1040  		bxa, err := ElEq(b, a)
  1041  		if err, retEarly := qcErrCheck(t, "ElEq - b∙a", a, b, we, err); retEarly {
  1042  			if err != nil {
  1043  				return false
  1044  			}
  1045  			return true
  1046  		}
  1047  		return reflect.DeepEqual(axb.Data(), bxa.Data())
  1048  
  1049  	}
  1050  	if err := quick.Check(symFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1051  		t.Errorf("Symmetry test for ElEq failed: %v", err)
  1052  	}
  1053  }
  1054  func TestNeScalar(t *testing.T) {
  1055  	symFn := func(q *Dense) bool {
  1056  		we, _ := willerr(q, eqTypes, nil)
  1057  		_, ok := q.Engine().(ElEqer)
  1058  		we = we || !ok
  1059  
  1060  		r := newRand()
  1061  		a := q.Clone().(*Dense)
  1062  		bv, _ := quick.Value(a.Dtype().Type, r)
  1063  		b := bv.Interface()
  1064  
  1065  		axb, err := ElNe(a, b)
  1066  		if err, retEarly := qcErrCheck(t, "ElNe - a∙b", a, b, we, err); retEarly {
  1067  			if err != nil {
  1068  				return false
  1069  			}
  1070  			return true
  1071  		}
  1072  
  1073  		bxa, err := ElNe(b, a)
  1074  		if err, retEarly := qcErrCheck(t, "ElNe - b∙a", a, b, we, err); retEarly {
  1075  			if err != nil {
  1076  				return false
  1077  			}
  1078  			return true
  1079  		}
  1080  		return reflect.DeepEqual(axb.Data(), bxa.Data())
  1081  
  1082  	}
  1083  	if err := quick.Check(symFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1084  		t.Errorf("Symmetry test for ElNe failed: %v", err)
  1085  	}
  1086  }
  1087  func TestGtScalar_assame(t *testing.T) {
  1088  	transFn := func(q *Dense) bool {
  1089  		we, _ := willerr(q, nonComplexNumberTypes, nil)
  1090  		_, ok := q.Engine().(Gter)
  1091  		we = we || !ok
  1092  
  1093  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
  1094  			return true // we exit early if the generated type is not something we can handle
  1095  		}
  1096  		r := newRand()
  1097  		a := q.Clone().(*Dense)
  1098  		bv, _ := quick.Value(a.Dtype().Type, r)
  1099  		b := bv.Interface()
  1100  		c := q.Clone().(*Dense)
  1101  		cv, _ := quick.Value(c.Dtype().Type, r)
  1102  		c.Memset(cv.Interface())
  1103  
  1104  		axb, err := Gt(a, b, AsSameType())
  1105  		if err, retEarly := qcErrCheck(t, "Gt - a∙b", a, b, we, err); retEarly {
  1106  			if err != nil {
  1107  				return false
  1108  			}
  1109  			return true
  1110  		}
  1111  
  1112  		bxc, err := Gt(b, c, AsSameType())
  1113  		if err, retEarly := qcErrCheck(t, "Gt - b∙c", c, b, we, err); retEarly {
  1114  			if err != nil {
  1115  				return false
  1116  			}
  1117  			return true
  1118  		}
  1119  
  1120  		axc, err := Gt(a, c, AsSameType())
  1121  		if err, retEarly := qcErrCheck(t, "Gt - a∙c", a, c, we, err); retEarly {
  1122  			if err != nil {
  1123  				return false
  1124  			}
  1125  			return true
  1126  		}
  1127  
  1128  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
  1129  			t.Errorf("a: %-v", a)
  1130  			t.Errorf("b: %-v", b)
  1131  			t.Errorf("c: %-v", c)
  1132  			t.Errorf("axb.Data() %v", axb.Data())
  1133  			t.Errorf("bxc.Data() %v", bxc.Data())
  1134  			t.Errorf("axc.Data() %v", axc.Data())
  1135  			return false
  1136  		}
  1137  
  1138  		return true
  1139  	}
  1140  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1141  		t.Errorf("Transitivity test for Gt failed: %v", err)
  1142  	}
  1143  
  1144  }
  1145  func TestGteScalar_assame(t *testing.T) {
  1146  	transFn := func(q *Dense) bool {
  1147  		we, _ := willerr(q, nonComplexNumberTypes, nil)
  1148  		_, ok := q.Engine().(Gteer)
  1149  		we = we || !ok
  1150  
  1151  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
  1152  			return true // we exit early if the generated type is not something we can handle
  1153  		}
  1154  		r := newRand()
  1155  		a := q.Clone().(*Dense)
  1156  		bv, _ := quick.Value(a.Dtype().Type, r)
  1157  		b := bv.Interface()
  1158  		c := q.Clone().(*Dense)
  1159  		cv, _ := quick.Value(c.Dtype().Type, r)
  1160  		c.Memset(cv.Interface())
  1161  
  1162  		axb, err := Gte(a, b, AsSameType())
  1163  		if err, retEarly := qcErrCheck(t, "Gte - a∙b", a, b, we, err); retEarly {
  1164  			if err != nil {
  1165  				return false
  1166  			}
  1167  			return true
  1168  		}
  1169  
  1170  		bxc, err := Gte(b, c, AsSameType())
  1171  		if err, retEarly := qcErrCheck(t, "Gte - b∙c", c, b, we, err); retEarly {
  1172  			if err != nil {
  1173  				return false
  1174  			}
  1175  			return true
  1176  		}
  1177  
  1178  		axc, err := Gte(a, c, AsSameType())
  1179  		if err, retEarly := qcErrCheck(t, "Gte - a∙c", a, c, we, err); retEarly {
  1180  			if err != nil {
  1181  				return false
  1182  			}
  1183  			return true
  1184  		}
  1185  
  1186  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
  1187  			t.Errorf("a: %-v", a)
  1188  			t.Errorf("b: %-v", b)
  1189  			t.Errorf("c: %-v", c)
  1190  			t.Errorf("axb.Data() %v", axb.Data())
  1191  			t.Errorf("bxc.Data() %v", bxc.Data())
  1192  			t.Errorf("axc.Data() %v", axc.Data())
  1193  			return false
  1194  		}
  1195  
  1196  		return true
  1197  	}
  1198  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1199  		t.Errorf("Transitivity test for Gte failed: %v", err)
  1200  	}
  1201  
  1202  }
  1203  func TestLtScalar_assame(t *testing.T) {
  1204  	transFn := func(q *Dense) bool {
  1205  		we, _ := willerr(q, nonComplexNumberTypes, nil)
  1206  		_, ok := q.Engine().(Lter)
  1207  		we = we || !ok
  1208  
  1209  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
  1210  			return true // we exit early if the generated type is not something we can handle
  1211  		}
  1212  		r := newRand()
  1213  		a := q.Clone().(*Dense)
  1214  		bv, _ := quick.Value(a.Dtype().Type, r)
  1215  		b := bv.Interface()
  1216  		c := q.Clone().(*Dense)
  1217  		cv, _ := quick.Value(c.Dtype().Type, r)
  1218  		c.Memset(cv.Interface())
  1219  
  1220  		axb, err := Lt(a, b, AsSameType())
  1221  		if err, retEarly := qcErrCheck(t, "Lt - a∙b", a, b, we, err); retEarly {
  1222  			if err != nil {
  1223  				return false
  1224  			}
  1225  			return true
  1226  		}
  1227  
  1228  		bxc, err := Lt(b, c, AsSameType())
  1229  		if err, retEarly := qcErrCheck(t, "Lt - b∙c", c, b, we, err); retEarly {
  1230  			if err != nil {
  1231  				return false
  1232  			}
  1233  			return true
  1234  		}
  1235  
  1236  		axc, err := Lt(a, c, AsSameType())
  1237  		if err, retEarly := qcErrCheck(t, "Lt - a∙c", a, c, we, err); retEarly {
  1238  			if err != nil {
  1239  				return false
  1240  			}
  1241  			return true
  1242  		}
  1243  
  1244  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
  1245  			t.Errorf("a: %-v", a)
  1246  			t.Errorf("b: %-v", b)
  1247  			t.Errorf("c: %-v", c)
  1248  			t.Errorf("axb.Data() %v", axb.Data())
  1249  			t.Errorf("bxc.Data() %v", bxc.Data())
  1250  			t.Errorf("axc.Data() %v", axc.Data())
  1251  			return false
  1252  		}
  1253  
  1254  		return true
  1255  	}
  1256  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1257  		t.Errorf("Transitivity test for Lt failed: %v", err)
  1258  	}
  1259  
  1260  }
  1261  func TestLteScalar_assame(t *testing.T) {
  1262  	transFn := func(q *Dense) bool {
  1263  		we, _ := willerr(q, nonComplexNumberTypes, nil)
  1264  		_, ok := q.Engine().(Lteer)
  1265  		we = we || !ok
  1266  
  1267  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
  1268  			return true // we exit early if the generated type is not something we can handle
  1269  		}
  1270  		r := newRand()
  1271  		a := q.Clone().(*Dense)
  1272  		bv, _ := quick.Value(a.Dtype().Type, r)
  1273  		b := bv.Interface()
  1274  		c := q.Clone().(*Dense)
  1275  		cv, _ := quick.Value(c.Dtype().Type, r)
  1276  		c.Memset(cv.Interface())
  1277  
  1278  		axb, err := Lte(a, b, AsSameType())
  1279  		if err, retEarly := qcErrCheck(t, "Lte - a∙b", a, b, we, err); retEarly {
  1280  			if err != nil {
  1281  				return false
  1282  			}
  1283  			return true
  1284  		}
  1285  
  1286  		bxc, err := Lte(b, c, AsSameType())
  1287  		if err, retEarly := qcErrCheck(t, "Lte - b∙c", c, b, we, err); retEarly {
  1288  			if err != nil {
  1289  				return false
  1290  			}
  1291  			return true
  1292  		}
  1293  
  1294  		axc, err := Lte(a, c, AsSameType())
  1295  		if err, retEarly := qcErrCheck(t, "Lte - a∙c", a, c, we, err); retEarly {
  1296  			if err != nil {
  1297  				return false
  1298  			}
  1299  			return true
  1300  		}
  1301  
  1302  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
  1303  			t.Errorf("a: %-v", a)
  1304  			t.Errorf("b: %-v", b)
  1305  			t.Errorf("c: %-v", c)
  1306  			t.Errorf("axb.Data() %v", axb.Data())
  1307  			t.Errorf("bxc.Data() %v", bxc.Data())
  1308  			t.Errorf("axc.Data() %v", axc.Data())
  1309  			return false
  1310  		}
  1311  
  1312  		return true
  1313  	}
  1314  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1315  		t.Errorf("Transitivity test for Lte failed: %v", err)
  1316  	}
  1317  
  1318  }
  1319  func TestEqScalar_assame(t *testing.T) {
  1320  	transFn := func(q *Dense) bool {
  1321  		we, _ := willerr(q, nonComplexNumberTypes, nil)
  1322  		_, ok := q.Engine().(ElEqer)
  1323  		we = we || !ok
  1324  
  1325  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
  1326  			return true // we exit early if the generated type is not something we can handle
  1327  		}
  1328  		r := newRand()
  1329  		a := q.Clone().(*Dense)
  1330  		bv, _ := quick.Value(a.Dtype().Type, r)
  1331  		b := bv.Interface()
  1332  		c := q.Clone().(*Dense)
  1333  		cv, _ := quick.Value(c.Dtype().Type, r)
  1334  		c.Memset(cv.Interface())
  1335  
  1336  		axb, err := ElEq(a, b, AsSameType())
  1337  		if err, retEarly := qcErrCheck(t, "ElEq - a∙b", a, b, we, err); retEarly {
  1338  			if err != nil {
  1339  				return false
  1340  			}
  1341  			return true
  1342  		}
  1343  
  1344  		bxc, err := ElEq(b, c, AsSameType())
  1345  		if err, retEarly := qcErrCheck(t, "ElEq - b∙c", c, b, we, err); retEarly {
  1346  			if err != nil {
  1347  				return false
  1348  			}
  1349  			return true
  1350  		}
  1351  
  1352  		axc, err := ElEq(a, c, AsSameType())
  1353  		if err, retEarly := qcErrCheck(t, "ElEq - a∙c", a, c, we, err); retEarly {
  1354  			if err != nil {
  1355  				return false
  1356  			}
  1357  			return true
  1358  		}
  1359  
  1360  		if !threewayEq(axb.Data(), bxc.Data(), axc.Data()) {
  1361  			t.Errorf("a: %-v", a)
  1362  			t.Errorf("b: %-v", b)
  1363  			t.Errorf("c: %-v", c)
  1364  			t.Errorf("axb.Data() %v", axb.Data())
  1365  			t.Errorf("bxc.Data() %v", bxc.Data())
  1366  			t.Errorf("axc.Data() %v", axc.Data())
  1367  			return false
  1368  		}
  1369  
  1370  		return true
  1371  	}
  1372  	if err := quick.Check(transFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1373  		t.Errorf("Transitivity test for ElEq failed: %v", err)
  1374  	}
  1375  
  1376  	symFn := func(q *Dense) bool {
  1377  		we, _ := willerr(q, nonComplexNumberTypes, nil)
  1378  		_, ok := q.Engine().(ElEqer)
  1379  		we = we || !ok
  1380  
  1381  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
  1382  			return true // we exit early if the generated type is not something we can handle
  1383  		}
  1384  		r := newRand()
  1385  		a := q.Clone().(*Dense)
  1386  		bv, _ := quick.Value(a.Dtype().Type, r)
  1387  		b := bv.Interface()
  1388  
  1389  		axb, err := ElEq(a, b, AsSameType())
  1390  		if err, retEarly := qcErrCheck(t, "ElEq - a∙b", a, b, we, err); retEarly {
  1391  			if err != nil {
  1392  				return false
  1393  			}
  1394  			return true
  1395  		}
  1396  
  1397  		bxa, err := ElEq(b, a, AsSameType())
  1398  		if err, retEarly := qcErrCheck(t, "ElEq - b∙a", a, b, we, err); retEarly {
  1399  			if err != nil {
  1400  				return false
  1401  			}
  1402  			return true
  1403  		}
  1404  		return reflect.DeepEqual(axb.Data(), bxa.Data())
  1405  
  1406  	}
  1407  	if err := quick.Check(symFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1408  		t.Errorf("Symmetry test for ElEq failed: %v", err)
  1409  	}
  1410  }
  1411  func TestNeScalar_assame(t *testing.T) {
  1412  	symFn := func(q *Dense) bool {
  1413  		we, _ := willerr(q, nonComplexNumberTypes, nil)
  1414  		_, ok := q.Engine().(ElEqer)
  1415  		we = we || !ok
  1416  
  1417  		if err := typeclassCheck(q.Dtype(), nonComplexNumberTypes); err != nil {
  1418  			return true // we exit early if the generated type is not something we can handle
  1419  		}
  1420  		r := newRand()
  1421  		a := q.Clone().(*Dense)
  1422  		bv, _ := quick.Value(a.Dtype().Type, r)
  1423  		b := bv.Interface()
  1424  
  1425  		axb, err := ElNe(a, b, AsSameType())
  1426  		if err, retEarly := qcErrCheck(t, "ElNe - a∙b", a, b, we, err); retEarly {
  1427  			if err != nil {
  1428  				return false
  1429  			}
  1430  			return true
  1431  		}
  1432  
  1433  		bxa, err := ElNe(b, a, AsSameType())
  1434  		if err, retEarly := qcErrCheck(t, "ElNe - b∙a", a, b, we, err); retEarly {
  1435  			if err != nil {
  1436  				return false
  1437  			}
  1438  			return true
  1439  		}
  1440  		return reflect.DeepEqual(axb.Data(), bxa.Data())
  1441  
  1442  	}
  1443  	if err := quick.Check(symFn, &quick.Config{Rand: newRand(), MaxCount: quickchecks}); err != nil {
  1444  		t.Errorf("Symmetry test for ElNe failed: %v", err)
  1445  	}
  1446  }