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

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