gorgonia.org/tensor@v0.9.24/internal/execution/eng_argmethods.go (about)

     1  // Code generated by genlib2. DO NOT EDIT.
     2  
     3  package execution
     4  
     5  import (
     6  	"reflect"
     7  
     8  	"github.com/pkg/errors"
     9  	"gorgonia.org/tensor/internal/storage"
    10  )
    11  
    12  func (e E) ArgmaxIter(t reflect.Type, a *storage.Header, it Iterator, lastSize int) (indices []int, err error) {
    13  	var next int
    14  	switch t {
    15  	case Int:
    16  		data := a.Ints()
    17  		tmp := make([]int, 0, lastSize)
    18  		for next, err = it.Next(); err == nil; next, err = it.Next() {
    19  			tmp = append(tmp, data[next])
    20  			if len(tmp) == lastSize {
    21  				am := ArgmaxI(tmp)
    22  				indices = append(indices, am)
    23  
    24  				// reset
    25  				tmp = tmp[:0]
    26  			}
    27  		}
    28  		if _, ok := err.(NoOpError); ok {
    29  			err = nil
    30  		}
    31  		return
    32  	case Int8:
    33  		data := a.Int8s()
    34  		tmp := make([]int8, 0, lastSize)
    35  		for next, err = it.Next(); err == nil; next, err = it.Next() {
    36  			tmp = append(tmp, data[next])
    37  			if len(tmp) == lastSize {
    38  				am := ArgmaxI8(tmp)
    39  				indices = append(indices, am)
    40  
    41  				// reset
    42  				tmp = tmp[:0]
    43  			}
    44  		}
    45  		if _, ok := err.(NoOpError); ok {
    46  			err = nil
    47  		}
    48  		return
    49  	case Int16:
    50  		data := a.Int16s()
    51  		tmp := make([]int16, 0, lastSize)
    52  		for next, err = it.Next(); err == nil; next, err = it.Next() {
    53  			tmp = append(tmp, data[next])
    54  			if len(tmp) == lastSize {
    55  				am := ArgmaxI16(tmp)
    56  				indices = append(indices, am)
    57  
    58  				// reset
    59  				tmp = tmp[:0]
    60  			}
    61  		}
    62  		if _, ok := err.(NoOpError); ok {
    63  			err = nil
    64  		}
    65  		return
    66  	case Int32:
    67  		data := a.Int32s()
    68  		tmp := make([]int32, 0, lastSize)
    69  		for next, err = it.Next(); err == nil; next, err = it.Next() {
    70  			tmp = append(tmp, data[next])
    71  			if len(tmp) == lastSize {
    72  				am := ArgmaxI32(tmp)
    73  				indices = append(indices, am)
    74  
    75  				// reset
    76  				tmp = tmp[:0]
    77  			}
    78  		}
    79  		if _, ok := err.(NoOpError); ok {
    80  			err = nil
    81  		}
    82  		return
    83  	case Int64:
    84  		data := a.Int64s()
    85  		tmp := make([]int64, 0, lastSize)
    86  		for next, err = it.Next(); err == nil; next, err = it.Next() {
    87  			tmp = append(tmp, data[next])
    88  			if len(tmp) == lastSize {
    89  				am := ArgmaxI64(tmp)
    90  				indices = append(indices, am)
    91  
    92  				// reset
    93  				tmp = tmp[:0]
    94  			}
    95  		}
    96  		if _, ok := err.(NoOpError); ok {
    97  			err = nil
    98  		}
    99  		return
   100  	case Uint:
   101  		data := a.Uints()
   102  		tmp := make([]uint, 0, lastSize)
   103  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   104  			tmp = append(tmp, data[next])
   105  			if len(tmp) == lastSize {
   106  				am := ArgmaxU(tmp)
   107  				indices = append(indices, am)
   108  
   109  				// reset
   110  				tmp = tmp[:0]
   111  			}
   112  		}
   113  		if _, ok := err.(NoOpError); ok {
   114  			err = nil
   115  		}
   116  		return
   117  	case Uint8:
   118  		data := a.Uint8s()
   119  		tmp := make([]uint8, 0, lastSize)
   120  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   121  			tmp = append(tmp, data[next])
   122  			if len(tmp) == lastSize {
   123  				am := ArgmaxU8(tmp)
   124  				indices = append(indices, am)
   125  
   126  				// reset
   127  				tmp = tmp[:0]
   128  			}
   129  		}
   130  		if _, ok := err.(NoOpError); ok {
   131  			err = nil
   132  		}
   133  		return
   134  	case Uint16:
   135  		data := a.Uint16s()
   136  		tmp := make([]uint16, 0, lastSize)
   137  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   138  			tmp = append(tmp, data[next])
   139  			if len(tmp) == lastSize {
   140  				am := ArgmaxU16(tmp)
   141  				indices = append(indices, am)
   142  
   143  				// reset
   144  				tmp = tmp[:0]
   145  			}
   146  		}
   147  		if _, ok := err.(NoOpError); ok {
   148  			err = nil
   149  		}
   150  		return
   151  	case Uint32:
   152  		data := a.Uint32s()
   153  		tmp := make([]uint32, 0, lastSize)
   154  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   155  			tmp = append(tmp, data[next])
   156  			if len(tmp) == lastSize {
   157  				am := ArgmaxU32(tmp)
   158  				indices = append(indices, am)
   159  
   160  				// reset
   161  				tmp = tmp[:0]
   162  			}
   163  		}
   164  		if _, ok := err.(NoOpError); ok {
   165  			err = nil
   166  		}
   167  		return
   168  	case Uint64:
   169  		data := a.Uint64s()
   170  		tmp := make([]uint64, 0, lastSize)
   171  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   172  			tmp = append(tmp, data[next])
   173  			if len(tmp) == lastSize {
   174  				am := ArgmaxU64(tmp)
   175  				indices = append(indices, am)
   176  
   177  				// reset
   178  				tmp = tmp[:0]
   179  			}
   180  		}
   181  		if _, ok := err.(NoOpError); ok {
   182  			err = nil
   183  		}
   184  		return
   185  	case Float32:
   186  		data := a.Float32s()
   187  		tmp := make([]float32, 0, lastSize)
   188  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   189  			tmp = append(tmp, data[next])
   190  			if len(tmp) == lastSize {
   191  				am := ArgmaxF32(tmp)
   192  				indices = append(indices, am)
   193  
   194  				// reset
   195  				tmp = tmp[:0]
   196  			}
   197  		}
   198  		if _, ok := err.(NoOpError); ok {
   199  			err = nil
   200  		}
   201  		return
   202  	case Float64:
   203  		data := a.Float64s()
   204  		tmp := make([]float64, 0, lastSize)
   205  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   206  			tmp = append(tmp, data[next])
   207  			if len(tmp) == lastSize {
   208  				am := ArgmaxF64(tmp)
   209  				indices = append(indices, am)
   210  
   211  				// reset
   212  				tmp = tmp[:0]
   213  			}
   214  		}
   215  		if _, ok := err.(NoOpError); ok {
   216  			err = nil
   217  		}
   218  		return
   219  	case String:
   220  		data := a.Strings()
   221  		tmp := make([]string, 0, lastSize)
   222  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   223  			tmp = append(tmp, data[next])
   224  			if len(tmp) == lastSize {
   225  				am := ArgmaxStr(tmp)
   226  				indices = append(indices, am)
   227  
   228  				// reset
   229  				tmp = tmp[:0]
   230  			}
   231  		}
   232  		if _, ok := err.(NoOpError); ok {
   233  			err = nil
   234  		}
   235  		return
   236  	default:
   237  		return nil, errors.Errorf("Unsupported type %v for Argmax", t)
   238  	}
   239  }
   240  func (e E) ArgminIter(t reflect.Type, a *storage.Header, it Iterator, lastSize int) (indices []int, err error) {
   241  	var next int
   242  	switch t {
   243  	case Int:
   244  		data := a.Ints()
   245  		tmp := make([]int, 0, lastSize)
   246  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   247  			tmp = append(tmp, data[next])
   248  			if len(tmp) == lastSize {
   249  				am := ArgminI(tmp)
   250  				indices = append(indices, am)
   251  
   252  				// reset
   253  				tmp = tmp[:0]
   254  			}
   255  		}
   256  		if _, ok := err.(NoOpError); ok {
   257  			err = nil
   258  		}
   259  		return
   260  	case Int8:
   261  		data := a.Int8s()
   262  		tmp := make([]int8, 0, lastSize)
   263  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   264  			tmp = append(tmp, data[next])
   265  			if len(tmp) == lastSize {
   266  				am := ArgminI8(tmp)
   267  				indices = append(indices, am)
   268  
   269  				// reset
   270  				tmp = tmp[:0]
   271  			}
   272  		}
   273  		if _, ok := err.(NoOpError); ok {
   274  			err = nil
   275  		}
   276  		return
   277  	case Int16:
   278  		data := a.Int16s()
   279  		tmp := make([]int16, 0, lastSize)
   280  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   281  			tmp = append(tmp, data[next])
   282  			if len(tmp) == lastSize {
   283  				am := ArgminI16(tmp)
   284  				indices = append(indices, am)
   285  
   286  				// reset
   287  				tmp = tmp[:0]
   288  			}
   289  		}
   290  		if _, ok := err.(NoOpError); ok {
   291  			err = nil
   292  		}
   293  		return
   294  	case Int32:
   295  		data := a.Int32s()
   296  		tmp := make([]int32, 0, lastSize)
   297  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   298  			tmp = append(tmp, data[next])
   299  			if len(tmp) == lastSize {
   300  				am := ArgminI32(tmp)
   301  				indices = append(indices, am)
   302  
   303  				// reset
   304  				tmp = tmp[:0]
   305  			}
   306  		}
   307  		if _, ok := err.(NoOpError); ok {
   308  			err = nil
   309  		}
   310  		return
   311  	case Int64:
   312  		data := a.Int64s()
   313  		tmp := make([]int64, 0, lastSize)
   314  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   315  			tmp = append(tmp, data[next])
   316  			if len(tmp) == lastSize {
   317  				am := ArgminI64(tmp)
   318  				indices = append(indices, am)
   319  
   320  				// reset
   321  				tmp = tmp[:0]
   322  			}
   323  		}
   324  		if _, ok := err.(NoOpError); ok {
   325  			err = nil
   326  		}
   327  		return
   328  	case Uint:
   329  		data := a.Uints()
   330  		tmp := make([]uint, 0, lastSize)
   331  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   332  			tmp = append(tmp, data[next])
   333  			if len(tmp) == lastSize {
   334  				am := ArgminU(tmp)
   335  				indices = append(indices, am)
   336  
   337  				// reset
   338  				tmp = tmp[:0]
   339  			}
   340  		}
   341  		if _, ok := err.(NoOpError); ok {
   342  			err = nil
   343  		}
   344  		return
   345  	case Uint8:
   346  		data := a.Uint8s()
   347  		tmp := make([]uint8, 0, lastSize)
   348  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   349  			tmp = append(tmp, data[next])
   350  			if len(tmp) == lastSize {
   351  				am := ArgminU8(tmp)
   352  				indices = append(indices, am)
   353  
   354  				// reset
   355  				tmp = tmp[:0]
   356  			}
   357  		}
   358  		if _, ok := err.(NoOpError); ok {
   359  			err = nil
   360  		}
   361  		return
   362  	case Uint16:
   363  		data := a.Uint16s()
   364  		tmp := make([]uint16, 0, lastSize)
   365  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   366  			tmp = append(tmp, data[next])
   367  			if len(tmp) == lastSize {
   368  				am := ArgminU16(tmp)
   369  				indices = append(indices, am)
   370  
   371  				// reset
   372  				tmp = tmp[:0]
   373  			}
   374  		}
   375  		if _, ok := err.(NoOpError); ok {
   376  			err = nil
   377  		}
   378  		return
   379  	case Uint32:
   380  		data := a.Uint32s()
   381  		tmp := make([]uint32, 0, lastSize)
   382  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   383  			tmp = append(tmp, data[next])
   384  			if len(tmp) == lastSize {
   385  				am := ArgminU32(tmp)
   386  				indices = append(indices, am)
   387  
   388  				// reset
   389  				tmp = tmp[:0]
   390  			}
   391  		}
   392  		if _, ok := err.(NoOpError); ok {
   393  			err = nil
   394  		}
   395  		return
   396  	case Uint64:
   397  		data := a.Uint64s()
   398  		tmp := make([]uint64, 0, lastSize)
   399  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   400  			tmp = append(tmp, data[next])
   401  			if len(tmp) == lastSize {
   402  				am := ArgminU64(tmp)
   403  				indices = append(indices, am)
   404  
   405  				// reset
   406  				tmp = tmp[:0]
   407  			}
   408  		}
   409  		if _, ok := err.(NoOpError); ok {
   410  			err = nil
   411  		}
   412  		return
   413  	case Float32:
   414  		data := a.Float32s()
   415  		tmp := make([]float32, 0, lastSize)
   416  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   417  			tmp = append(tmp, data[next])
   418  			if len(tmp) == lastSize {
   419  				am := ArgminF32(tmp)
   420  				indices = append(indices, am)
   421  
   422  				// reset
   423  				tmp = tmp[:0]
   424  			}
   425  		}
   426  		if _, ok := err.(NoOpError); ok {
   427  			err = nil
   428  		}
   429  		return
   430  	case Float64:
   431  		data := a.Float64s()
   432  		tmp := make([]float64, 0, lastSize)
   433  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   434  			tmp = append(tmp, data[next])
   435  			if len(tmp) == lastSize {
   436  				am := ArgminF64(tmp)
   437  				indices = append(indices, am)
   438  
   439  				// reset
   440  				tmp = tmp[:0]
   441  			}
   442  		}
   443  		if _, ok := err.(NoOpError); ok {
   444  			err = nil
   445  		}
   446  		return
   447  	case String:
   448  		data := a.Strings()
   449  		tmp := make([]string, 0, lastSize)
   450  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   451  			tmp = append(tmp, data[next])
   452  			if len(tmp) == lastSize {
   453  				am := ArgminStr(tmp)
   454  				indices = append(indices, am)
   455  
   456  				// reset
   457  				tmp = tmp[:0]
   458  			}
   459  		}
   460  		if _, ok := err.(NoOpError); ok {
   461  			err = nil
   462  		}
   463  		return
   464  	default:
   465  		return nil, errors.Errorf("Unsupported type %v for Argmin", t)
   466  	}
   467  }
   468  func (e E) ArgmaxIterMasked(t reflect.Type, a *storage.Header, mask []bool, it Iterator, lastSize int) (indices []int, err error) {
   469  	newMask := make([]bool, 0, lastSize)
   470  	var next int
   471  	switch t {
   472  	case Int:
   473  		data := a.Ints()
   474  		tmp := make([]int, 0, lastSize)
   475  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   476  			tmp = append(tmp, data[next])
   477  			newMask = append(newMask, mask[next])
   478  			if len(tmp) == lastSize {
   479  				am := ArgmaxMaskedI(tmp, mask)
   480  				indices = append(indices, am)
   481  
   482  				// reset
   483  				tmp = tmp[:0]
   484  				newMask = newMask[:0]
   485  			}
   486  		}
   487  		if _, ok := err.(NoOpError); ok {
   488  			err = nil
   489  		}
   490  		return
   491  	case Int8:
   492  		data := a.Int8s()
   493  		tmp := make([]int8, 0, lastSize)
   494  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   495  			tmp = append(tmp, data[next])
   496  			newMask = append(newMask, mask[next])
   497  			if len(tmp) == lastSize {
   498  				am := ArgmaxMaskedI8(tmp, mask)
   499  				indices = append(indices, am)
   500  
   501  				// reset
   502  				tmp = tmp[:0]
   503  				newMask = newMask[:0]
   504  			}
   505  		}
   506  		if _, ok := err.(NoOpError); ok {
   507  			err = nil
   508  		}
   509  		return
   510  	case Int16:
   511  		data := a.Int16s()
   512  		tmp := make([]int16, 0, lastSize)
   513  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   514  			tmp = append(tmp, data[next])
   515  			newMask = append(newMask, mask[next])
   516  			if len(tmp) == lastSize {
   517  				am := ArgmaxMaskedI16(tmp, mask)
   518  				indices = append(indices, am)
   519  
   520  				// reset
   521  				tmp = tmp[:0]
   522  				newMask = newMask[:0]
   523  			}
   524  		}
   525  		if _, ok := err.(NoOpError); ok {
   526  			err = nil
   527  		}
   528  		return
   529  	case Int32:
   530  		data := a.Int32s()
   531  		tmp := make([]int32, 0, lastSize)
   532  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   533  			tmp = append(tmp, data[next])
   534  			newMask = append(newMask, mask[next])
   535  			if len(tmp) == lastSize {
   536  				am := ArgmaxMaskedI32(tmp, mask)
   537  				indices = append(indices, am)
   538  
   539  				// reset
   540  				tmp = tmp[:0]
   541  				newMask = newMask[:0]
   542  			}
   543  		}
   544  		if _, ok := err.(NoOpError); ok {
   545  			err = nil
   546  		}
   547  		return
   548  	case Int64:
   549  		data := a.Int64s()
   550  		tmp := make([]int64, 0, lastSize)
   551  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   552  			tmp = append(tmp, data[next])
   553  			newMask = append(newMask, mask[next])
   554  			if len(tmp) == lastSize {
   555  				am := ArgmaxMaskedI64(tmp, mask)
   556  				indices = append(indices, am)
   557  
   558  				// reset
   559  				tmp = tmp[:0]
   560  				newMask = newMask[:0]
   561  			}
   562  		}
   563  		if _, ok := err.(NoOpError); ok {
   564  			err = nil
   565  		}
   566  		return
   567  	case Uint:
   568  		data := a.Uints()
   569  		tmp := make([]uint, 0, lastSize)
   570  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   571  			tmp = append(tmp, data[next])
   572  			newMask = append(newMask, mask[next])
   573  			if len(tmp) == lastSize {
   574  				am := ArgmaxMaskedU(tmp, mask)
   575  				indices = append(indices, am)
   576  
   577  				// reset
   578  				tmp = tmp[:0]
   579  				newMask = newMask[:0]
   580  			}
   581  		}
   582  		if _, ok := err.(NoOpError); ok {
   583  			err = nil
   584  		}
   585  		return
   586  	case Uint8:
   587  		data := a.Uint8s()
   588  		tmp := make([]uint8, 0, lastSize)
   589  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   590  			tmp = append(tmp, data[next])
   591  			newMask = append(newMask, mask[next])
   592  			if len(tmp) == lastSize {
   593  				am := ArgmaxMaskedU8(tmp, mask)
   594  				indices = append(indices, am)
   595  
   596  				// reset
   597  				tmp = tmp[:0]
   598  				newMask = newMask[:0]
   599  			}
   600  		}
   601  		if _, ok := err.(NoOpError); ok {
   602  			err = nil
   603  		}
   604  		return
   605  	case Uint16:
   606  		data := a.Uint16s()
   607  		tmp := make([]uint16, 0, lastSize)
   608  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   609  			tmp = append(tmp, data[next])
   610  			newMask = append(newMask, mask[next])
   611  			if len(tmp) == lastSize {
   612  				am := ArgmaxMaskedU16(tmp, mask)
   613  				indices = append(indices, am)
   614  
   615  				// reset
   616  				tmp = tmp[:0]
   617  				newMask = newMask[:0]
   618  			}
   619  		}
   620  		if _, ok := err.(NoOpError); ok {
   621  			err = nil
   622  		}
   623  		return
   624  	case Uint32:
   625  		data := a.Uint32s()
   626  		tmp := make([]uint32, 0, lastSize)
   627  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   628  			tmp = append(tmp, data[next])
   629  			newMask = append(newMask, mask[next])
   630  			if len(tmp) == lastSize {
   631  				am := ArgmaxMaskedU32(tmp, mask)
   632  				indices = append(indices, am)
   633  
   634  				// reset
   635  				tmp = tmp[:0]
   636  				newMask = newMask[:0]
   637  			}
   638  		}
   639  		if _, ok := err.(NoOpError); ok {
   640  			err = nil
   641  		}
   642  		return
   643  	case Uint64:
   644  		data := a.Uint64s()
   645  		tmp := make([]uint64, 0, lastSize)
   646  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   647  			tmp = append(tmp, data[next])
   648  			newMask = append(newMask, mask[next])
   649  			if len(tmp) == lastSize {
   650  				am := ArgmaxMaskedU64(tmp, mask)
   651  				indices = append(indices, am)
   652  
   653  				// reset
   654  				tmp = tmp[:0]
   655  				newMask = newMask[:0]
   656  			}
   657  		}
   658  		if _, ok := err.(NoOpError); ok {
   659  			err = nil
   660  		}
   661  		return
   662  	case Float32:
   663  		data := a.Float32s()
   664  		tmp := make([]float32, 0, lastSize)
   665  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   666  			tmp = append(tmp, data[next])
   667  			newMask = append(newMask, mask[next])
   668  			if len(tmp) == lastSize {
   669  				am := ArgmaxMaskedF32(tmp, mask)
   670  				indices = append(indices, am)
   671  
   672  				// reset
   673  				tmp = tmp[:0]
   674  				newMask = newMask[:0]
   675  			}
   676  		}
   677  		if _, ok := err.(NoOpError); ok {
   678  			err = nil
   679  		}
   680  		return
   681  	case Float64:
   682  		data := a.Float64s()
   683  		tmp := make([]float64, 0, lastSize)
   684  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   685  			tmp = append(tmp, data[next])
   686  			newMask = append(newMask, mask[next])
   687  			if len(tmp) == lastSize {
   688  				am := ArgmaxMaskedF64(tmp, mask)
   689  				indices = append(indices, am)
   690  
   691  				// reset
   692  				tmp = tmp[:0]
   693  				newMask = newMask[:0]
   694  			}
   695  		}
   696  		if _, ok := err.(NoOpError); ok {
   697  			err = nil
   698  		}
   699  		return
   700  	case String:
   701  		data := a.Strings()
   702  		tmp := make([]string, 0, lastSize)
   703  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   704  			tmp = append(tmp, data[next])
   705  			newMask = append(newMask, mask[next])
   706  			if len(tmp) == lastSize {
   707  				am := ArgmaxMaskedStr(tmp, mask)
   708  				indices = append(indices, am)
   709  
   710  				// reset
   711  				tmp = tmp[:0]
   712  				newMask = newMask[:0]
   713  			}
   714  		}
   715  		if _, ok := err.(NoOpError); ok {
   716  			err = nil
   717  		}
   718  		return
   719  	default:
   720  		return nil, errors.Errorf("Unsupported type %v for Argmax", t)
   721  	}
   722  }
   723  func (e E) ArgminIterMasked(t reflect.Type, a *storage.Header, mask []bool, it Iterator, lastSize int) (indices []int, err error) {
   724  	newMask := make([]bool, 0, lastSize)
   725  	var next int
   726  	switch t {
   727  	case Int:
   728  		data := a.Ints()
   729  		tmp := make([]int, 0, lastSize)
   730  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   731  			tmp = append(tmp, data[next])
   732  			newMask = append(newMask, mask[next])
   733  			if len(tmp) == lastSize {
   734  				am := ArgminMaskedI(tmp, mask)
   735  				indices = append(indices, am)
   736  
   737  				// reset
   738  				tmp = tmp[:0]
   739  				newMask = newMask[:0]
   740  			}
   741  		}
   742  		if _, ok := err.(NoOpError); ok {
   743  			err = nil
   744  		}
   745  		return
   746  	case Int8:
   747  		data := a.Int8s()
   748  		tmp := make([]int8, 0, lastSize)
   749  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   750  			tmp = append(tmp, data[next])
   751  			newMask = append(newMask, mask[next])
   752  			if len(tmp) == lastSize {
   753  				am := ArgminMaskedI8(tmp, mask)
   754  				indices = append(indices, am)
   755  
   756  				// reset
   757  				tmp = tmp[:0]
   758  				newMask = newMask[:0]
   759  			}
   760  		}
   761  		if _, ok := err.(NoOpError); ok {
   762  			err = nil
   763  		}
   764  		return
   765  	case Int16:
   766  		data := a.Int16s()
   767  		tmp := make([]int16, 0, lastSize)
   768  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   769  			tmp = append(tmp, data[next])
   770  			newMask = append(newMask, mask[next])
   771  			if len(tmp) == lastSize {
   772  				am := ArgminMaskedI16(tmp, mask)
   773  				indices = append(indices, am)
   774  
   775  				// reset
   776  				tmp = tmp[:0]
   777  				newMask = newMask[:0]
   778  			}
   779  		}
   780  		if _, ok := err.(NoOpError); ok {
   781  			err = nil
   782  		}
   783  		return
   784  	case Int32:
   785  		data := a.Int32s()
   786  		tmp := make([]int32, 0, lastSize)
   787  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   788  			tmp = append(tmp, data[next])
   789  			newMask = append(newMask, mask[next])
   790  			if len(tmp) == lastSize {
   791  				am := ArgminMaskedI32(tmp, mask)
   792  				indices = append(indices, am)
   793  
   794  				// reset
   795  				tmp = tmp[:0]
   796  				newMask = newMask[:0]
   797  			}
   798  		}
   799  		if _, ok := err.(NoOpError); ok {
   800  			err = nil
   801  		}
   802  		return
   803  	case Int64:
   804  		data := a.Int64s()
   805  		tmp := make([]int64, 0, lastSize)
   806  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   807  			tmp = append(tmp, data[next])
   808  			newMask = append(newMask, mask[next])
   809  			if len(tmp) == lastSize {
   810  				am := ArgminMaskedI64(tmp, mask)
   811  				indices = append(indices, am)
   812  
   813  				// reset
   814  				tmp = tmp[:0]
   815  				newMask = newMask[:0]
   816  			}
   817  		}
   818  		if _, ok := err.(NoOpError); ok {
   819  			err = nil
   820  		}
   821  		return
   822  	case Uint:
   823  		data := a.Uints()
   824  		tmp := make([]uint, 0, lastSize)
   825  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   826  			tmp = append(tmp, data[next])
   827  			newMask = append(newMask, mask[next])
   828  			if len(tmp) == lastSize {
   829  				am := ArgminMaskedU(tmp, mask)
   830  				indices = append(indices, am)
   831  
   832  				// reset
   833  				tmp = tmp[:0]
   834  				newMask = newMask[:0]
   835  			}
   836  		}
   837  		if _, ok := err.(NoOpError); ok {
   838  			err = nil
   839  		}
   840  		return
   841  	case Uint8:
   842  		data := a.Uint8s()
   843  		tmp := make([]uint8, 0, lastSize)
   844  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   845  			tmp = append(tmp, data[next])
   846  			newMask = append(newMask, mask[next])
   847  			if len(tmp) == lastSize {
   848  				am := ArgminMaskedU8(tmp, mask)
   849  				indices = append(indices, am)
   850  
   851  				// reset
   852  				tmp = tmp[:0]
   853  				newMask = newMask[:0]
   854  			}
   855  		}
   856  		if _, ok := err.(NoOpError); ok {
   857  			err = nil
   858  		}
   859  		return
   860  	case Uint16:
   861  		data := a.Uint16s()
   862  		tmp := make([]uint16, 0, lastSize)
   863  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   864  			tmp = append(tmp, data[next])
   865  			newMask = append(newMask, mask[next])
   866  			if len(tmp) == lastSize {
   867  				am := ArgminMaskedU16(tmp, mask)
   868  				indices = append(indices, am)
   869  
   870  				// reset
   871  				tmp = tmp[:0]
   872  				newMask = newMask[:0]
   873  			}
   874  		}
   875  		if _, ok := err.(NoOpError); ok {
   876  			err = nil
   877  		}
   878  		return
   879  	case Uint32:
   880  		data := a.Uint32s()
   881  		tmp := make([]uint32, 0, lastSize)
   882  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   883  			tmp = append(tmp, data[next])
   884  			newMask = append(newMask, mask[next])
   885  			if len(tmp) == lastSize {
   886  				am := ArgminMaskedU32(tmp, mask)
   887  				indices = append(indices, am)
   888  
   889  				// reset
   890  				tmp = tmp[:0]
   891  				newMask = newMask[:0]
   892  			}
   893  		}
   894  		if _, ok := err.(NoOpError); ok {
   895  			err = nil
   896  		}
   897  		return
   898  	case Uint64:
   899  		data := a.Uint64s()
   900  		tmp := make([]uint64, 0, lastSize)
   901  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   902  			tmp = append(tmp, data[next])
   903  			newMask = append(newMask, mask[next])
   904  			if len(tmp) == lastSize {
   905  				am := ArgminMaskedU64(tmp, mask)
   906  				indices = append(indices, am)
   907  
   908  				// reset
   909  				tmp = tmp[:0]
   910  				newMask = newMask[:0]
   911  			}
   912  		}
   913  		if _, ok := err.(NoOpError); ok {
   914  			err = nil
   915  		}
   916  		return
   917  	case Float32:
   918  		data := a.Float32s()
   919  		tmp := make([]float32, 0, lastSize)
   920  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   921  			tmp = append(tmp, data[next])
   922  			newMask = append(newMask, mask[next])
   923  			if len(tmp) == lastSize {
   924  				am := ArgminMaskedF32(tmp, mask)
   925  				indices = append(indices, am)
   926  
   927  				// reset
   928  				tmp = tmp[:0]
   929  				newMask = newMask[:0]
   930  			}
   931  		}
   932  		if _, ok := err.(NoOpError); ok {
   933  			err = nil
   934  		}
   935  		return
   936  	case Float64:
   937  		data := a.Float64s()
   938  		tmp := make([]float64, 0, lastSize)
   939  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   940  			tmp = append(tmp, data[next])
   941  			newMask = append(newMask, mask[next])
   942  			if len(tmp) == lastSize {
   943  				am := ArgminMaskedF64(tmp, mask)
   944  				indices = append(indices, am)
   945  
   946  				// reset
   947  				tmp = tmp[:0]
   948  				newMask = newMask[:0]
   949  			}
   950  		}
   951  		if _, ok := err.(NoOpError); ok {
   952  			err = nil
   953  		}
   954  		return
   955  	case String:
   956  		data := a.Strings()
   957  		tmp := make([]string, 0, lastSize)
   958  		for next, err = it.Next(); err == nil; next, err = it.Next() {
   959  			tmp = append(tmp, data[next])
   960  			newMask = append(newMask, mask[next])
   961  			if len(tmp) == lastSize {
   962  				am := ArgminMaskedStr(tmp, mask)
   963  				indices = append(indices, am)
   964  
   965  				// reset
   966  				tmp = tmp[:0]
   967  				newMask = newMask[:0]
   968  			}
   969  		}
   970  		if _, ok := err.(NoOpError); ok {
   971  			err = nil
   972  		}
   973  		return
   974  	default:
   975  		return nil, errors.Errorf("Unsupported type %v for Argmin", t)
   976  	}
   977  }
   978  func (e E) ArgmaxFlatMasked(t reflect.Type, a *storage.Header, mask []bool) (retVal int) {
   979  	switch t {
   980  	case Int:
   981  		return ArgmaxMaskedI(a.Ints(), mask)
   982  	case Int8:
   983  		return ArgmaxMaskedI8(a.Int8s(), mask)
   984  	case Int16:
   985  		return ArgmaxMaskedI16(a.Int16s(), mask)
   986  	case Int32:
   987  		return ArgmaxMaskedI32(a.Int32s(), mask)
   988  	case Int64:
   989  		return ArgmaxMaskedI64(a.Int64s(), mask)
   990  	case Uint:
   991  		return ArgmaxMaskedU(a.Uints(), mask)
   992  	case Uint8:
   993  		return ArgmaxMaskedU8(a.Uint8s(), mask)
   994  	case Uint16:
   995  		return ArgmaxMaskedU16(a.Uint16s(), mask)
   996  	case Uint32:
   997  		return ArgmaxMaskedU32(a.Uint32s(), mask)
   998  	case Uint64:
   999  		return ArgmaxMaskedU64(a.Uint64s(), mask)
  1000  	case Float32:
  1001  		return ArgmaxMaskedF32(a.Float32s(), mask)
  1002  	case Float64:
  1003  		return ArgmaxMaskedF64(a.Float64s(), mask)
  1004  	case String:
  1005  		return ArgmaxMaskedStr(a.Strings(), mask)
  1006  	default:
  1007  		return -1
  1008  	}
  1009  }
  1010  func (e E) ArgminFlatMasked(t reflect.Type, a *storage.Header, mask []bool) (retVal int) {
  1011  	switch t {
  1012  	case Int:
  1013  		return ArgminMaskedI(a.Ints(), mask)
  1014  	case Int8:
  1015  		return ArgminMaskedI8(a.Int8s(), mask)
  1016  	case Int16:
  1017  		return ArgminMaskedI16(a.Int16s(), mask)
  1018  	case Int32:
  1019  		return ArgminMaskedI32(a.Int32s(), mask)
  1020  	case Int64:
  1021  		return ArgminMaskedI64(a.Int64s(), mask)
  1022  	case Uint:
  1023  		return ArgminMaskedU(a.Uints(), mask)
  1024  	case Uint8:
  1025  		return ArgminMaskedU8(a.Uint8s(), mask)
  1026  	case Uint16:
  1027  		return ArgminMaskedU16(a.Uint16s(), mask)
  1028  	case Uint32:
  1029  		return ArgminMaskedU32(a.Uint32s(), mask)
  1030  	case Uint64:
  1031  		return ArgminMaskedU64(a.Uint64s(), mask)
  1032  	case Float32:
  1033  		return ArgminMaskedF32(a.Float32s(), mask)
  1034  	case Float64:
  1035  		return ArgminMaskedF64(a.Float64s(), mask)
  1036  	case String:
  1037  		return ArgminMaskedStr(a.Strings(), mask)
  1038  	default:
  1039  		return -1
  1040  	}
  1041  }
  1042  func (e E) ArgmaxFlat(t reflect.Type, a *storage.Header) (retVal int) {
  1043  	switch t {
  1044  	case Int:
  1045  		return ArgmaxI(a.Ints())
  1046  	case Int8:
  1047  		return ArgmaxI8(a.Int8s())
  1048  	case Int16:
  1049  		return ArgmaxI16(a.Int16s())
  1050  	case Int32:
  1051  		return ArgmaxI32(a.Int32s())
  1052  	case Int64:
  1053  		return ArgmaxI64(a.Int64s())
  1054  	case Uint:
  1055  		return ArgmaxU(a.Uints())
  1056  	case Uint8:
  1057  		return ArgmaxU8(a.Uint8s())
  1058  	case Uint16:
  1059  		return ArgmaxU16(a.Uint16s())
  1060  	case Uint32:
  1061  		return ArgmaxU32(a.Uint32s())
  1062  	case Uint64:
  1063  		return ArgmaxU64(a.Uint64s())
  1064  	case Float32:
  1065  		return ArgmaxF32(a.Float32s())
  1066  	case Float64:
  1067  		return ArgmaxF64(a.Float64s())
  1068  	case String:
  1069  		return ArgmaxStr(a.Strings())
  1070  	default:
  1071  		return -1
  1072  	}
  1073  }
  1074  func (e E) ArgminFlat(t reflect.Type, a *storage.Header) (retVal int) {
  1075  	switch t {
  1076  	case Int:
  1077  		return ArgminI(a.Ints())
  1078  	case Int8:
  1079  		return ArgminI8(a.Int8s())
  1080  	case Int16:
  1081  		return ArgminI16(a.Int16s())
  1082  	case Int32:
  1083  		return ArgminI32(a.Int32s())
  1084  	case Int64:
  1085  		return ArgminI64(a.Int64s())
  1086  	case Uint:
  1087  		return ArgminU(a.Uints())
  1088  	case Uint8:
  1089  		return ArgminU8(a.Uint8s())
  1090  	case Uint16:
  1091  		return ArgminU16(a.Uint16s())
  1092  	case Uint32:
  1093  		return ArgminU32(a.Uint32s())
  1094  	case Uint64:
  1095  		return ArgminU64(a.Uint64s())
  1096  	case Float32:
  1097  		return ArgminF32(a.Float32s())
  1098  	case Float64:
  1099  		return ArgminF64(a.Float64s())
  1100  	case String:
  1101  		return ArgminStr(a.Strings())
  1102  	default:
  1103  		return -1
  1104  	}
  1105  }