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

     1  // Code generated by genlib2. DO NOT EDIT.
     2  
     3  package tensor
     4  
     5  import (
     6  	"github.com/pkg/errors"
     7  	"github.com/wzzhu/tensor/internal/storage"
     8  )
     9  
    10  func (e StdEng) Neg(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
    11  	if err = unaryCheck(a, numberTypes); err != nil {
    12  		err = errors.Wrapf(err, "Neg failed")
    13  		return
    14  	}
    15  	var reuse DenseTensor
    16  	var safe, toReuse, incr bool
    17  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
    18  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
    19  	}
    20  
    21  	typ := a.Dtype().Type
    22  	var ait, rit Iterator
    23  	var dataA, dataReuse *storage.Header
    24  	var useIter bool
    25  
    26  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
    27  		return nil, errors.Wrapf(err, opFail, "StdEng.Neg")
    28  	}
    29  
    30  	if useIter {
    31  		switch {
    32  		case incr:
    33  			cloned := a.Clone().(Tensor)
    34  			if err = e.E.NegIter(typ, cloned.hdr(), ait); err != nil {
    35  				return nil, errors.Wrap(err, "Unable to perform Neg")
    36  			}
    37  			ait.Reset()
    38  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
    39  			retVal = reuse
    40  		case toReuse:
    41  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
    42  			rit.Reset()
    43  			err = e.E.NegIter(typ, dataReuse, rit)
    44  			retVal = reuse
    45  		case !safe:
    46  			err = e.E.NegIter(typ, dataA, ait)
    47  			retVal = a
    48  		default: // safe by default
    49  			cloned := a.Clone().(Tensor)
    50  			err = e.E.NegIter(typ, cloned.hdr(), ait)
    51  			retVal = cloned
    52  		}
    53  		return
    54  	}
    55  	switch {
    56  	case incr:
    57  		cloned := a.Clone().(Tensor)
    58  		if err = e.E.Neg(typ, cloned.hdr()); err != nil {
    59  			return nil, errors.Wrap(err, "Unable to perform Neg")
    60  		}
    61  		err = e.E.Add(typ, dataReuse, cloned.hdr())
    62  		retVal = reuse
    63  	case toReuse:
    64  		storage.Copy(typ, dataReuse, dataA)
    65  		err = e.E.Neg(typ, dataReuse)
    66  		retVal = reuse
    67  	case !safe:
    68  		err = e.E.Neg(typ, dataA)
    69  		retVal = a
    70  	default: // safe by default
    71  		cloned := a.Clone().(Tensor)
    72  		err = e.E.Neg(typ, cloned.hdr())
    73  		retVal = cloned
    74  	}
    75  	return
    76  
    77  }
    78  func (e StdEng) Inv(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
    79  	if err = unaryCheck(a, numberTypes); err != nil {
    80  		err = errors.Wrapf(err, "Inv failed")
    81  		return
    82  	}
    83  	var reuse DenseTensor
    84  	var safe, toReuse, incr bool
    85  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
    86  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
    87  	}
    88  
    89  	typ := a.Dtype().Type
    90  	var ait, rit Iterator
    91  	var dataA, dataReuse *storage.Header
    92  	var useIter bool
    93  
    94  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
    95  		return nil, errors.Wrapf(err, opFail, "StdEng.Inv")
    96  	}
    97  
    98  	if useIter {
    99  		switch {
   100  		case incr:
   101  			cloned := a.Clone().(Tensor)
   102  			if err = e.E.InvIter(typ, cloned.hdr(), ait); err != nil {
   103  				return nil, errors.Wrap(err, "Unable to perform Inv")
   104  			}
   105  			ait.Reset()
   106  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   107  			retVal = reuse
   108  		case toReuse:
   109  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   110  			rit.Reset()
   111  			err = e.E.InvIter(typ, dataReuse, rit)
   112  			retVal = reuse
   113  		case !safe:
   114  			err = e.E.InvIter(typ, dataA, ait)
   115  			retVal = a
   116  		default: // safe by default
   117  			cloned := a.Clone().(Tensor)
   118  			err = e.E.InvIter(typ, cloned.hdr(), ait)
   119  			retVal = cloned
   120  		}
   121  		return
   122  	}
   123  	switch {
   124  	case incr:
   125  		cloned := a.Clone().(Tensor)
   126  		if err = e.E.Inv(typ, cloned.hdr()); err != nil {
   127  			return nil, errors.Wrap(err, "Unable to perform Inv")
   128  		}
   129  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   130  		retVal = reuse
   131  	case toReuse:
   132  		storage.Copy(typ, dataReuse, dataA)
   133  		err = e.E.Inv(typ, dataReuse)
   134  		retVal = reuse
   135  	case !safe:
   136  		err = e.E.Inv(typ, dataA)
   137  		retVal = a
   138  	default: // safe by default
   139  		cloned := a.Clone().(Tensor)
   140  		err = e.E.Inv(typ, cloned.hdr())
   141  		retVal = cloned
   142  	}
   143  	return
   144  
   145  }
   146  func (e StdEng) Square(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   147  	if err = unaryCheck(a, numberTypes); err != nil {
   148  		err = errors.Wrapf(err, "Square failed")
   149  		return
   150  	}
   151  	var reuse DenseTensor
   152  	var safe, toReuse, incr bool
   153  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   154  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   155  	}
   156  
   157  	typ := a.Dtype().Type
   158  	var ait, rit Iterator
   159  	var dataA, dataReuse *storage.Header
   160  	var useIter bool
   161  
   162  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   163  		return nil, errors.Wrapf(err, opFail, "StdEng.Square")
   164  	}
   165  
   166  	if useIter {
   167  		switch {
   168  		case incr:
   169  			cloned := a.Clone().(Tensor)
   170  			if err = e.E.SquareIter(typ, cloned.hdr(), ait); err != nil {
   171  				return nil, errors.Wrap(err, "Unable to perform Square")
   172  			}
   173  			ait.Reset()
   174  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   175  			retVal = reuse
   176  		case toReuse:
   177  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   178  			rit.Reset()
   179  			err = e.E.SquareIter(typ, dataReuse, rit)
   180  			retVal = reuse
   181  		case !safe:
   182  			err = e.E.SquareIter(typ, dataA, ait)
   183  			retVal = a
   184  		default: // safe by default
   185  			cloned := a.Clone().(Tensor)
   186  			err = e.E.SquareIter(typ, cloned.hdr(), ait)
   187  			retVal = cloned
   188  		}
   189  		return
   190  	}
   191  	switch {
   192  	case incr:
   193  		cloned := a.Clone().(Tensor)
   194  		if err = e.E.Square(typ, cloned.hdr()); err != nil {
   195  			return nil, errors.Wrap(err, "Unable to perform Square")
   196  		}
   197  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   198  		retVal = reuse
   199  	case toReuse:
   200  		storage.Copy(typ, dataReuse, dataA)
   201  		err = e.E.Square(typ, dataReuse)
   202  		retVal = reuse
   203  	case !safe:
   204  		err = e.E.Square(typ, dataA)
   205  		retVal = a
   206  	default: // safe by default
   207  		cloned := a.Clone().(Tensor)
   208  		err = e.E.Square(typ, cloned.hdr())
   209  		retVal = cloned
   210  	}
   211  	return
   212  
   213  }
   214  func (e StdEng) Cube(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   215  	if err = unaryCheck(a, numberTypes); err != nil {
   216  		err = errors.Wrapf(err, "Cube failed")
   217  		return
   218  	}
   219  	var reuse DenseTensor
   220  	var safe, toReuse, incr bool
   221  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   222  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   223  	}
   224  
   225  	typ := a.Dtype().Type
   226  	var ait, rit Iterator
   227  	var dataA, dataReuse *storage.Header
   228  	var useIter bool
   229  
   230  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   231  		return nil, errors.Wrapf(err, opFail, "StdEng.Cube")
   232  	}
   233  
   234  	if useIter {
   235  		switch {
   236  		case incr:
   237  			cloned := a.Clone().(Tensor)
   238  			if err = e.E.CubeIter(typ, cloned.hdr(), ait); err != nil {
   239  				return nil, errors.Wrap(err, "Unable to perform Cube")
   240  			}
   241  			ait.Reset()
   242  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   243  			retVal = reuse
   244  		case toReuse:
   245  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   246  			rit.Reset()
   247  			err = e.E.CubeIter(typ, dataReuse, rit)
   248  			retVal = reuse
   249  		case !safe:
   250  			err = e.E.CubeIter(typ, dataA, ait)
   251  			retVal = a
   252  		default: // safe by default
   253  			cloned := a.Clone().(Tensor)
   254  			err = e.E.CubeIter(typ, cloned.hdr(), ait)
   255  			retVal = cloned
   256  		}
   257  		return
   258  	}
   259  	switch {
   260  	case incr:
   261  		cloned := a.Clone().(Tensor)
   262  		if err = e.E.Cube(typ, cloned.hdr()); err != nil {
   263  			return nil, errors.Wrap(err, "Unable to perform Cube")
   264  		}
   265  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   266  		retVal = reuse
   267  	case toReuse:
   268  		storage.Copy(typ, dataReuse, dataA)
   269  		err = e.E.Cube(typ, dataReuse)
   270  		retVal = reuse
   271  	case !safe:
   272  		err = e.E.Cube(typ, dataA)
   273  		retVal = a
   274  	default: // safe by default
   275  		cloned := a.Clone().(Tensor)
   276  		err = e.E.Cube(typ, cloned.hdr())
   277  		retVal = cloned
   278  	}
   279  	return
   280  
   281  }
   282  func (e StdEng) Exp(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   283  	if err = unaryCheck(a, floatcmplxTypes); err != nil {
   284  		err = errors.Wrapf(err, "Exp failed")
   285  		return
   286  	}
   287  	var reuse DenseTensor
   288  	var safe, toReuse, incr bool
   289  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   290  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   291  	}
   292  
   293  	typ := a.Dtype().Type
   294  	var ait, rit Iterator
   295  	var dataA, dataReuse *storage.Header
   296  	var useIter bool
   297  
   298  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   299  		return nil, errors.Wrapf(err, opFail, "StdEng.Exp")
   300  	}
   301  
   302  	if useIter {
   303  		switch {
   304  		case incr:
   305  			cloned := a.Clone().(Tensor)
   306  			if err = e.E.ExpIter(typ, cloned.hdr(), ait); err != nil {
   307  				return nil, errors.Wrap(err, "Unable to perform Exp")
   308  			}
   309  			ait.Reset()
   310  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   311  			retVal = reuse
   312  		case toReuse:
   313  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   314  			rit.Reset()
   315  			err = e.E.ExpIter(typ, dataReuse, rit)
   316  			retVal = reuse
   317  		case !safe:
   318  			err = e.E.ExpIter(typ, dataA, ait)
   319  			retVal = a
   320  		default: // safe by default
   321  			cloned := a.Clone().(Tensor)
   322  			err = e.E.ExpIter(typ, cloned.hdr(), ait)
   323  			retVal = cloned
   324  		}
   325  		return
   326  	}
   327  	switch {
   328  	case incr:
   329  		cloned := a.Clone().(Tensor)
   330  		if err = e.E.Exp(typ, cloned.hdr()); err != nil {
   331  			return nil, errors.Wrap(err, "Unable to perform Exp")
   332  		}
   333  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   334  		retVal = reuse
   335  	case toReuse:
   336  		storage.Copy(typ, dataReuse, dataA)
   337  		err = e.E.Exp(typ, dataReuse)
   338  		retVal = reuse
   339  	case !safe:
   340  		err = e.E.Exp(typ, dataA)
   341  		retVal = a
   342  	default: // safe by default
   343  		cloned := a.Clone().(Tensor)
   344  		err = e.E.Exp(typ, cloned.hdr())
   345  		retVal = cloned
   346  	}
   347  	return
   348  
   349  }
   350  func (e StdEng) Tanh(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   351  	if err = unaryCheck(a, floatcmplxTypes); err != nil {
   352  		err = errors.Wrapf(err, "Tanh failed")
   353  		return
   354  	}
   355  	var reuse DenseTensor
   356  	var safe, toReuse, incr bool
   357  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   358  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   359  	}
   360  
   361  	typ := a.Dtype().Type
   362  	var ait, rit Iterator
   363  	var dataA, dataReuse *storage.Header
   364  	var useIter bool
   365  
   366  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   367  		return nil, errors.Wrapf(err, opFail, "StdEng.Tanh")
   368  	}
   369  
   370  	if useIter {
   371  		switch {
   372  		case incr:
   373  			cloned := a.Clone().(Tensor)
   374  			if err = e.E.TanhIter(typ, cloned.hdr(), ait); err != nil {
   375  				return nil, errors.Wrap(err, "Unable to perform Tanh")
   376  			}
   377  			ait.Reset()
   378  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   379  			retVal = reuse
   380  		case toReuse:
   381  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   382  			rit.Reset()
   383  			err = e.E.TanhIter(typ, dataReuse, rit)
   384  			retVal = reuse
   385  		case !safe:
   386  			err = e.E.TanhIter(typ, dataA, ait)
   387  			retVal = a
   388  		default: // safe by default
   389  			cloned := a.Clone().(Tensor)
   390  			err = e.E.TanhIter(typ, cloned.hdr(), ait)
   391  			retVal = cloned
   392  		}
   393  		return
   394  	}
   395  	switch {
   396  	case incr:
   397  		cloned := a.Clone().(Tensor)
   398  		if err = e.E.Tanh(typ, cloned.hdr()); err != nil {
   399  			return nil, errors.Wrap(err, "Unable to perform Tanh")
   400  		}
   401  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   402  		retVal = reuse
   403  	case toReuse:
   404  		storage.Copy(typ, dataReuse, dataA)
   405  		err = e.E.Tanh(typ, dataReuse)
   406  		retVal = reuse
   407  	case !safe:
   408  		err = e.E.Tanh(typ, dataA)
   409  		retVal = a
   410  	default: // safe by default
   411  		cloned := a.Clone().(Tensor)
   412  		err = e.E.Tanh(typ, cloned.hdr())
   413  		retVal = cloned
   414  	}
   415  	return
   416  
   417  }
   418  func (e StdEng) Log(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   419  	if err = unaryCheck(a, floatcmplxTypes); err != nil {
   420  		err = errors.Wrapf(err, "Log failed")
   421  		return
   422  	}
   423  	var reuse DenseTensor
   424  	var safe, toReuse, incr bool
   425  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   426  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   427  	}
   428  
   429  	typ := a.Dtype().Type
   430  	var ait, rit Iterator
   431  	var dataA, dataReuse *storage.Header
   432  	var useIter bool
   433  
   434  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   435  		return nil, errors.Wrapf(err, opFail, "StdEng.Log")
   436  	}
   437  
   438  	if useIter {
   439  		switch {
   440  		case incr:
   441  			cloned := a.Clone().(Tensor)
   442  			if err = e.E.LogIter(typ, cloned.hdr(), ait); err != nil {
   443  				return nil, errors.Wrap(err, "Unable to perform Log")
   444  			}
   445  			ait.Reset()
   446  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   447  			retVal = reuse
   448  		case toReuse:
   449  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   450  			rit.Reset()
   451  			err = e.E.LogIter(typ, dataReuse, rit)
   452  			retVal = reuse
   453  		case !safe:
   454  			err = e.E.LogIter(typ, dataA, ait)
   455  			retVal = a
   456  		default: // safe by default
   457  			cloned := a.Clone().(Tensor)
   458  			err = e.E.LogIter(typ, cloned.hdr(), ait)
   459  			retVal = cloned
   460  		}
   461  		return
   462  	}
   463  	switch {
   464  	case incr:
   465  		cloned := a.Clone().(Tensor)
   466  		if err = e.E.Log(typ, cloned.hdr()); err != nil {
   467  			return nil, errors.Wrap(err, "Unable to perform Log")
   468  		}
   469  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   470  		retVal = reuse
   471  	case toReuse:
   472  		storage.Copy(typ, dataReuse, dataA)
   473  		err = e.E.Log(typ, dataReuse)
   474  		retVal = reuse
   475  	case !safe:
   476  		err = e.E.Log(typ, dataA)
   477  		retVal = a
   478  	default: // safe by default
   479  		cloned := a.Clone().(Tensor)
   480  		err = e.E.Log(typ, cloned.hdr())
   481  		retVal = cloned
   482  	}
   483  	return
   484  
   485  }
   486  func (e StdEng) Log2(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   487  	if err = unaryCheck(a, floatTypes); err != nil {
   488  		err = errors.Wrapf(err, "Log2 failed")
   489  		return
   490  	}
   491  	var reuse DenseTensor
   492  	var safe, toReuse, incr bool
   493  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   494  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   495  	}
   496  
   497  	typ := a.Dtype().Type
   498  	var ait, rit Iterator
   499  	var dataA, dataReuse *storage.Header
   500  	var useIter bool
   501  
   502  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   503  		return nil, errors.Wrapf(err, opFail, "StdEng.Log2")
   504  	}
   505  
   506  	if useIter {
   507  		switch {
   508  		case incr:
   509  			cloned := a.Clone().(Tensor)
   510  			if err = e.E.Log2Iter(typ, cloned.hdr(), ait); err != nil {
   511  				return nil, errors.Wrap(err, "Unable to perform Log2")
   512  			}
   513  			ait.Reset()
   514  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   515  			retVal = reuse
   516  		case toReuse:
   517  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   518  			rit.Reset()
   519  			err = e.E.Log2Iter(typ, dataReuse, rit)
   520  			retVal = reuse
   521  		case !safe:
   522  			err = e.E.Log2Iter(typ, dataA, ait)
   523  			retVal = a
   524  		default: // safe by default
   525  			cloned := a.Clone().(Tensor)
   526  			err = e.E.Log2Iter(typ, cloned.hdr(), ait)
   527  			retVal = cloned
   528  		}
   529  		return
   530  	}
   531  	switch {
   532  	case incr:
   533  		cloned := a.Clone().(Tensor)
   534  		if err = e.E.Log2(typ, cloned.hdr()); err != nil {
   535  			return nil, errors.Wrap(err, "Unable to perform Log2")
   536  		}
   537  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   538  		retVal = reuse
   539  	case toReuse:
   540  		storage.Copy(typ, dataReuse, dataA)
   541  		err = e.E.Log2(typ, dataReuse)
   542  		retVal = reuse
   543  	case !safe:
   544  		err = e.E.Log2(typ, dataA)
   545  		retVal = a
   546  	default: // safe by default
   547  		cloned := a.Clone().(Tensor)
   548  		err = e.E.Log2(typ, cloned.hdr())
   549  		retVal = cloned
   550  	}
   551  	return
   552  
   553  }
   554  func (e StdEng) Log10(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   555  	if err = unaryCheck(a, floatcmplxTypes); err != nil {
   556  		err = errors.Wrapf(err, "Log10 failed")
   557  		return
   558  	}
   559  	var reuse DenseTensor
   560  	var safe, toReuse, incr bool
   561  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   562  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   563  	}
   564  
   565  	typ := a.Dtype().Type
   566  	var ait, rit Iterator
   567  	var dataA, dataReuse *storage.Header
   568  	var useIter bool
   569  
   570  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   571  		return nil, errors.Wrapf(err, opFail, "StdEng.Log10")
   572  	}
   573  
   574  	if useIter {
   575  		switch {
   576  		case incr:
   577  			cloned := a.Clone().(Tensor)
   578  			if err = e.E.Log10Iter(typ, cloned.hdr(), ait); err != nil {
   579  				return nil, errors.Wrap(err, "Unable to perform Log10")
   580  			}
   581  			ait.Reset()
   582  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   583  			retVal = reuse
   584  		case toReuse:
   585  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   586  			rit.Reset()
   587  			err = e.E.Log10Iter(typ, dataReuse, rit)
   588  			retVal = reuse
   589  		case !safe:
   590  			err = e.E.Log10Iter(typ, dataA, ait)
   591  			retVal = a
   592  		default: // safe by default
   593  			cloned := a.Clone().(Tensor)
   594  			err = e.E.Log10Iter(typ, cloned.hdr(), ait)
   595  			retVal = cloned
   596  		}
   597  		return
   598  	}
   599  	switch {
   600  	case incr:
   601  		cloned := a.Clone().(Tensor)
   602  		if err = e.E.Log10(typ, cloned.hdr()); err != nil {
   603  			return nil, errors.Wrap(err, "Unable to perform Log10")
   604  		}
   605  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   606  		retVal = reuse
   607  	case toReuse:
   608  		storage.Copy(typ, dataReuse, dataA)
   609  		err = e.E.Log10(typ, dataReuse)
   610  		retVal = reuse
   611  	case !safe:
   612  		err = e.E.Log10(typ, dataA)
   613  		retVal = a
   614  	default: // safe by default
   615  		cloned := a.Clone().(Tensor)
   616  		err = e.E.Log10(typ, cloned.hdr())
   617  		retVal = cloned
   618  	}
   619  	return
   620  
   621  }
   622  func (e StdEng) Sqrt(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   623  	if err = unaryCheck(a, floatcmplxTypes); err != nil {
   624  		err = errors.Wrapf(err, "Sqrt failed")
   625  		return
   626  	}
   627  	var reuse DenseTensor
   628  	var safe, toReuse, incr bool
   629  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   630  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   631  	}
   632  
   633  	typ := a.Dtype().Type
   634  	var ait, rit Iterator
   635  	var dataA, dataReuse *storage.Header
   636  	var useIter bool
   637  
   638  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   639  		return nil, errors.Wrapf(err, opFail, "StdEng.Sqrt")
   640  	}
   641  
   642  	if useIter {
   643  		switch {
   644  		case incr:
   645  			cloned := a.Clone().(Tensor)
   646  			if err = e.E.SqrtIter(typ, cloned.hdr(), ait); err != nil {
   647  				return nil, errors.Wrap(err, "Unable to perform Sqrt")
   648  			}
   649  			ait.Reset()
   650  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   651  			retVal = reuse
   652  		case toReuse:
   653  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   654  			rit.Reset()
   655  			err = e.E.SqrtIter(typ, dataReuse, rit)
   656  			retVal = reuse
   657  		case !safe:
   658  			err = e.E.SqrtIter(typ, dataA, ait)
   659  			retVal = a
   660  		default: // safe by default
   661  			cloned := a.Clone().(Tensor)
   662  			err = e.E.SqrtIter(typ, cloned.hdr(), ait)
   663  			retVal = cloned
   664  		}
   665  		return
   666  	}
   667  	switch {
   668  	case incr:
   669  		cloned := a.Clone().(Tensor)
   670  		if err = e.E.Sqrt(typ, cloned.hdr()); err != nil {
   671  			return nil, errors.Wrap(err, "Unable to perform Sqrt")
   672  		}
   673  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   674  		retVal = reuse
   675  	case toReuse:
   676  		storage.Copy(typ, dataReuse, dataA)
   677  		err = e.E.Sqrt(typ, dataReuse)
   678  		retVal = reuse
   679  	case !safe:
   680  		err = e.E.Sqrt(typ, dataA)
   681  		retVal = a
   682  	default: // safe by default
   683  		cloned := a.Clone().(Tensor)
   684  		err = e.E.Sqrt(typ, cloned.hdr())
   685  		retVal = cloned
   686  	}
   687  	return
   688  
   689  }
   690  func (e StdEng) Cbrt(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   691  	if err = unaryCheck(a, floatTypes); err != nil {
   692  		err = errors.Wrapf(err, "Cbrt failed")
   693  		return
   694  	}
   695  	var reuse DenseTensor
   696  	var safe, toReuse, incr bool
   697  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   698  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   699  	}
   700  
   701  	typ := a.Dtype().Type
   702  	var ait, rit Iterator
   703  	var dataA, dataReuse *storage.Header
   704  	var useIter bool
   705  
   706  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   707  		return nil, errors.Wrapf(err, opFail, "StdEng.Cbrt")
   708  	}
   709  
   710  	if useIter {
   711  		switch {
   712  		case incr:
   713  			cloned := a.Clone().(Tensor)
   714  			if err = e.E.CbrtIter(typ, cloned.hdr(), ait); err != nil {
   715  				return nil, errors.Wrap(err, "Unable to perform Cbrt")
   716  			}
   717  			ait.Reset()
   718  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   719  			retVal = reuse
   720  		case toReuse:
   721  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   722  			rit.Reset()
   723  			err = e.E.CbrtIter(typ, dataReuse, rit)
   724  			retVal = reuse
   725  		case !safe:
   726  			err = e.E.CbrtIter(typ, dataA, ait)
   727  			retVal = a
   728  		default: // safe by default
   729  			cloned := a.Clone().(Tensor)
   730  			err = e.E.CbrtIter(typ, cloned.hdr(), ait)
   731  			retVal = cloned
   732  		}
   733  		return
   734  	}
   735  	switch {
   736  	case incr:
   737  		cloned := a.Clone().(Tensor)
   738  		if err = e.E.Cbrt(typ, cloned.hdr()); err != nil {
   739  			return nil, errors.Wrap(err, "Unable to perform Cbrt")
   740  		}
   741  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   742  		retVal = reuse
   743  	case toReuse:
   744  		storage.Copy(typ, dataReuse, dataA)
   745  		err = e.E.Cbrt(typ, dataReuse)
   746  		retVal = reuse
   747  	case !safe:
   748  		err = e.E.Cbrt(typ, dataA)
   749  		retVal = a
   750  	default: // safe by default
   751  		cloned := a.Clone().(Tensor)
   752  		err = e.E.Cbrt(typ, cloned.hdr())
   753  		retVal = cloned
   754  	}
   755  	return
   756  
   757  }
   758  func (e StdEng) InvSqrt(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   759  	if err = unaryCheck(a, floatTypes); err != nil {
   760  		err = errors.Wrapf(err, "InvSqrt failed")
   761  		return
   762  	}
   763  	var reuse DenseTensor
   764  	var safe, toReuse, incr bool
   765  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   766  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   767  	}
   768  
   769  	typ := a.Dtype().Type
   770  	var ait, rit Iterator
   771  	var dataA, dataReuse *storage.Header
   772  	var useIter bool
   773  
   774  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   775  		return nil, errors.Wrapf(err, opFail, "StdEng.InvSqrt")
   776  	}
   777  
   778  	if useIter {
   779  		switch {
   780  		case incr:
   781  			cloned := a.Clone().(Tensor)
   782  			if err = e.E.InvSqrtIter(typ, cloned.hdr(), ait); err != nil {
   783  				return nil, errors.Wrap(err, "Unable to perform InvSqrt")
   784  			}
   785  			ait.Reset()
   786  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   787  			retVal = reuse
   788  		case toReuse:
   789  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   790  			rit.Reset()
   791  			err = e.E.InvSqrtIter(typ, dataReuse, rit)
   792  			retVal = reuse
   793  		case !safe:
   794  			err = e.E.InvSqrtIter(typ, dataA, ait)
   795  			retVal = a
   796  		default: // safe by default
   797  			cloned := a.Clone().(Tensor)
   798  			err = e.E.InvSqrtIter(typ, cloned.hdr(), ait)
   799  			retVal = cloned
   800  		}
   801  		return
   802  	}
   803  	switch {
   804  	case incr:
   805  		cloned := a.Clone().(Tensor)
   806  		if err = e.E.InvSqrt(typ, cloned.hdr()); err != nil {
   807  			return nil, errors.Wrap(err, "Unable to perform InvSqrt")
   808  		}
   809  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   810  		retVal = reuse
   811  	case toReuse:
   812  		storage.Copy(typ, dataReuse, dataA)
   813  		err = e.E.InvSqrt(typ, dataReuse)
   814  		retVal = reuse
   815  	case !safe:
   816  		err = e.E.InvSqrt(typ, dataA)
   817  		retVal = a
   818  	default: // safe by default
   819  		cloned := a.Clone().(Tensor)
   820  		err = e.E.InvSqrt(typ, cloned.hdr())
   821  		retVal = cloned
   822  	}
   823  	return
   824  
   825  }
   826  func (e StdEng) Abs(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   827  	if err = unaryCheck(a, signedTypes); err != nil {
   828  		err = errors.Wrapf(err, "Abs failed")
   829  		return
   830  	}
   831  	var reuse DenseTensor
   832  	var safe, toReuse, incr bool
   833  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   834  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   835  	}
   836  
   837  	typ := a.Dtype().Type
   838  	var ait, rit Iterator
   839  	var dataA, dataReuse *storage.Header
   840  	var useIter bool
   841  
   842  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   843  		return nil, errors.Wrapf(err, opFail, "StdEng.Abs")
   844  	}
   845  
   846  	if useIter {
   847  		switch {
   848  		case incr:
   849  			cloned := a.Clone().(Tensor)
   850  			if err = e.E.AbsIter(typ, cloned.hdr(), ait); err != nil {
   851  				return nil, errors.Wrap(err, "Unable to perform Abs")
   852  			}
   853  			ait.Reset()
   854  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   855  			retVal = reuse
   856  		case toReuse:
   857  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   858  			rit.Reset()
   859  			err = e.E.AbsIter(typ, dataReuse, rit)
   860  			retVal = reuse
   861  		case !safe:
   862  			err = e.E.AbsIter(typ, dataA, ait)
   863  			retVal = a
   864  		default: // safe by default
   865  			cloned := a.Clone().(Tensor)
   866  			err = e.E.AbsIter(typ, cloned.hdr(), ait)
   867  			retVal = cloned
   868  		}
   869  		return
   870  	}
   871  	switch {
   872  	case incr:
   873  		cloned := a.Clone().(Tensor)
   874  		if err = e.E.Abs(typ, cloned.hdr()); err != nil {
   875  			return nil, errors.Wrap(err, "Unable to perform Abs")
   876  		}
   877  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   878  		retVal = reuse
   879  	case toReuse:
   880  		storage.Copy(typ, dataReuse, dataA)
   881  		err = e.E.Abs(typ, dataReuse)
   882  		retVal = reuse
   883  	case !safe:
   884  		err = e.E.Abs(typ, dataA)
   885  		retVal = a
   886  	default: // safe by default
   887  		cloned := a.Clone().(Tensor)
   888  		err = e.E.Abs(typ, cloned.hdr())
   889  		retVal = cloned
   890  	}
   891  	return
   892  
   893  }
   894  func (e StdEng) Sign(a Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
   895  	if err = unaryCheck(a, signedTypes); err != nil {
   896  		err = errors.Wrapf(err, "Sign failed")
   897  		return
   898  	}
   899  	var reuse DenseTensor
   900  	var safe, toReuse, incr bool
   901  	if reuse, safe, toReuse, incr, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
   902  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   903  	}
   904  
   905  	typ := a.Dtype().Type
   906  	var ait, rit Iterator
   907  	var dataA, dataReuse *storage.Header
   908  	var useIter bool
   909  
   910  	if dataA, dataReuse, ait, rit, useIter, err = prepDataUnary(a, reuse); err != nil {
   911  		return nil, errors.Wrapf(err, opFail, "StdEng.Sign")
   912  	}
   913  
   914  	if useIter {
   915  		switch {
   916  		case incr:
   917  			cloned := a.Clone().(Tensor)
   918  			if err = e.E.SignIter(typ, cloned.hdr(), ait); err != nil {
   919  				return nil, errors.Wrap(err, "Unable to perform Sign")
   920  			}
   921  			ait.Reset()
   922  			err = e.E.AddIter(typ, dataReuse, cloned.hdr(), rit, ait)
   923  			retVal = reuse
   924  		case toReuse:
   925  			storage.CopyIter(typ, dataReuse, dataA, rit, ait)
   926  			rit.Reset()
   927  			err = e.E.SignIter(typ, dataReuse, rit)
   928  			retVal = reuse
   929  		case !safe:
   930  			err = e.E.SignIter(typ, dataA, ait)
   931  			retVal = a
   932  		default: // safe by default
   933  			cloned := a.Clone().(Tensor)
   934  			err = e.E.SignIter(typ, cloned.hdr(), ait)
   935  			retVal = cloned
   936  		}
   937  		return
   938  	}
   939  	switch {
   940  	case incr:
   941  		cloned := a.Clone().(Tensor)
   942  		if err = e.E.Sign(typ, cloned.hdr()); err != nil {
   943  			return nil, errors.Wrap(err, "Unable to perform Sign")
   944  		}
   945  		err = e.E.Add(typ, dataReuse, cloned.hdr())
   946  		retVal = reuse
   947  	case toReuse:
   948  		storage.Copy(typ, dataReuse, dataA)
   949  		err = e.E.Sign(typ, dataReuse)
   950  		retVal = reuse
   951  	case !safe:
   952  		err = e.E.Sign(typ, dataA)
   953  		retVal = a
   954  	default: // safe by default
   955  		cloned := a.Clone().(Tensor)
   956  		err = e.E.Sign(typ, cloned.hdr())
   957  		retVal = cloned
   958  	}
   959  	return
   960  
   961  }