gorgonia.org/tensor@v0.9.24/internal/execution/eng_unary.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) Neg(t reflect.Type, a *storage.Header) (err error) {
    13  	switch t {
    14  	case Int:
    15  		NegI(a.Ints())
    16  		return nil
    17  	case Int8:
    18  		NegI8(a.Int8s())
    19  		return nil
    20  	case Int16:
    21  		NegI16(a.Int16s())
    22  		return nil
    23  	case Int32:
    24  		NegI32(a.Int32s())
    25  		return nil
    26  	case Int64:
    27  		NegI64(a.Int64s())
    28  		return nil
    29  	case Uint:
    30  		NegU(a.Uints())
    31  		return nil
    32  	case Uint8:
    33  		NegU8(a.Uint8s())
    34  		return nil
    35  	case Uint16:
    36  		NegU16(a.Uint16s())
    37  		return nil
    38  	case Uint32:
    39  		NegU32(a.Uint32s())
    40  		return nil
    41  	case Uint64:
    42  		NegU64(a.Uint64s())
    43  		return nil
    44  	case Float32:
    45  		NegF32(a.Float32s())
    46  		return nil
    47  	case Float64:
    48  		NegF64(a.Float64s())
    49  		return nil
    50  	case Complex64:
    51  		NegC64(a.Complex64s())
    52  		return nil
    53  	case Complex128:
    54  		NegC128(a.Complex128s())
    55  		return nil
    56  	default:
    57  		return errors.Errorf("Unsupported type %v for Neg", t)
    58  	}
    59  }
    60  
    61  func (e E) Inv(t reflect.Type, a *storage.Header) (err error) {
    62  	switch t {
    63  	case Int:
    64  		InvI(a.Ints())
    65  		return nil
    66  	case Int8:
    67  		InvI8(a.Int8s())
    68  		return nil
    69  	case Int16:
    70  		InvI16(a.Int16s())
    71  		return nil
    72  	case Int32:
    73  		InvI32(a.Int32s())
    74  		return nil
    75  	case Int64:
    76  		InvI64(a.Int64s())
    77  		return nil
    78  	case Uint:
    79  		InvU(a.Uints())
    80  		return nil
    81  	case Uint8:
    82  		InvU8(a.Uint8s())
    83  		return nil
    84  	case Uint16:
    85  		InvU16(a.Uint16s())
    86  		return nil
    87  	case Uint32:
    88  		InvU32(a.Uint32s())
    89  		return nil
    90  	case Uint64:
    91  		InvU64(a.Uint64s())
    92  		return nil
    93  	case Float32:
    94  		InvF32(a.Float32s())
    95  		return nil
    96  	case Float64:
    97  		InvF64(a.Float64s())
    98  		return nil
    99  	case Complex64:
   100  		InvC64(a.Complex64s())
   101  		return nil
   102  	case Complex128:
   103  		InvC128(a.Complex128s())
   104  		return nil
   105  	default:
   106  		return errors.Errorf("Unsupported type %v for Inv", t)
   107  	}
   108  }
   109  
   110  func (e E) Square(t reflect.Type, a *storage.Header) (err error) {
   111  	switch t {
   112  	case Int:
   113  		SquareI(a.Ints())
   114  		return nil
   115  	case Int8:
   116  		SquareI8(a.Int8s())
   117  		return nil
   118  	case Int16:
   119  		SquareI16(a.Int16s())
   120  		return nil
   121  	case Int32:
   122  		SquareI32(a.Int32s())
   123  		return nil
   124  	case Int64:
   125  		SquareI64(a.Int64s())
   126  		return nil
   127  	case Uint:
   128  		SquareU(a.Uints())
   129  		return nil
   130  	case Uint8:
   131  		SquareU8(a.Uint8s())
   132  		return nil
   133  	case Uint16:
   134  		SquareU16(a.Uint16s())
   135  		return nil
   136  	case Uint32:
   137  		SquareU32(a.Uint32s())
   138  		return nil
   139  	case Uint64:
   140  		SquareU64(a.Uint64s())
   141  		return nil
   142  	case Float32:
   143  		SquareF32(a.Float32s())
   144  		return nil
   145  	case Float64:
   146  		SquareF64(a.Float64s())
   147  		return nil
   148  	case Complex64:
   149  		SquareC64(a.Complex64s())
   150  		return nil
   151  	case Complex128:
   152  		SquareC128(a.Complex128s())
   153  		return nil
   154  	default:
   155  		return errors.Errorf("Unsupported type %v for Square", t)
   156  	}
   157  }
   158  
   159  func (e E) Cube(t reflect.Type, a *storage.Header) (err error) {
   160  	switch t {
   161  	case Int:
   162  		CubeI(a.Ints())
   163  		return nil
   164  	case Int8:
   165  		CubeI8(a.Int8s())
   166  		return nil
   167  	case Int16:
   168  		CubeI16(a.Int16s())
   169  		return nil
   170  	case Int32:
   171  		CubeI32(a.Int32s())
   172  		return nil
   173  	case Int64:
   174  		CubeI64(a.Int64s())
   175  		return nil
   176  	case Uint:
   177  		CubeU(a.Uints())
   178  		return nil
   179  	case Uint8:
   180  		CubeU8(a.Uint8s())
   181  		return nil
   182  	case Uint16:
   183  		CubeU16(a.Uint16s())
   184  		return nil
   185  	case Uint32:
   186  		CubeU32(a.Uint32s())
   187  		return nil
   188  	case Uint64:
   189  		CubeU64(a.Uint64s())
   190  		return nil
   191  	case Float32:
   192  		CubeF32(a.Float32s())
   193  		return nil
   194  	case Float64:
   195  		CubeF64(a.Float64s())
   196  		return nil
   197  	case Complex64:
   198  		CubeC64(a.Complex64s())
   199  		return nil
   200  	case Complex128:
   201  		CubeC128(a.Complex128s())
   202  		return nil
   203  	default:
   204  		return errors.Errorf("Unsupported type %v for Cube", t)
   205  	}
   206  }
   207  
   208  func (e E) Exp(t reflect.Type, a *storage.Header) (err error) {
   209  	switch t {
   210  	case Float32:
   211  		ExpF32(a.Float32s())
   212  		return nil
   213  	case Float64:
   214  		ExpF64(a.Float64s())
   215  		return nil
   216  	case Complex64:
   217  		ExpC64(a.Complex64s())
   218  		return nil
   219  	case Complex128:
   220  		ExpC128(a.Complex128s())
   221  		return nil
   222  	default:
   223  		return errors.Errorf("Unsupported type %v for Exp", t)
   224  	}
   225  }
   226  
   227  func (e E) Tanh(t reflect.Type, a *storage.Header) (err error) {
   228  	switch t {
   229  	case Float32:
   230  		TanhF32(a.Float32s())
   231  		return nil
   232  	case Float64:
   233  		TanhF64(a.Float64s())
   234  		return nil
   235  	case Complex64:
   236  		TanhC64(a.Complex64s())
   237  		return nil
   238  	case Complex128:
   239  		TanhC128(a.Complex128s())
   240  		return nil
   241  	default:
   242  		return errors.Errorf("Unsupported type %v for Tanh", t)
   243  	}
   244  }
   245  
   246  func (e E) Log(t reflect.Type, a *storage.Header) (err error) {
   247  	switch t {
   248  	case Float32:
   249  		LogF32(a.Float32s())
   250  		return nil
   251  	case Float64:
   252  		LogF64(a.Float64s())
   253  		return nil
   254  	case Complex64:
   255  		LogC64(a.Complex64s())
   256  		return nil
   257  	case Complex128:
   258  		LogC128(a.Complex128s())
   259  		return nil
   260  	default:
   261  		return errors.Errorf("Unsupported type %v for Log", t)
   262  	}
   263  }
   264  
   265  func (e E) Log2(t reflect.Type, a *storage.Header) (err error) {
   266  	switch t {
   267  	case Float32:
   268  		Log2F32(a.Float32s())
   269  		return nil
   270  	case Float64:
   271  		Log2F64(a.Float64s())
   272  		return nil
   273  	default:
   274  		return errors.Errorf("Unsupported type %v for Log2", t)
   275  	}
   276  }
   277  
   278  func (e E) Log10(t reflect.Type, a *storage.Header) (err error) {
   279  	switch t {
   280  	case Float32:
   281  		Log10F32(a.Float32s())
   282  		return nil
   283  	case Float64:
   284  		Log10F64(a.Float64s())
   285  		return nil
   286  	case Complex64:
   287  		Log10C64(a.Complex64s())
   288  		return nil
   289  	case Complex128:
   290  		Log10C128(a.Complex128s())
   291  		return nil
   292  	default:
   293  		return errors.Errorf("Unsupported type %v for Log10", t)
   294  	}
   295  }
   296  
   297  func (e E) Sqrt(t reflect.Type, a *storage.Header) (err error) {
   298  	switch t {
   299  	case Float32:
   300  		SqrtF32(a.Float32s())
   301  		return nil
   302  	case Float64:
   303  		SqrtF64(a.Float64s())
   304  		return nil
   305  	case Complex64:
   306  		SqrtC64(a.Complex64s())
   307  		return nil
   308  	case Complex128:
   309  		SqrtC128(a.Complex128s())
   310  		return nil
   311  	default:
   312  		return errors.Errorf("Unsupported type %v for Sqrt", t)
   313  	}
   314  }
   315  
   316  func (e E) Cbrt(t reflect.Type, a *storage.Header) (err error) {
   317  	switch t {
   318  	case Float32:
   319  		CbrtF32(a.Float32s())
   320  		return nil
   321  	case Float64:
   322  		CbrtF64(a.Float64s())
   323  		return nil
   324  	default:
   325  		return errors.Errorf("Unsupported type %v for Cbrt", t)
   326  	}
   327  }
   328  
   329  func (e E) InvSqrt(t reflect.Type, a *storage.Header) (err error) {
   330  	switch t {
   331  	case Float32:
   332  		InvSqrtF32(a.Float32s())
   333  		return nil
   334  	case Float64:
   335  		InvSqrtF64(a.Float64s())
   336  		return nil
   337  	default:
   338  		return errors.Errorf("Unsupported type %v for InvSqrt", t)
   339  	}
   340  }
   341  
   342  func (e E) NegIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   343  	switch t {
   344  	case Int:
   345  		return NegIterI(a.Ints(), ait)
   346  	case Int8:
   347  		return NegIterI8(a.Int8s(), ait)
   348  	case Int16:
   349  		return NegIterI16(a.Int16s(), ait)
   350  	case Int32:
   351  		return NegIterI32(a.Int32s(), ait)
   352  	case Int64:
   353  		return NegIterI64(a.Int64s(), ait)
   354  	case Uint:
   355  		return NegIterU(a.Uints(), ait)
   356  	case Uint8:
   357  		return NegIterU8(a.Uint8s(), ait)
   358  	case Uint16:
   359  		return NegIterU16(a.Uint16s(), ait)
   360  	case Uint32:
   361  		return NegIterU32(a.Uint32s(), ait)
   362  	case Uint64:
   363  		return NegIterU64(a.Uint64s(), ait)
   364  	case Float32:
   365  		return NegIterF32(a.Float32s(), ait)
   366  	case Float64:
   367  		return NegIterF64(a.Float64s(), ait)
   368  	case Complex64:
   369  		return NegIterC64(a.Complex64s(), ait)
   370  	case Complex128:
   371  		return NegIterC128(a.Complex128s(), ait)
   372  	default:
   373  		return errors.Errorf("Unsupported type %v for NegIter", t)
   374  	}
   375  }
   376  
   377  func (e E) InvIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   378  	switch t {
   379  	case Int:
   380  		return InvIterI(a.Ints(), ait)
   381  	case Int8:
   382  		return InvIterI8(a.Int8s(), ait)
   383  	case Int16:
   384  		return InvIterI16(a.Int16s(), ait)
   385  	case Int32:
   386  		return InvIterI32(a.Int32s(), ait)
   387  	case Int64:
   388  		return InvIterI64(a.Int64s(), ait)
   389  	case Uint:
   390  		return InvIterU(a.Uints(), ait)
   391  	case Uint8:
   392  		return InvIterU8(a.Uint8s(), ait)
   393  	case Uint16:
   394  		return InvIterU16(a.Uint16s(), ait)
   395  	case Uint32:
   396  		return InvIterU32(a.Uint32s(), ait)
   397  	case Uint64:
   398  		return InvIterU64(a.Uint64s(), ait)
   399  	case Float32:
   400  		return InvIterF32(a.Float32s(), ait)
   401  	case Float64:
   402  		return InvIterF64(a.Float64s(), ait)
   403  	case Complex64:
   404  		return InvIterC64(a.Complex64s(), ait)
   405  	case Complex128:
   406  		return InvIterC128(a.Complex128s(), ait)
   407  	default:
   408  		return errors.Errorf("Unsupported type %v for InvIter", t)
   409  	}
   410  }
   411  
   412  func (e E) SquareIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   413  	switch t {
   414  	case Int:
   415  		return SquareIterI(a.Ints(), ait)
   416  	case Int8:
   417  		return SquareIterI8(a.Int8s(), ait)
   418  	case Int16:
   419  		return SquareIterI16(a.Int16s(), ait)
   420  	case Int32:
   421  		return SquareIterI32(a.Int32s(), ait)
   422  	case Int64:
   423  		return SquareIterI64(a.Int64s(), ait)
   424  	case Uint:
   425  		return SquareIterU(a.Uints(), ait)
   426  	case Uint8:
   427  		return SquareIterU8(a.Uint8s(), ait)
   428  	case Uint16:
   429  		return SquareIterU16(a.Uint16s(), ait)
   430  	case Uint32:
   431  		return SquareIterU32(a.Uint32s(), ait)
   432  	case Uint64:
   433  		return SquareIterU64(a.Uint64s(), ait)
   434  	case Float32:
   435  		return SquareIterF32(a.Float32s(), ait)
   436  	case Float64:
   437  		return SquareIterF64(a.Float64s(), ait)
   438  	case Complex64:
   439  		return SquareIterC64(a.Complex64s(), ait)
   440  	case Complex128:
   441  		return SquareIterC128(a.Complex128s(), ait)
   442  	default:
   443  		return errors.Errorf("Unsupported type %v for SquareIter", t)
   444  	}
   445  }
   446  
   447  func (e E) CubeIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   448  	switch t {
   449  	case Int:
   450  		return CubeIterI(a.Ints(), ait)
   451  	case Int8:
   452  		return CubeIterI8(a.Int8s(), ait)
   453  	case Int16:
   454  		return CubeIterI16(a.Int16s(), ait)
   455  	case Int32:
   456  		return CubeIterI32(a.Int32s(), ait)
   457  	case Int64:
   458  		return CubeIterI64(a.Int64s(), ait)
   459  	case Uint:
   460  		return CubeIterU(a.Uints(), ait)
   461  	case Uint8:
   462  		return CubeIterU8(a.Uint8s(), ait)
   463  	case Uint16:
   464  		return CubeIterU16(a.Uint16s(), ait)
   465  	case Uint32:
   466  		return CubeIterU32(a.Uint32s(), ait)
   467  	case Uint64:
   468  		return CubeIterU64(a.Uint64s(), ait)
   469  	case Float32:
   470  		return CubeIterF32(a.Float32s(), ait)
   471  	case Float64:
   472  		return CubeIterF64(a.Float64s(), ait)
   473  	case Complex64:
   474  		return CubeIterC64(a.Complex64s(), ait)
   475  	case Complex128:
   476  		return CubeIterC128(a.Complex128s(), ait)
   477  	default:
   478  		return errors.Errorf("Unsupported type %v for CubeIter", t)
   479  	}
   480  }
   481  
   482  func (e E) ExpIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   483  	switch t {
   484  	case Float32:
   485  		return ExpIterF32(a.Float32s(), ait)
   486  	case Float64:
   487  		return ExpIterF64(a.Float64s(), ait)
   488  	case Complex64:
   489  		return ExpIterC64(a.Complex64s(), ait)
   490  	case Complex128:
   491  		return ExpIterC128(a.Complex128s(), ait)
   492  	default:
   493  		return errors.Errorf("Unsupported type %v for ExpIter", t)
   494  	}
   495  }
   496  
   497  func (e E) TanhIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   498  	switch t {
   499  	case Float32:
   500  		return TanhIterF32(a.Float32s(), ait)
   501  	case Float64:
   502  		return TanhIterF64(a.Float64s(), ait)
   503  	case Complex64:
   504  		return TanhIterC64(a.Complex64s(), ait)
   505  	case Complex128:
   506  		return TanhIterC128(a.Complex128s(), ait)
   507  	default:
   508  		return errors.Errorf("Unsupported type %v for TanhIter", t)
   509  	}
   510  }
   511  
   512  func (e E) LogIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   513  	switch t {
   514  	case Float32:
   515  		return LogIterF32(a.Float32s(), ait)
   516  	case Float64:
   517  		return LogIterF64(a.Float64s(), ait)
   518  	case Complex64:
   519  		return LogIterC64(a.Complex64s(), ait)
   520  	case Complex128:
   521  		return LogIterC128(a.Complex128s(), ait)
   522  	default:
   523  		return errors.Errorf("Unsupported type %v for LogIter", t)
   524  	}
   525  }
   526  
   527  func (e E) Log2Iter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   528  	switch t {
   529  	case Float32:
   530  		return Log2IterF32(a.Float32s(), ait)
   531  	case Float64:
   532  		return Log2IterF64(a.Float64s(), ait)
   533  	default:
   534  		return errors.Errorf("Unsupported type %v for Log2Iter", t)
   535  	}
   536  }
   537  
   538  func (e E) Log10Iter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   539  	switch t {
   540  	case Float32:
   541  		return Log10IterF32(a.Float32s(), ait)
   542  	case Float64:
   543  		return Log10IterF64(a.Float64s(), ait)
   544  	case Complex64:
   545  		return Log10IterC64(a.Complex64s(), ait)
   546  	case Complex128:
   547  		return Log10IterC128(a.Complex128s(), ait)
   548  	default:
   549  		return errors.Errorf("Unsupported type %v for Log10Iter", t)
   550  	}
   551  }
   552  
   553  func (e E) SqrtIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   554  	switch t {
   555  	case Float32:
   556  		return SqrtIterF32(a.Float32s(), ait)
   557  	case Float64:
   558  		return SqrtIterF64(a.Float64s(), ait)
   559  	case Complex64:
   560  		return SqrtIterC64(a.Complex64s(), ait)
   561  	case Complex128:
   562  		return SqrtIterC128(a.Complex128s(), ait)
   563  	default:
   564  		return errors.Errorf("Unsupported type %v for SqrtIter", t)
   565  	}
   566  }
   567  
   568  func (e E) CbrtIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   569  	switch t {
   570  	case Float32:
   571  		return CbrtIterF32(a.Float32s(), ait)
   572  	case Float64:
   573  		return CbrtIterF64(a.Float64s(), ait)
   574  	default:
   575  		return errors.Errorf("Unsupported type %v for CbrtIter", t)
   576  	}
   577  }
   578  
   579  func (e E) InvSqrtIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   580  	switch t {
   581  	case Float32:
   582  		return InvSqrtIterF32(a.Float32s(), ait)
   583  	case Float64:
   584  		return InvSqrtIterF64(a.Float64s(), ait)
   585  	default:
   586  		return errors.Errorf("Unsupported type %v for InvSqrtIter", t)
   587  	}
   588  }
   589  
   590  func (e E) Abs(t reflect.Type, a *storage.Header) (err error) {
   591  	switch t {
   592  	case Int:
   593  		AbsI(a.Ints())
   594  		return nil
   595  	case Int8:
   596  		AbsI8(a.Int8s())
   597  		return nil
   598  	case Int16:
   599  		AbsI16(a.Int16s())
   600  		return nil
   601  	case Int32:
   602  		AbsI32(a.Int32s())
   603  		return nil
   604  	case Int64:
   605  		AbsI64(a.Int64s())
   606  		return nil
   607  	case Float32:
   608  		AbsF32(a.Float32s())
   609  		return nil
   610  	case Float64:
   611  		AbsF64(a.Float64s())
   612  		return nil
   613  	default:
   614  		return errors.Errorf("Unsupported type %v for Abs", t)
   615  	}
   616  }
   617  
   618  func (e E) Sign(t reflect.Type, a *storage.Header) (err error) {
   619  	switch t {
   620  	case Int:
   621  		SignI(a.Ints())
   622  		return nil
   623  	case Int8:
   624  		SignI8(a.Int8s())
   625  		return nil
   626  	case Int16:
   627  		SignI16(a.Int16s())
   628  		return nil
   629  	case Int32:
   630  		SignI32(a.Int32s())
   631  		return nil
   632  	case Int64:
   633  		SignI64(a.Int64s())
   634  		return nil
   635  	case Float32:
   636  		SignF32(a.Float32s())
   637  		return nil
   638  	case Float64:
   639  		SignF64(a.Float64s())
   640  		return nil
   641  	default:
   642  		return errors.Errorf("Unsupported type %v for Sign", t)
   643  	}
   644  }
   645  
   646  func (e E) AbsIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   647  	switch t {
   648  	case Int:
   649  		return AbsIterI(a.Ints(), ait)
   650  	case Int8:
   651  		return AbsIterI8(a.Int8s(), ait)
   652  	case Int16:
   653  		return AbsIterI16(a.Int16s(), ait)
   654  	case Int32:
   655  		return AbsIterI32(a.Int32s(), ait)
   656  	case Int64:
   657  		return AbsIterI64(a.Int64s(), ait)
   658  	case Float32:
   659  		return AbsIterF32(a.Float32s(), ait)
   660  	case Float64:
   661  		return AbsIterF64(a.Float64s(), ait)
   662  	default:
   663  		return errors.Errorf("Unsupported type %v for AbsIter", t)
   664  	}
   665  }
   666  
   667  func (e E) SignIter(t reflect.Type, a *storage.Header, ait Iterator) (err error) {
   668  	switch t {
   669  	case Int:
   670  		return SignIterI(a.Ints(), ait)
   671  	case Int8:
   672  		return SignIterI8(a.Int8s(), ait)
   673  	case Int16:
   674  		return SignIterI16(a.Int16s(), ait)
   675  	case Int32:
   676  		return SignIterI32(a.Int32s(), ait)
   677  	case Int64:
   678  		return SignIterI64(a.Int64s(), ait)
   679  	case Float32:
   680  		return SignIterF32(a.Float32s(), ait)
   681  	case Float64:
   682  		return SignIterF64(a.Float64s(), ait)
   683  	default:
   684  		return errors.Errorf("Unsupported type %v for SignIter", t)
   685  	}
   686  }
   687  
   688  func (e E) Clamp(t reflect.Type, a *storage.Header, minVal interface{}, maxVal interface{}) (err error) {
   689  	var ok bool
   690  	switch t {
   691  	case Int:
   692  		var min, max int
   693  		if min, ok = minVal.(int); !ok {
   694  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   695  		}
   696  		if max, ok = maxVal.(int); !ok {
   697  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   698  		}
   699  		ClampI(a.Ints(), min, max)
   700  		return nil
   701  	case Int8:
   702  		var min, max int8
   703  		if min, ok = minVal.(int8); !ok {
   704  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   705  		}
   706  		if max, ok = maxVal.(int8); !ok {
   707  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   708  		}
   709  		ClampI8(a.Int8s(), min, max)
   710  		return nil
   711  	case Int16:
   712  		var min, max int16
   713  		if min, ok = minVal.(int16); !ok {
   714  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   715  		}
   716  		if max, ok = maxVal.(int16); !ok {
   717  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   718  		}
   719  		ClampI16(a.Int16s(), min, max)
   720  		return nil
   721  	case Int32:
   722  		var min, max int32
   723  		if min, ok = minVal.(int32); !ok {
   724  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   725  		}
   726  		if max, ok = maxVal.(int32); !ok {
   727  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   728  		}
   729  		ClampI32(a.Int32s(), min, max)
   730  		return nil
   731  	case Int64:
   732  		var min, max int64
   733  		if min, ok = minVal.(int64); !ok {
   734  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   735  		}
   736  		if max, ok = maxVal.(int64); !ok {
   737  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   738  		}
   739  		ClampI64(a.Int64s(), min, max)
   740  		return nil
   741  	case Uint:
   742  		var min, max uint
   743  		if min, ok = minVal.(uint); !ok {
   744  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   745  		}
   746  		if max, ok = maxVal.(uint); !ok {
   747  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   748  		}
   749  		ClampU(a.Uints(), min, max)
   750  		return nil
   751  	case Uint8:
   752  		var min, max uint8
   753  		if min, ok = minVal.(uint8); !ok {
   754  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   755  		}
   756  		if max, ok = maxVal.(uint8); !ok {
   757  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   758  		}
   759  		ClampU8(a.Uint8s(), min, max)
   760  		return nil
   761  	case Uint16:
   762  		var min, max uint16
   763  		if min, ok = minVal.(uint16); !ok {
   764  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   765  		}
   766  		if max, ok = maxVal.(uint16); !ok {
   767  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   768  		}
   769  		ClampU16(a.Uint16s(), min, max)
   770  		return nil
   771  	case Uint32:
   772  		var min, max uint32
   773  		if min, ok = minVal.(uint32); !ok {
   774  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   775  		}
   776  		if max, ok = maxVal.(uint32); !ok {
   777  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   778  		}
   779  		ClampU32(a.Uint32s(), min, max)
   780  		return nil
   781  	case Uint64:
   782  		var min, max uint64
   783  		if min, ok = minVal.(uint64); !ok {
   784  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   785  		}
   786  		if max, ok = maxVal.(uint64); !ok {
   787  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   788  		}
   789  		ClampU64(a.Uint64s(), min, max)
   790  		return nil
   791  	case Float32:
   792  		var min, max float32
   793  		if min, ok = minVal.(float32); !ok {
   794  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   795  		}
   796  		if max, ok = maxVal.(float32); !ok {
   797  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   798  		}
   799  		ClampF32(a.Float32s(), min, max)
   800  		return nil
   801  	case Float64:
   802  		var min, max float64
   803  		if min, ok = minVal.(float64); !ok {
   804  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   805  		}
   806  		if max, ok = maxVal.(float64); !ok {
   807  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   808  		}
   809  		ClampF64(a.Float64s(), min, max)
   810  		return nil
   811  	default:
   812  		return errors.Errorf("Unsupported type %v for Clamp", t)
   813  	}
   814  }
   815  
   816  func (e E) ClampIter(t reflect.Type, a *storage.Header, ait Iterator, minVal interface{}, maxVal interface{}) (err error) {
   817  	var ok bool
   818  	switch t {
   819  	case Int:
   820  		var min, max int
   821  		if min, ok = minVal.(int); !ok {
   822  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   823  		}
   824  		if max, ok = maxVal.(int); !ok {
   825  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   826  		}
   827  		return ClampIterI(a.Ints(), ait, min, max)
   828  	case Int8:
   829  		var min, max int8
   830  		if min, ok = minVal.(int8); !ok {
   831  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   832  		}
   833  		if max, ok = maxVal.(int8); !ok {
   834  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   835  		}
   836  		return ClampIterI8(a.Int8s(), ait, min, max)
   837  	case Int16:
   838  		var min, max int16
   839  		if min, ok = minVal.(int16); !ok {
   840  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   841  		}
   842  		if max, ok = maxVal.(int16); !ok {
   843  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   844  		}
   845  		return ClampIterI16(a.Int16s(), ait, min, max)
   846  	case Int32:
   847  		var min, max int32
   848  		if min, ok = minVal.(int32); !ok {
   849  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   850  		}
   851  		if max, ok = maxVal.(int32); !ok {
   852  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   853  		}
   854  		return ClampIterI32(a.Int32s(), ait, min, max)
   855  	case Int64:
   856  		var min, max int64
   857  		if min, ok = minVal.(int64); !ok {
   858  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   859  		}
   860  		if max, ok = maxVal.(int64); !ok {
   861  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   862  		}
   863  		return ClampIterI64(a.Int64s(), ait, min, max)
   864  	case Uint:
   865  		var min, max uint
   866  		if min, ok = minVal.(uint); !ok {
   867  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   868  		}
   869  		if max, ok = maxVal.(uint); !ok {
   870  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   871  		}
   872  		return ClampIterU(a.Uints(), ait, min, max)
   873  	case Uint8:
   874  		var min, max uint8
   875  		if min, ok = minVal.(uint8); !ok {
   876  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   877  		}
   878  		if max, ok = maxVal.(uint8); !ok {
   879  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   880  		}
   881  		return ClampIterU8(a.Uint8s(), ait, min, max)
   882  	case Uint16:
   883  		var min, max uint16
   884  		if min, ok = minVal.(uint16); !ok {
   885  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   886  		}
   887  		if max, ok = maxVal.(uint16); !ok {
   888  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   889  		}
   890  		return ClampIterU16(a.Uint16s(), ait, min, max)
   891  	case Uint32:
   892  		var min, max uint32
   893  		if min, ok = minVal.(uint32); !ok {
   894  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   895  		}
   896  		if max, ok = maxVal.(uint32); !ok {
   897  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   898  		}
   899  		return ClampIterU32(a.Uint32s(), ait, min, max)
   900  	case Uint64:
   901  		var min, max uint64
   902  		if min, ok = minVal.(uint64); !ok {
   903  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   904  		}
   905  		if max, ok = maxVal.(uint64); !ok {
   906  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   907  		}
   908  		return ClampIterU64(a.Uint64s(), ait, min, max)
   909  	case Float32:
   910  		var min, max float32
   911  		if min, ok = minVal.(float32); !ok {
   912  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   913  		}
   914  		if max, ok = maxVal.(float32); !ok {
   915  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   916  		}
   917  		return ClampIterF32(a.Float32s(), ait, min, max)
   918  	case Float64:
   919  		var min, max float64
   920  		if min, ok = minVal.(float64); !ok {
   921  			return errors.Wrap(errors.Errorf(typeMismatch, min, minVal), "Clamp() min")
   922  		}
   923  		if max, ok = maxVal.(float64); !ok {
   924  			return errors.Wrap(errors.Errorf(typeMismatch, max, maxVal), "Clamp() max")
   925  		}
   926  		return ClampIterF64(a.Float64s(), ait, min, max)
   927  	default:
   928  		return errors.Errorf("Unsupported type %v for Clamp", t)
   929  	}
   930  }