gorgonia.org/tensor@v0.9.24/defaultengine_minmax.go (about)

     1  // Code generated by genlib2. DO NOT EDIT.
     2  
     3  package tensor
     4  
     5  import (
     6  	"github.com/pkg/errors"
     7  	"gorgonia.org/tensor/internal/storage"
     8  )
     9  
    10  var (
    11  	_ MinBetweener = StdEng{}
    12  	_ MaxBetweener = StdEng{}
    13  )
    14  
    15  func (e StdEng) MinBetween(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
    16  	if err = binaryCheck(a, b, ordTypes); err != nil {
    17  		return nil, errors.Wrapf(err, "MinBetween failed")
    18  	}
    19  
    20  	var reuse DenseTensor
    21  	var safe bool
    22  	if reuse, safe, _, _, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
    23  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
    24  	}
    25  	typ := a.Dtype().Type
    26  	var dataA, dataB, dataReuse *storage.Header
    27  	var ait, bit, iit Iterator
    28  	var useIter, swap bool
    29  	if dataA, dataB, dataReuse, ait, bit, iit, useIter, swap, err = prepDataVV(a, b, reuse); err != nil {
    30  		return nil, errors.Wrapf(err, "StdEng.MinBetween")
    31  	}
    32  	// check to see if anything needs to be created
    33  	if reuse == nil {
    34  		if swap {
    35  			reuse = NewDense(b.Dtype(), b.Shape().Clone(), WithEngine(e))
    36  		} else {
    37  			reuse = NewDense(a.Dtype(), a.Shape().Clone(), WithEngine(e))
    38  		}
    39  		dataReuse = reuse.hdr()
    40  		if useIter {
    41  			iit = IteratorFromDense(reuse)
    42  		}
    43  	}
    44  
    45  	if useIter {
    46  		switch {
    47  		case !safe && reuse == nil:
    48  			err = e.E.MinBetweenIter(typ, dataA, dataB, ait, bit)
    49  			retVal = a
    50  		case safe && reuse != nil:
    51  			storage.CopyIter(typ, dataReuse, dataA, iit, ait)
    52  			ait.Reset()
    53  			iit.Reset()
    54  			err = e.E.MinBetweenIter(typ, dataReuse, dataB, iit, bit)
    55  			retVal = reuse
    56  		default: // safe && bool
    57  			panic("Unreachable")
    58  		}
    59  		return
    60  	}
    61  
    62  	// standard
    63  	switch {
    64  	case !safe && reuse == nil:
    65  		err = e.E.MinBetween(typ, dataA, dataB)
    66  		retVal = a
    67  	case safe && reuse != nil:
    68  		storage.Copy(typ, dataReuse, dataA)
    69  		err = e.E.MinBetween(typ, dataReuse, dataB)
    70  		retVal = reuse
    71  	default:
    72  		panic("Unreachable")
    73  	}
    74  	return
    75  }
    76  
    77  func (e StdEng) MaxBetween(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error) {
    78  	if err = binaryCheck(a, b, ordTypes); err != nil {
    79  		return nil, errors.Wrapf(err, "MaxBetween failed")
    80  	}
    81  
    82  	var reuse DenseTensor
    83  	var safe bool
    84  	if reuse, safe, _, _, _, err = handleFuncOpts(a.Shape(), a.Dtype(), a.DataOrder(), true, opts...); err != nil {
    85  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
    86  	}
    87  	typ := a.Dtype().Type
    88  	var dataA, dataB, dataReuse *storage.Header
    89  	var ait, bit, iit Iterator
    90  	var useIter, swap bool
    91  	if dataA, dataB, dataReuse, ait, bit, iit, useIter, swap, err = prepDataVV(a, b, reuse); err != nil {
    92  		return nil, errors.Wrapf(err, "StdEng.MaxBetween")
    93  	}
    94  	// check to see if anything needs to be created
    95  	if reuse == nil {
    96  		if swap {
    97  			reuse = NewDense(b.Dtype(), b.Shape().Clone(), WithEngine(e))
    98  		} else {
    99  			reuse = NewDense(a.Dtype(), a.Shape().Clone(), WithEngine(e))
   100  		}
   101  		dataReuse = reuse.hdr()
   102  		if useIter {
   103  			iit = IteratorFromDense(reuse)
   104  		}
   105  	}
   106  
   107  	if useIter {
   108  		switch {
   109  		case !safe && reuse == nil:
   110  			err = e.E.MaxBetweenIter(typ, dataA, dataB, ait, bit)
   111  			retVal = a
   112  		case safe && reuse != nil:
   113  			storage.CopyIter(typ, dataReuse, dataA, iit, ait)
   114  			ait.Reset()
   115  			iit.Reset()
   116  			err = e.E.MaxBetweenIter(typ, dataReuse, dataB, iit, bit)
   117  			retVal = reuse
   118  		default: // safe && bool
   119  			panic("Unreachable")
   120  		}
   121  		return
   122  	}
   123  
   124  	// standard
   125  	switch {
   126  	case !safe && reuse == nil:
   127  		err = e.E.MaxBetween(typ, dataA, dataB)
   128  		retVal = a
   129  	case safe && reuse != nil:
   130  		storage.Copy(typ, dataReuse, dataA)
   131  		err = e.E.MaxBetween(typ, dataReuse, dataB)
   132  		retVal = reuse
   133  	default:
   134  		panic("Unreachable")
   135  	}
   136  	return
   137  }
   138  
   139  func (e StdEng) MinBetweenScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error) {
   140  	if err = unaryCheck(t, ordTypes); err != nil {
   141  		return nil, errors.Wrapf(err, "MinBetween failed")
   142  	}
   143  
   144  	if err = scalarDtypeCheck(t, s); err != nil {
   145  		return nil, errors.Wrap(err, "MinBetween failed")
   146  	}
   147  
   148  	var reuse DenseTensor
   149  	var safe bool
   150  	if reuse, safe, _, _, _, err = handleFuncOpts(t.Shape(), t.Dtype(), t.DataOrder(), true, opts...); err != nil {
   151  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   152  	}
   153  	a := t
   154  	typ := t.Dtype().Type
   155  	var ait, bit, iit Iterator
   156  	var dataA, dataB, dataReuse, scalarHeader *storage.Header
   157  	var useIter, newAlloc bool
   158  
   159  	if leftTensor {
   160  		if dataA, dataB, dataReuse, ait, iit, useIter, newAlloc, err = prepDataVS(t, s, reuse); err != nil {
   161  			return nil, errors.Wrapf(err, opFail, "StdEng.MinBetween")
   162  		}
   163  		scalarHeader = dataB
   164  	} else {
   165  		if dataA, dataB, dataReuse, bit, iit, useIter, newAlloc, err = prepDataSV(s, t, reuse); err != nil {
   166  			return nil, errors.Wrapf(err, opFail, "StdEng.MinBetween")
   167  		}
   168  		scalarHeader = dataA
   169  	}
   170  
   171  	// check to see if anything needs to be created
   172  	if reuse == nil {
   173  		reuse = NewDense(a.Dtype(), a.Shape().Clone(), WithEngine(e))
   174  		dataReuse = reuse.hdr()
   175  		if useIter {
   176  			iit = IteratorFromDense(reuse)
   177  		}
   178  	}
   179  
   180  	if useIter {
   181  		switch {
   182  		case !safe && reuse == nil:
   183  			err = e.E.MinBetweenIter(typ, dataA, dataB, ait, bit)
   184  			retVal = a
   185  		case safe && reuse != nil && !leftTensor:
   186  			storage.CopyIter(typ, dataReuse, dataB, iit, bit)
   187  			bit.Reset()
   188  			iit.Reset()
   189  			err = e.E.MinBetweenIter(typ, dataA, dataReuse, ait, bit)
   190  			retVal = reuse
   191  		case safe && reuse != nil && leftTensor:
   192  			storage.CopyIter(typ, dataReuse, dataA, iit, ait)
   193  			ait.Reset()
   194  			iit.Reset()
   195  			err = e.E.MinBetweenIter(typ, dataReuse, dataB, iit, bit)
   196  			retVal = reuse
   197  		default: // safe && bool
   198  			panic("Unreachable")
   199  		}
   200  		if newAlloc {
   201  			freeScalar(scalarHeader.Raw)
   202  		}
   203  		returnHeader(scalarHeader)
   204  		return
   205  	}
   206  
   207  	// handle special case where A and B have both len 1
   208  	if len(dataA.Raw) == int(typ.Size()) && len(dataB.Raw) == int(typ.Size()) {
   209  		switch {
   210  		case safe && reuse != nil && leftTensor:
   211  			storage.Copy(typ, dataReuse, dataA)
   212  			err = e.E.MinBetween(typ, dataReuse, dataB)
   213  			retVal = reuse
   214  			return
   215  		case safe && reuse != nil && !leftTensor:
   216  			storage.Copy(typ, dataReuse, dataB)
   217  			err = e.E.MinBetween(typ, dataReuse, dataA)
   218  			retVal = reuse
   219  			return
   220  		}
   221  	}
   222  	// standard
   223  	switch {
   224  	case !safe && reuse == nil:
   225  		err = e.E.MinBetween(typ, dataA, dataB)
   226  		retVal = a
   227  	case safe && reuse != nil && leftTensor:
   228  		storage.Copy(typ, dataReuse, dataA)
   229  		err = e.E.MinBetween(typ, dataReuse, dataB)
   230  		retVal = reuse
   231  	case safe && reuse != nil && !leftTensor:
   232  		storage.Copy(typ, dataReuse, dataB)
   233  		err = e.E.MinBetween(typ, dataA, dataReuse)
   234  		retVal = reuse
   235  	default:
   236  		panic("Unreachable")
   237  	}
   238  	if newAlloc {
   239  		freeScalar(scalarHeader.Raw)
   240  	}
   241  	returnHeader(scalarHeader)
   242  	return
   243  }
   244  
   245  func (e StdEng) MaxBetweenScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error) {
   246  	if err = unaryCheck(t, ordTypes); err != nil {
   247  		return nil, errors.Wrapf(err, "MaxBetween failed")
   248  	}
   249  
   250  	if err = scalarDtypeCheck(t, s); err != nil {
   251  		return nil, errors.Wrap(err, "MaxBetween failed")
   252  	}
   253  
   254  	var reuse DenseTensor
   255  	var safe bool
   256  	if reuse, safe, _, _, _, err = handleFuncOpts(t.Shape(), t.Dtype(), t.DataOrder(), true, opts...); err != nil {
   257  		return nil, errors.Wrap(err, "Unable to handle funcOpts")
   258  	}
   259  	a := t
   260  	typ := t.Dtype().Type
   261  	var ait, bit, iit Iterator
   262  	var dataA, dataB, dataReuse, scalarHeader *storage.Header
   263  	var useIter, newAlloc bool
   264  
   265  	if leftTensor {
   266  		if dataA, dataB, dataReuse, ait, iit, useIter, newAlloc, err = prepDataVS(t, s, reuse); err != nil {
   267  			return nil, errors.Wrapf(err, opFail, "StdEng.MaxBetween")
   268  		}
   269  		scalarHeader = dataB
   270  	} else {
   271  		if dataA, dataB, dataReuse, bit, iit, useIter, newAlloc, err = prepDataSV(s, t, reuse); err != nil {
   272  			return nil, errors.Wrapf(err, opFail, "StdEng.MaxBetween")
   273  		}
   274  		scalarHeader = dataA
   275  	}
   276  
   277  	// check to see if anything needs to be created
   278  	if reuse == nil {
   279  		reuse = NewDense(a.Dtype(), a.Shape().Clone(), WithEngine(e))
   280  		dataReuse = reuse.hdr()
   281  		if useIter {
   282  			iit = IteratorFromDense(reuse)
   283  		}
   284  	}
   285  
   286  	if useIter {
   287  		switch {
   288  		case !safe && reuse == nil:
   289  			err = e.E.MaxBetweenIter(typ, dataA, dataB, ait, bit)
   290  			retVal = a
   291  		case safe && reuse != nil && !leftTensor:
   292  			storage.CopyIter(typ, dataReuse, dataB, iit, bit)
   293  			bit.Reset()
   294  			iit.Reset()
   295  			err = e.E.MaxBetweenIter(typ, dataA, dataReuse, ait, bit)
   296  			retVal = reuse
   297  		case safe && reuse != nil && leftTensor:
   298  			storage.CopyIter(typ, dataReuse, dataA, iit, ait)
   299  			ait.Reset()
   300  			iit.Reset()
   301  			err = e.E.MaxBetweenIter(typ, dataReuse, dataB, iit, bit)
   302  			retVal = reuse
   303  		default: // safe && bool
   304  			panic("Unreachable")
   305  		}
   306  		if newAlloc {
   307  			freeScalar(scalarHeader.Raw)
   308  		}
   309  		returnHeader(scalarHeader)
   310  		return
   311  	}
   312  
   313  	// handle special case where A and B have both len 1
   314  	if len(dataA.Raw) == int(typ.Size()) && len(dataB.Raw) == int(typ.Size()) {
   315  		switch {
   316  		case safe && reuse != nil && leftTensor:
   317  			storage.Copy(typ, dataReuse, dataA)
   318  			err = e.E.MaxBetween(typ, dataReuse, dataB)
   319  			retVal = reuse
   320  			return
   321  		case safe && reuse != nil && !leftTensor:
   322  			storage.Copy(typ, dataReuse, dataB)
   323  			err = e.E.MaxBetween(typ, dataReuse, dataA)
   324  			retVal = reuse
   325  			return
   326  		}
   327  	}
   328  	// standard
   329  	switch {
   330  	case !safe && reuse == nil:
   331  		err = e.E.MaxBetween(typ, dataA, dataB)
   332  		retVal = a
   333  	case safe && reuse != nil && leftTensor:
   334  		storage.Copy(typ, dataReuse, dataA)
   335  		err = e.E.MaxBetween(typ, dataReuse, dataB)
   336  		retVal = reuse
   337  	case safe && reuse != nil && !leftTensor:
   338  		storage.Copy(typ, dataReuse, dataB)
   339  		err = e.E.MaxBetween(typ, dataA, dataReuse)
   340  		retVal = reuse
   341  	default:
   342  		panic("Unreachable")
   343  	}
   344  	if newAlloc {
   345  		freeScalar(scalarHeader.Raw)
   346  	}
   347  	returnHeader(scalarHeader)
   348  	return
   349  }