libtch

README

NOTES ON WRITING WRAPPER FUNCTIONS

Function Input Arguments

tensor -> t *C_tensor

void at_print(tensor);

func AtPrint(t *C_tensor) {
	c_tensor := (C.tensor)((*t).private)
	C.at_print(c_tensor)
}

C pointer e.g int64_t * -> ptr unsafe.Pointer

In function body, cPtr := (*C.long)(ptr)

void at_shape(tensor, int64_t *);

func AtShape(t *C_tensor, ptr unsafe.Pointer) {
	c_tensor := (C.tensor)((*t).private)
	c_ptr := (*C.long)(ptr)
	C.at_shape(c_tensor, c_ptr)
}

C types e.g size_t ndims -> equivalent Go types ndims uint

In function body, c_ndims := *(*C.size_t)(unsafe.Pointer(&ndims))

tensor at_tensor_of_data(void *vs, int64_t *dims, size_t ndims, size_t element_size_in_bytes, int type);

func AtTensorOfData(vs unsafe.Pointer, dims []int64, ndims uint, elt_size_in_bytes uint, kind int) *C_tensor {

    // 1. Unsafe pointer
	c_dims := (*C.int64_t)(unsafe.Pointer(&dims[0]))
	c_ndims := *(*C.size_t)(unsafe.Pointer(&ndims))
	c_elt_size_in_bytes := *(*C.size_t)(unsafe.Pointer(&elt_size_in_bytes))
	c_kind := *(*C.int)(unsafe.Pointer(&kind))

    // 2. Call C function
	t := C.at_tensor_of_data(vs, c_dims, c_ndims, c_elt_size_in_bytes, c_kind)

    // 3. Form return value
	return &C_tensor{private: unsafe.Pointer(t)}
}

Function Return

void *CFUNC(...)

void *at_data_ptr(tensor);

func AtDataPtr(t *C_tensor) unsafe.Pointer {
	c_tensor := (C.tensor)((*t).private)
	return C.at_data_ptr(c_tensor)
}

tensor -> *C_tensor

then in the return of function body

    // Call C function
    t := C.FUNCTION_TO_CALL(...)
    // Return
	return &C_tensor{private: unsafe.Pointer(t)}

tensor *CFUNC(...)

The pattern of return tensor pointer: tensor *atg_FUNCTION_NAME(). The returning tensor pointer actually is the FIRST element of a vector of C tensor pointers. Next pointer will be calculated from the first. In C land, verifying a valid pointer is to check whether it points to NULL.

tensor *atg_split(tensor self, int64_t split_size, int64_t dim);

// Wrapper
func AtgSplit(self Ctensor, splitSize int64, dim int64) *Ctensor {

	csplitSize := *(*C.int64_t)(unsafe.Pointer(&splitSize))
	cdim := *(*C.int64_t)(unsafe.Pointer(&dim))

	return C.atg_split(self, csplitSize, cdim)
}

// API

// Split splits tensor into chunks
//
// Parameters:
//  - splitSize – size of a single chunk or list of sizes for each chunk
//  - dim – dimension along which to split the tensor.
// Ref. https://pytorch.org/docs/stable/generated/torch.split.html
func (ts Tensor) Split(splitSize, dim int64) (retVal []Tensor, err error) {

	ctensorsPtr := lib.AtgSplit(ts.ctensor, splitSize, dim)
	if err = TorchErr(); err != nil {
		return retVal, err
	}

	// NOTE: ctensorsPtr is a c-pointer to a vector of tensors. The first
	// C tensor is the `ctensorsPtr` value. The next pointer will be
	// calculated from there. The vector of tensors will end if the calculated
	// pointer value is `null`.
	currentPtr := ctensorsPtr
	retVal = append(retVal, Tensor{ctensor: *currentPtr})
	for {
		// calculate the next pointer value
		nextPtr := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(currentPtr)) + unsafe.Sizeof(currentPtr)))
		if *nextPtr == nil {
			break
		}

		retVal = append(retVal, Tensor{ctensor: *nextPtr})
		currentPtr = nextPtr
	}

	return retVal, nil
}

C types e.g. C_ulong -> Go equivalent types uint64

then in the return of function body

	c_result := C.FUNCTION_CALL(...)
	return *(*uint64)(unsafe.Pointer(&c_result))

C type pointers e.g. char *FUNCTION() --> *C.char

then just return the C function call.

char *get_and_reset_last_err(); // thread-local

func GetAndResetLastErr() *C.char{
   return C.get_and_reset_last_err()
}

Multiple Tensors Created In C Land Memory

• When there are multiple Ctensor created in C land memory. A first Ctensor pointer will be created and given to the C function. It will create consecutive Ctensor(s) based on this pointer. The next pointer(s) can be calulated based on this pointer and its size.

• Example: lstm function

  • C function

      void atg_lstm(tensor *, tensor input, tensor *hx_data, int hx_len, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional, int batch_first);
  

  • Go wrapper function

      func AtgLstm(ptr *Ctensor, input Ctensor, hxData []Ctensor, hxLen int, paramsData []Ctensor, paramsLen int, hasBiases int, numLayers int64, dropout float64, train int, bidirectional int, batchFirst int) {
  
          chxDataPtr := (*Ctensor)(unsafe.Pointer(&hxData[0]))
          chxLen := *(*C.int)(unsafe.Pointer(&hxLen))
          cparamsDataPtr := (*Ctensor)(unsafe.Pointer(&paramsData[0]))
          cparamsLen := *(*C.int)(unsafe.Pointer(&paramsLen))
          chasBiases := *(*C.int)(unsafe.Pointer(&hasBiases))
          cnumLayers := *(*C.int64_t)(unsafe.Pointer(&numLayers))
          cdropout := *(*C.double)(unsafe.Pointer(&dropout))
          ctrain := *(*C.int)(unsafe.Pointer(&train))
          cbidirectional := *(*C.int)(unsafe.Pointer(&bidirectional))
          cbatchFirst := *(*C.int)(unsafe.Pointer(&batchFirst))
  
          C.atg_lstm(ptr, input, chxDataPtr, chxLen, cparamsDataPtr, cparamsLen, chasBiases, cnumLayers, cdropout, ctrain, cbidirectional, cbatchFirst)
      }
  

  • Go API function

  func (ts Tensor) LSTM(hxData []Tensor, paramsData []Tensor, hasBiases bool, numLayers int64, dropout float64, train bool, bidirectional bool, batchFirst bool) (output, h, c Tensor, err error) {
  
      // NOTE: `atg_lstm` will create 3 consecutive Ctensors in memory of C land. The first
      // Ctensor will have address given by `ctensorPtr1` here.
      // The next pointers can be calculated based on `ctensorPtr1`
      ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0)))
      ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr1)))
      ctensorPtr3 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr2)) + unsafe.Sizeof(ctensorPtr1)))
  
      var chxData []lib.Ctensor
      for _, t := range hxData {
          chxData = append(chxData, t.ctensor)
      }
  
      var cparamsData []lib.Ctensor
      for _, t := range paramsData {
          cparamsData = append(cparamsData, t.ctensor)
      }
  
      chasBiases := 0
      if hasBiases {
          chasBiases = 1
      }
      ctrain := 0
      if train {
          ctrain = 1
      }
      cbidirectional := 0
      if bidirectional {
          cbidirectional = 1
      }
      cbatchFirst := 0
      if batchFirst {
          cbatchFirst = 1
      }
  
      lib.AtgLstm(ctensorPtr1, ts.ctensor, chxData, len(hxData), cparamsData, len(paramsData), chasBiases, numLayers, dropout, ctrain, cbidirectional, cbatchFirst)
      err = TorchErr()
      if err != nil {
          return output, h, c, err
      }
  
      return Tensor{ctensor: *ctensorPtr1}, Tensor{ctensor: *ctensorPtr2}, Tensor{ctensor: *ctensorPtr3}, nil
  
  }
  

Documentation

Overview

NOTE: functions in this file would be automatically generated and named as `c-generated.go`

Index

• Variables
• func AtBackward(ts Ctensor, keepGraph int, createGraph int)
• func AtCopyData(ts Ctensor, vs unsafe.Pointer, numel uint, element_size_in_bytes uint)
• func AtCopy_(dst Ctensor, src Ctensor)
• func AtDataPtr(t Ctensor) unsafe.Pointer
• func AtDefined(ts Ctensor) bool
• func AtDevice(ts Ctensor) int
• func AtDim(t Ctensor) uint64
• func AtDoubleValueAtIndexes(ts Ctensor, indexes unsafe.Pointer, indexesLen int) float64
• func AtFree(ts Ctensor)
• func AtGradSetEnabled(b int) int
• func AtInt64ValueAtIndexes(ts Ctensor, indexes unsafe.Pointer, indexesLen int) int64
• func AtIsSparse(ts Ctensor) bool
• func AtLoadCallback(filename string, dataPtr unsafe.Pointer)
• func AtLoadCallbackWithDevice(filename string, dataPtr unsafe.Pointer, device int32)
• func AtLoadMulti(tensors []Ctensor, tensor_names []string, ntensors int, filename string)
• func AtPrint(t Ctensor)
• func AtRequiresGrad(ts Ctensor) bool
• func AtRunBackward(tensorsPtr *Ctensor, ntensors int, inputsPtr *Ctensor, ninputs int, ...)
• func AtSave(ts Ctensor, path string)
• func AtSaveImage(ts Ctensor, path string)
• func AtSaveMulti(tensors []Ctensor, tensor_names []string, ntensors int, filename string)
• func AtSaveMultiNew(tensors []Ctensor, names []string, filename string)
• func AtScalarType(t Ctensor) int32
• func AtShape(t Ctensor, ptr unsafe.Pointer)
• func AtToString(ts Ctensor, lineSize int64) string
• func AtcCudaDeviceCount() int
• func AtcCudaIsAvailable() bool
• func AtcCudnnIsAvailable() bool
• func AtcSetBenchmarkCudnn(b int)
• func Atc_cuda_device_count() int
• func AtgAbs(ptr *Ctensor, self Ctensor)
• func AtgAbsOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAbs_(ptr *Ctensor, self Ctensor)
• func AtgAbsolute(ptr *Ctensor, self Ctensor)
• func AtgAbsoluteOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAbsolute_(ptr *Ctensor, self Ctensor)
• func AtgAcos(ptr *Ctensor, self Ctensor)
• func AtgAcosOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAcos_(ptr *Ctensor, self Ctensor)
• func AtgAcosh(ptr *Ctensor, self Ctensor)
• func AtgAcoshOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAcosh_(ptr *Ctensor, self Ctensor)
• func AtgAdaptiveAvgPool1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
• func AtgAdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
• func AtgAdaptiveAvgPool2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgAdaptiveAvgPool3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
• func AtgAdaptiveAvgPool3dBackward(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor)
• func AtgAdaptiveAvgPool3dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgAdaptiveMaxPool1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
• func AtgAdaptiveMaxPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
• func AtgAdaptiveMaxPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor)
• func AtgAdaptiveMaxPool2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgAdaptiveMaxPool2dOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, ...)
• func AtgAdaptiveMaxPool3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
• func AtgAdaptiveMaxPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor)
• func AtgAdaptiveMaxPool3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgAdaptiveMaxPool3dOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, ...)
• func AtgAdd(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgAddOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgAddScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgAddScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgAdd_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgAddbmm(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)
• func AtgAddbmmOut(ptr *Ctensor, out Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)
• func AtgAddbmm_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)
• func AtgAddcdiv(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)
• func AtgAddcdivOut(ptr *Ctensor, out Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)
• func AtgAddcdiv_(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)
• func AtgAddcmul(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)
• func AtgAddcmulOut(ptr *Ctensor, out Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)
• func AtgAddcmul_(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)
• func AtgAddmm(ptr *Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)
• func AtgAddmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)
• func AtgAddmm_(ptr *Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)
• func AtgAddmv(ptr *Ctensor, self Ctensor, mat Ctensor, vec Ctensor)
• func AtgAddmvOut(ptr *Ctensor, out Ctensor, self Ctensor, mat Ctensor, vec Ctensor)
• func AtgAddmv_(ptr *Ctensor, self Ctensor, mat Ctensor, vec Ctensor)
• func AtgAddr(ptr *Ctensor, self Ctensor, vec1 Ctensor, vec2 Ctensor)
• func AtgAddrOut(ptr *Ctensor, out Ctensor, self Ctensor, vec1 Ctensor, vec2 Ctensor)
• func AtgAddr_(ptr *Ctensor, self Ctensor, vec1 Ctensor, vec2 Ctensor)
• func AtgAffineGridGenerator(ptr *Ctensor, theta Ctensor, sizeData []int64, sizeLen int, alignCorners int32)
• func AtgAffineGridGeneratorBackward(ptr *Ctensor, grad Ctensor, sizeData []int64, sizeLen int, alignCorners int32)
• func AtgAlias(ptr *Ctensor, self Ctensor)
• func AtgAlignAs(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgAll(ptr *Ctensor, self Ctensor)
• func AtgAllAllOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAllDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
• func AtgAllOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32)
• func AtgAllclose(self Ctensor, other Ctensor, rtol float64, atol float64, equalNan int32) bool
• func AtgAlphaDropout(ptr *Ctensor, input Ctensor, p float64, train int32)
• func AtgAlphaDropout_(ptr *Ctensor, self Ctensor, p float64, train int32)
• func AtgAmax(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)
• func AtgAmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgAmin(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)
• func AtgAminOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgAminmax(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)
• func AtgAminmaxOut(ptr *Ctensor, min Ctensor, max Ctensor, self Ctensor, dimVal int64, ...)
• func AtgAngle(ptr *Ctensor, self Ctensor)
• func AtgAngleOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAny(ptr *Ctensor, self Ctensor)
• func AtgAnyAllOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAnyDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
• func AtgAnyOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32)
• func AtgArange(ptr *Ctensor, end Cscalar, optionsKind int32, optionsDevice int32)
• func AtgArangeOut(ptr *Ctensor, out Ctensor, end Cscalar)
• func AtgArangeStart(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, ...)
• func AtgArangeStartOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar)
• func AtgArangeStartStep(ptr *Ctensor, start Cscalar, end Cscalar, step Cscalar, optionsKind int32, ...)
• func AtgArccos(ptr *Ctensor, self Ctensor)
• func AtgArccosOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgArccos_(ptr *Ctensor, self Ctensor)
• func AtgArccosh(ptr *Ctensor, self Ctensor)
• func AtgArccoshOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgArccosh_(ptr *Ctensor, self Ctensor)
• func AtgArcsin(ptr *Ctensor, self Ctensor)
• func AtgArcsinOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgArcsin_(ptr *Ctensor, self Ctensor)
• func AtgArcsinh(ptr *Ctensor, self Ctensor)
• func AtgArcsinhOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgArcsinh_(ptr *Ctensor, self Ctensor)
• func AtgArctan(ptr *Ctensor, self Ctensor)
• func AtgArctanOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgArctan_(ptr *Ctensor, self Ctensor)
• func AtgArctanh(ptr *Ctensor, self Ctensor)
• func AtgArctanhOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgArctanh_(ptr *Ctensor, self Ctensor)
• func AtgArgmax(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)
• func AtgArgmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, dimVal int64, dimNull int, ...)
• func AtgArgmin(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)
• func AtgArgminOut(ptr *Ctensor, out Ctensor, self Ctensor, dimVal int64, dimNull int, ...)
• func AtgArgsort(ptr *Ctensor, self Ctensor, dim int64, descending int32)
• func AtgAsStrided(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, ...)
• func AtgAsStrided_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, ...)
• func AtgAsin(ptr *Ctensor, self Ctensor)
• func AtgAsinOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAsin_(ptr *Ctensor, self Ctensor)
• func AtgAsinh(ptr *Ctensor, self Ctensor)
• func AtgAsinhOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAsinh_(ptr *Ctensor, self Ctensor)
• func AtgAtan(ptr *Ctensor, self Ctensor)
• func AtgAtan2(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgAtan2Out(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgAtan2_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgAtanOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAtan_(ptr *Ctensor, self Ctensor)
• func AtgAtanh(ptr *Ctensor, self Ctensor)
• func AtgAtanhOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgAtanh_(ptr *Ctensor, self Ctensor)
• func AtgAtleast1d(ptr *Ctensor, self Ctensor)
• func AtgAtleast2d(ptr *Ctensor, self Ctensor)
• func AtgAtleast3d(ptr *Ctensor, self Ctensor)
• func AtgAvgPool1d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgAvgPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgAvgPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, ...)
• func AtgAvgPool2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgAvgPool2dOut(ptr *Ctensor, out Ctensor, self Ctensor, kernelSizeData []int64, ...)
• func AtgAvgPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgAvgPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, ...)
• func AtgAvgPool3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgAvgPool3dOut(ptr *Ctensor, out Ctensor, self Ctensor, kernelSizeData []int64, ...)
• func AtgBaddbmm(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)
• func AtgBaddbmmOut(ptr *Ctensor, out Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)
• func AtgBaddbmm_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)
• func AtgBartlettWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)
• func AtgBartlettWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, ...)
• func AtgBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, ...)
• func AtgBatchNormBackwardElemt(ptr *Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, ...)
• func AtgBatchNormBackwardReduce(ptr *Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, ...)
• func AtgBatchNormElemt(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, mean Ctensor, ...)
• func AtgBatchNormElemtOut(ptr *Ctensor, out Ctensor, input Ctensor, weight Ctensor, bias Ctensor, ...)
• func AtgBatchNormGatherStats(ptr *Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, runningMean Ctensor, ...)
• func AtgBatchNormGatherStatsWithCounts(ptr *Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, runningMean Ctensor, ...)
• func AtgBatchNormStats(ptr *Ctensor, input Ctensor, eps float64)
• func AtgBatchNormUpdateStats(ptr *Ctensor, input Ctensor, runningMean Ctensor, runningVar Ctensor, ...)
• func AtgBernoulli(ptr *Ctensor, self Ctensor)
• func AtgBernoulliFloat_(ptr *Ctensor, self Ctensor, p float64)
• func AtgBernoulliOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgBernoulliP(ptr *Ctensor, self Ctensor, p float64)
• func AtgBernoulli_(ptr *Ctensor, self Ctensor, p Ctensor)
• func AtgBilinear(ptr *Ctensor, input1 Ctensor, input2 Ctensor, weight Ctensor, bias Ctensor)
• func AtgBinaryCrossEntropy(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64)
• func AtgBinaryCrossEntropyBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, ...)
• func AtgBinaryCrossEntropyBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgBinaryCrossEntropyOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, weight Ctensor, ...)
• func AtgBinaryCrossEntropyWithLogits(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, posWeight Ctensor, ...)
• func AtgBinaryCrossEntropyWithLogitsBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, ...)
• func AtgBincount(ptr *Ctensor, self Ctensor, weights Ctensor, minlength int64)
• func AtgBinomial(ptr *Ctensor, count Ctensor, prob Ctensor)
• func AtgBitwiseAnd(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseAndScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseAndTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseAndTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseAndTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseAnd_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseLeftShift(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseLeftShiftScalarTensor(ptr *Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgBitwiseLeftShiftTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseLeftShiftTensorScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseLeftShiftTensorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseLeftShiftTensorScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseLeftShift_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseNot(ptr *Ctensor, self Ctensor)
• func AtgBitwiseNotOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgBitwiseNot_(ptr *Ctensor, self Ctensor)
• func AtgBitwiseOr(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseOrScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseOrTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseOrTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseOrTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseOr_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseRightShift(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseRightShiftScalarTensor(ptr *Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgBitwiseRightShiftTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseRightShiftTensorScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseRightShiftTensorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseRightShiftTensorScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseRightShift_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseXor(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseXorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgBitwiseXorTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseXorTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseXorTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgBitwiseXor_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgBlackmanWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)
• func AtgBlackmanWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, ...)
• func AtgBlockDiag(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgBmm(ptr *Ctensor, self Ctensor, mat2 Ctensor)
• func AtgBmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor)
• func AtgBroadcastTo(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)
• func AtgBucketize(ptr *Ctensor, self Ctensor, boundaries Ctensor, outInt32 int32, right int32)
• func AtgBucketizeScalar(ptr *Ctensor, selfScalar Cscalar, boundaries Ctensor, outInt32 int32, ...)
• func AtgBucketizeTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, boundaries Ctensor, outInt32 int32, ...)
• func AtgCanCast(from int32, to int32) bool
• func AtgCartesianProd(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgCat(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func AtgCatOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func AtgCauchy_(ptr *Ctensor, self Ctensor, median float64, sigma float64)
• func AtgCdist(ptr *Ctensor, x1 Ctensor, x2 Ctensor, p float64, computeModeVal int64, ...)
• func AtgCeil(ptr *Ctensor, self Ctensor)
• func AtgCeilOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgCeil_(ptr *Ctensor, self Ctensor)
• func AtgCelu(ptr *Ctensor, self Ctensor)
• func AtgCelu_(ptr *Ctensor, self Ctensor)
• func AtgChainMatmul(ptr *Ctensor, matricesData []Ctensor, matricesLen int)
• func AtgChainMatmulOut(ptr *Ctensor, out Ctensor, matricesData []Ctensor, matricesLen int)
• func AtgChannelShuffle(ptr *Ctensor, self Ctensor, groups int64)
• func AtgCholesky(ptr *Ctensor, self Ctensor, upper int32)
• func AtgCholeskyInverse(ptr *Ctensor, self Ctensor, upper int32)
• func AtgCholeskyInverseOut(ptr *Ctensor, out Ctensor, self Ctensor, upper int32)
• func AtgCholeskyOut(ptr *Ctensor, out Ctensor, self Ctensor, upper int32)
• func AtgCholeskySolve(ptr *Ctensor, self Ctensor, input2 Ctensor, upper int32)
• func AtgCholeskySolveOut(ptr *Ctensor, out Ctensor, self Ctensor, input2 Ctensor, upper int32)
• func AtgChooseQparamsOptimized(ptr *Ctensor, input Ctensor, numel int64, nBins int64, ratio float64, ...)
• func AtgClamp(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar)
• func AtgClampMax(ptr *Ctensor, self Ctensor, max Cscalar)
• func AtgClampMaxOut(ptr *Ctensor, out Ctensor, self Ctensor, max Cscalar)
• func AtgClampMaxTensor(ptr *Ctensor, self Ctensor, max Ctensor)
• func AtgClampMaxTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, max Ctensor)
• func AtgClampMaxTensor_(ptr *Ctensor, self Ctensor, max Ctensor)
• func AtgClampMax_(ptr *Ctensor, self Ctensor, max Cscalar)
• func AtgClampMin(ptr *Ctensor, self Ctensor, min Cscalar)
• func AtgClampMinOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar)
• func AtgClampMinTensor(ptr *Ctensor, self Ctensor, min Ctensor)
• func AtgClampMinTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, min Ctensor)
• func AtgClampMinTensor_(ptr *Ctensor, self Ctensor, min Ctensor)
• func AtgClampMin_(ptr *Ctensor, self Ctensor, min Cscalar)
• func AtgClampOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar, max Cscalar)
• func AtgClampTensor(ptr *Ctensor, self Ctensor, min Ctensor, max Ctensor)
• func AtgClampTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, min Ctensor, max Ctensor)
• func AtgClampTensor_(ptr *Ctensor, self Ctensor, min Ctensor, max Ctensor)
• func AtgClamp_(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar)
• func AtgClip(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar)
• func AtgClipOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar, max Cscalar)
• func AtgClipTensor(ptr *Ctensor, self Ctensor, min Ctensor, max Ctensor)
• func AtgClipTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, min Ctensor, max Ctensor)
• func AtgClipTensor_(ptr *Ctensor, self Ctensor, min Ctensor, max Ctensor)
• func AtgClip_(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar)
• func AtgCoalesce(ptr *Ctensor, self Ctensor)
• func AtgCol2im(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgCol2imBackward(ptr *Ctensor, gradOutput Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgCol2imBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, kernelSizeData []int64, ...)
• func AtgCol2imOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgColIndices(ptr *Ctensor, self Ctensor)
• func AtgColumnStack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgColumnStackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgCombinations(ptr *Ctensor, self Ctensor, r int64, withReplacement int32)
• func AtgComplex(ptr *Ctensor, real Ctensor, imag Ctensor)
• func AtgComplexOut(ptr *Ctensor, out Ctensor, real Ctensor, imag Ctensor)
• func AtgConcat(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func AtgConcatOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func AtgConj(ptr *Ctensor, self Ctensor)
• func AtgConjPhysical(ptr *Ctensor, self Ctensor)
• func AtgConjPhysicalOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgConjPhysical_(ptr *Ctensor, self Ctensor)
• func AtgConstantPadNd(ptr *Ctensor, self Ctensor, padData []int64, padLen int)
• func AtgContiguous(ptr *Ctensor, self Ctensor)
• func AtgConv1d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConv1dPadding(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConv2d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConv2dPadding(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConv3d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConv3dPadding(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConvDepthwise3d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, ...)
• func AtgConvDepthwise3dBackward(ptr *Ctensor, gradInput Ctensor, gradWeight Ctensor, gradBias Ctensor, ...)
• func AtgConvTbc(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, pad int64)
• func AtgConvTbcBackward(ptr *Ctensor, self Ctensor, input Ctensor, weight Ctensor, bias Ctensor, ...)
• func AtgConvTranspose1d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConvTranspose2d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConvTranspose3d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConvolution(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgConvolutionOverrideable(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgCopySparseToSparse_(ptr *Ctensor, self Ctensor, src Ctensor, nonBlocking int32)
• func AtgCopysign(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgCopysignOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgCopysignScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgCopysignScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgCopysignScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgCopysign_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgCorrcoef(ptr *Ctensor, self Ctensor)
• func AtgCos(ptr *Ctensor, self Ctensor)
• func AtgCosOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgCos_(ptr *Ctensor, self Ctensor)
• func AtgCosh(ptr *Ctensor, self Ctensor)
• func AtgCoshOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgCosh_(ptr *Ctensor, self Ctensor)
• func AtgCosineEmbeddingLoss(ptr *Ctensor, input1 Ctensor, input2 Ctensor, target Ctensor, margin float64, ...)
• func AtgCosineSimilarity(ptr *Ctensor, x1 Ctensor, x2 Ctensor, dim int64, eps float64)
• func AtgCountNonzero(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int)
• func AtgCountNonzeroDimIntlist(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int)
• func AtgCov(ptr *Ctensor, self Ctensor, correction int64, fweights Ctensor, ...)
• func AtgCross(ptr *Ctensor, self Ctensor, other Ctensor, dimVal int64, dimNull int)
• func AtgCrossEntropyLoss(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ...)
• func AtgCrossOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, dimVal int64, ...)
• func AtgCrowIndices(ptr *Ctensor, self Ctensor)
• func AtgCtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, ...)
• func AtgCtcLossTensor(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengths Ctensor, ...)
• func AtgCudnnAffineGridGenerator(ptr *Ctensor, theta Ctensor, n int64, c int64, h int64, w int64)
• func AtgCudnnAffineGridGeneratorBackward(ptr *Ctensor, grad Ctensor, n int64, c int64, h int64, w int64)
• func AtgCudnnBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, ...)
• func AtgCudnnBatchNormBackward(ptr *Ctensor, input Ctensor, gradOutput Ctensor, weight Ctensor, ...)
• func AtgCudnnConvolution(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, ...)
• func AtgCudnnConvolutionAddRelu(ptr *Ctensor, self Ctensor, weight Ctensor, z Ctensor, alpha Cscalar, ...)
• func AtgCudnnConvolutionBackwardInput(ptr *Ctensor, selfSizeData []int64, selfSizeLen int, gradOutput Ctensor, ...)
• func AtgCudnnConvolutionBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, ...)
• func AtgCudnnConvolutionDeprecated(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, ...)
• func AtgCudnnConvolutionDeprecated2(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, ...)
• func AtgCudnnConvolutionRelu(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func AtgCudnnConvolutionTranspose(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, ...)
• func AtgCudnnConvolutionTransposeBackwardInput(ptr *Ctensor, gradOutput Ctensor, weight Ctensor, paddingData []int64, ...)
• func AtgCudnnConvolutionTransposeBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, ...)
• func AtgCudnnConvolutionTransposeDeprecated(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, ...)
• func AtgCudnnConvolutionTransposeDeprecated2(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, ...)
• func AtgCudnnGridSampler(ptr *Ctensor, self Ctensor, grid Ctensor)
• func AtgCudnnGridSamplerBackward(ptr *Ctensor, self Ctensor, grid Ctensor, gradOutput Ctensor)
• func AtgCudnnIsAcceptable(self Ctensor) bool
• func AtgCummax(ptr *Ctensor, self Ctensor, dim int64)
• func AtgCummaxOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64)
• func AtgCummaxminBackward(ptr *Ctensor, grad Ctensor, input Ctensor, indices Ctensor, dim int64)
• func AtgCummin(ptr *Ctensor, self Ctensor, dim int64)
• func AtgCumminOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64)
• func AtgCumprod(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
• func AtgCumprodBackward(ptr *Ctensor, grad Ctensor, input Ctensor, dim int64, output Ctensor)
• func AtgCumprodOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, dtype int32)
• func AtgCumprod_(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
• func AtgCumsum(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
• func AtgCumsumOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, dtype int32)
• func AtgCumsum_(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
• func AtgCumulativeTrapezoid(ptr *Ctensor, y Ctensor, dim int64)
• func AtgCumulativeTrapezoidX(ptr *Ctensor, y Ctensor, x Ctensor, dim int64)
• func AtgData(ptr *Ctensor, self Ctensor)
• func AtgDeg2rad(ptr *Ctensor, self Ctensor)
• func AtgDeg2radOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgDeg2rad_(ptr *Ctensor, self Ctensor)
• func AtgDenseDim(self Ctensor) int64
• func AtgDequantize(ptr *Ctensor, self Ctensor)
• func AtgDet(ptr *Ctensor, self Ctensor)
• func AtgDetach(ptr *Ctensor, self Ctensor)
• func AtgDetach_(ptr *Ctensor, self Ctensor)
• func AtgDiag(ptr *Ctensor, self Ctensor, diagonal int64)
• func AtgDiagBackward(ptr *Ctensor, grad Ctensor, inputSizesData []int64, inputSizesLen int, ...)
• func AtgDiagEmbed(ptr *Ctensor, self Ctensor, offset int64, dim1 int64, dim2 int64)
• func AtgDiagOut(ptr *Ctensor, out Ctensor, self Ctensor, diagonal int64)
• func AtgDiagflat(ptr *Ctensor, self Ctensor, offset int64)
• func AtgDiagonal(ptr *Ctensor, self Ctensor, offset int64, dim1 int64, dim2 int64)
• func AtgDiagonalBackward(ptr *Ctensor, gradOutput Ctensor, inputSizesData []int64, inputSizesLen int, ...)
• func AtgDiff(ptr *Ctensor, self Ctensor, n int64, dim int64, prepend Ctensor, ...)
• func AtgDiffOut(ptr *Ctensor, out Ctensor, self Ctensor, n int64, dim int64, prepend Ctensor, ...)
• func AtgDigamma(ptr *Ctensor, self Ctensor)
• func AtgDigammaOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgDigamma_(ptr *Ctensor, self Ctensor)
• func AtgDist(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgDiv(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgDivOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgDivOutMode(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, roundingMode string)
• func AtgDivScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgDivScalarMode(ptr *Ctensor, self Ctensor, other Cscalar, roundingMode string)
• func AtgDivScalarMode_(ptr *Ctensor, self Ctensor, other Cscalar, roundingMode string)
• func AtgDivScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgDivTensorMode(ptr *Ctensor, self Ctensor, other Ctensor, roundingMode string)
• func AtgDivTensorMode_(ptr *Ctensor, self Ctensor, other Ctensor, roundingMode string)
• func AtgDiv_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgDivide(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgDivideOutMode(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, roundingMode string)
• func AtgDivideScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgDivideScalarMode(ptr *Ctensor, self Ctensor, other Cscalar, roundingMode string)
• func AtgDivideScalarMode_(ptr *Ctensor, self Ctensor, other Cscalar, roundingMode string)
• func AtgDivideScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgDivideTensorMode(ptr *Ctensor, self Ctensor, other Ctensor, roundingMode string)
• func AtgDivideTensorMode_(ptr *Ctensor, self Ctensor, other Ctensor, roundingMode string)
• func AtgDivide_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgDot(ptr *Ctensor, self Ctensor, tensor Ctensor)
• func AtgDotOut(ptr *Ctensor, out Ctensor, self Ctensor, tensor Ctensor)
• func AtgDropout(ptr *Ctensor, input Ctensor, p float64, train int32)
• func AtgDropout_(ptr *Ctensor, self Ctensor, p float64, train int32)
• func AtgDstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgDstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgEig(ptr *Ctensor, self Ctensor, eigenvectors int32)
• func AtgEigE(ptr *Ctensor, e Ctensor, v Ctensor, self Ctensor, eigenvectors int32)
• func AtgEinsum(ptr *Ctensor, equation string, tensorsData []Ctensor, tensorsLen int)
• func AtgElu(ptr *Ctensor, self Ctensor)
• func AtgEluBackward(ptr *Ctensor, gradOutput Ctensor, alpha Cscalar, scale Cscalar, ...)
• func AtgEluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, alpha Cscalar, ...)
• func AtgEluOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgElu_(ptr *Ctensor, self Ctensor)
• func AtgEmbedding(ptr *Ctensor, weight Ctensor, indices Ctensor, paddingIdx int64, ...)
• func AtgEmbeddingBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, numWeights int64, ...)
• func AtgEmbeddingBag(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, ...)
• func AtgEmbeddingBagPaddingIdx(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, ...)
• func AtgEmbeddingDenseBackward(ptr *Ctensor, gradOutput Ctensor, indices Ctensor, numWeights int64, ...)
• func AtgEmbeddingRenorm_(ptr *Ctensor, self Ctensor, indices Ctensor, maxNorm float64, normType float64)
• func AtgEmbeddingSparseBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, numWeights int64, ...)
• func AtgEmpty(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgEmptyLike(ptr *Ctensor, self Ctensor)
• func AtgEmptyOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)
• func AtgEmptyQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, qtensor Ctensor, ...)
• func AtgEmptyStrided(ptr *Ctensor, sizeData []int64, sizeLen int, strideData []int64, strideLen int, ...)
• func AtgEq(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgEqScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgEqTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgEqTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgEqTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgEq_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgEqual(self Ctensor, other Ctensor) bool
• func AtgErf(ptr *Ctensor, self Ctensor)
• func AtgErfOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgErf_(ptr *Ctensor, self Ctensor)
• func AtgErfc(ptr *Ctensor, self Ctensor)
• func AtgErfcOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgErfc_(ptr *Ctensor, self Ctensor)
• func AtgErfinv(ptr *Ctensor, self Ctensor)
• func AtgErfinvOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgErfinv_(ptr *Ctensor, self Ctensor)
• func AtgExp(ptr *Ctensor, self Ctensor)
• func AtgExp2(ptr *Ctensor, self Ctensor)
• func AtgExp2Out(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgExp2_(ptr *Ctensor, self Ctensor)
• func AtgExpOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgExp_(ptr *Ctensor, self Ctensor)
• func AtgExpand(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, implicit int32)
• func AtgExpandAs(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgExpm1(ptr *Ctensor, self Ctensor)
• func AtgExpm1Out(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgExpm1_(ptr *Ctensor, self Ctensor)
• func AtgExponential_(ptr *Ctensor, self Ctensor, lambd float64)
• func AtgEye(ptr *Ctensor, n int64, optionsKind int32, optionsDevice int32)
• func AtgEyeM(ptr *Ctensor, n int64, m int64, optionsKind int32, optionsDevice int32)
• func AtgEyeMOut(ptr *Ctensor, out Ctensor, n int64, m int64)
• func AtgEyeOut(ptr *Ctensor, out Ctensor, n int64)
• func AtgFakeQuantizePerChannelAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, ...)
• func AtgFakeQuantizePerChannelAffineCachemask(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, ...)
• func AtgFakeQuantizePerChannelAffineCachemaskBackward(ptr *Ctensor, grad Ctensor, mask Ctensor)
• func AtgFakeQuantizePerTensorAffine(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64, quantMin int64, ...)
• func AtgFakeQuantizePerTensorAffineCachemask(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64, quantMin int64, ...)
• func AtgFakeQuantizePerTensorAffineCachemaskBackward(ptr *Ctensor, grad Ctensor, mask Ctensor)
• func AtgFakeQuantizePerTensorAffineTensorQparams(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, quantMin int64, ...)
• func AtgFbgemmLinearFp16Weight(ptr *Ctensor, input Ctensor, packedWeight Ctensor, bias Ctensor)
• func AtgFbgemmLinearFp16WeightFp32Activation(ptr *Ctensor, input Ctensor, packedWeight Ctensor, bias Ctensor)
• func AtgFbgemmLinearInt8Weight(ptr *Ctensor, input Ctensor, weight Ctensor, packed Ctensor, ...)
• func AtgFbgemmLinearInt8WeightFp32Activation(ptr *Ctensor, input Ctensor, weight Ctensor, packed Ctensor, ...)
• func AtgFbgemmPackGemmMatrixFp16(ptr *Ctensor, input Ctensor)
• func AtgFbgemmPackQuantizedMatrix(ptr *Ctensor, input Ctensor)
• func AtgFbgemmPackQuantizedMatrixKn(ptr *Ctensor, input Ctensor, k int64, n int64)
• func AtgFeatureAlphaDropout(ptr *Ctensor, input Ctensor, p float64, train int32)
• func AtgFeatureAlphaDropout_(ptr *Ctensor, self Ctensor, p float64, train int32)
• func AtgFeatureDropout(ptr *Ctensor, input Ctensor, p float64, train int32)
• func AtgFeatureDropout_(ptr *Ctensor, self Ctensor, p float64, train int32)
• func AtgFftFft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
• func AtgFftFft2(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
• func AtgFftFft2Out(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, ...)
• func AtgFftFftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, ...)
• func AtgFftFftfreq(ptr *Ctensor, n int64, d float64, optionsKind int32, optionsDevice int32)
• func AtgFftFftfreqOut(ptr *Ctensor, out Ctensor, n int64, d float64)
• func AtgFftFftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
• func AtgFftFftnOut(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, ...)
• func AtgFftFftshift(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int)
• func AtgFftHfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
• func AtgFftHfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, ...)
• func AtgFftIfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
• func AtgFftIfft2(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
• func AtgFftIfft2Out(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, ...)
• func AtgFftIfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, ...)
• func AtgFftIfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
• func AtgFftIfftnOut(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, ...)
• func AtgFftIfftshift(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int)
• func AtgFftIhfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
• func AtgFftIhfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, ...)
• func AtgFftIrfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
• func AtgFftIrfft2(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
• func AtgFftIrfft2Out(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, ...)
• func AtgFftIrfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, ...)
• func AtgFftIrfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
• func AtgFftIrfftnOut(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, ...)
• func AtgFftRfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
• func AtgFftRfft2(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
• func AtgFftRfft2Out(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, ...)
• func AtgFftRfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, ...)
• func AtgFftRfftfreq(ptr *Ctensor, n int64, d float64, optionsKind int32, optionsDevice int32)
• func AtgFftRfftfreqOut(ptr *Ctensor, out Ctensor, n int64, d float64)
• func AtgFftRfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
• func AtgFftRfftnOut(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, ...)
• func AtgFillDiagonal_(ptr *Ctensor, self Ctensor, fillValue Cscalar, wrap int32)
• func AtgFillTensor_(ptr *Ctensor, self Ctensor, value Ctensor)
• func AtgFill_(ptr *Ctensor, self Ctensor, value Cscalar)
• func AtgFix(ptr *Ctensor, self Ctensor)
• func AtgFixOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgFix_(ptr *Ctensor, self Ctensor)
• func AtgFlatten(ptr *Ctensor, self Ctensor, startDim int64, endDim int64)
• func AtgFlattenDenseTensors(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgFlip(ptr *Ctensor, self Ctensor, dimsData []int64, dimsLen int)
• func AtgFliplr(ptr *Ctensor, self Ctensor)
• func AtgFlipud(ptr *Ctensor, self Ctensor)
• func AtgFloatPower(ptr *Ctensor, self Ctensor, exponent Ctensor)
• func AtgFloatPowerScalar(ptr *Ctensor, selfScalar Cscalar, exponent Ctensor)
• func AtgFloatPowerScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, exponent Ctensor)
• func AtgFloatPowerTensorScalar(ptr *Ctensor, self Ctensor, exponent Cscalar)
• func AtgFloatPowerTensorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Cscalar)
• func AtgFloatPowerTensorTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Ctensor)
• func AtgFloatPowerTensor_(ptr *Ctensor, self Ctensor, exponent Ctensor)
• func AtgFloatPower_(ptr *Ctensor, self Ctensor, exponent Cscalar)
• func AtgFloor(ptr *Ctensor, self Ctensor)
• func AtgFloorDivide(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgFloorDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgFloorDivideScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgFloorDivideScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgFloorDivide_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgFloorOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgFloor_(ptr *Ctensor, self Ctensor)
• func AtgFmax(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgFmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgFmin(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgFminOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgFmod(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgFmodScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgFmodTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgFmodTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgFmodTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgFmod_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgFrac(ptr *Ctensor, self Ctensor)
• func AtgFracOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgFrac_(ptr *Ctensor, self Ctensor)
• func AtgFractionalMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgFractionalMaxPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, ...)
• func AtgFractionalMaxPool2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgFractionalMaxPool2dOutput(ptr *Ctensor, output Ctensor, indices Ctensor, self Ctensor, ...)
• func AtgFractionalMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgFractionalMaxPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, ...)
• func AtgFractionalMaxPool3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgFractionalMaxPool3dOutput(ptr *Ctensor, output Ctensor, indices Ctensor, self Ctensor, ...)
• func AtgFrexp(ptr *Ctensor, self Ctensor)
• func AtgFrexpTensorOut(ptr *Ctensor, mantissa Ctensor, exponent Ctensor, self Ctensor)
• func AtgFrobeniusNorm(ptr *Ctensor, self Ctensor)
• func AtgFrobeniusNormDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)
• func AtgFrobeniusNormOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgFromFile(ptr *Ctensor, filename string, shared int32, sizeVal int64, sizeNull int, ...)
• func AtgFull(ptr *Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar, ...)
• func AtgFullLike(ptr *Ctensor, self Ctensor, fillValue Cscalar)
• func AtgFullOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar)
• func AtgFusedMovingAvgObsFakeQuant(ptr *Ctensor, self Ctensor, observerOn Ctensor, fakeQuantOn Ctensor, ...)
• func AtgGather(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, sparseGrad int32)
• func AtgGatherBackward(ptr *Ctensor, grad Ctensor, self Ctensor, dim int64, index Ctensor, ...)
• func AtgGatherOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, ...)
• func AtgGcd(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGcdOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgGcd_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGe(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgGeScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgGeTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGeTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgGeTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGe_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgGelu(ptr *Ctensor, self Ctensor)
• func AtgGeluBackward(ptr *Ctensor, grad Ctensor, self Ctensor)
• func AtgGeluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, grad Ctensor, self Ctensor)
• func AtgGeluOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgGeometric_(ptr *Ctensor, self Ctensor, p float64)
• func AtgGeqrf(ptr *Ctensor, self Ctensor)
• func AtgGeqrfA(ptr *Ctensor, a Ctensor, tau Ctensor, self Ctensor)
• func AtgGer(ptr *Ctensor, self Ctensor, vec2 Ctensor)
• func AtgGerOut(ptr *Ctensor, out Ctensor, self Ctensor, vec2 Ctensor)
• func AtgGlu(ptr *Ctensor, self Ctensor, dim int64)
• func AtgGluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, dim int64)
• func AtgGluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, dim int64)
• func AtgGluOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64)
• func AtgGrad(ptr *Ctensor, self Ctensor)
• func AtgGreater(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgGreaterEqual(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgGreaterEqualScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgGreaterEqualTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGreaterEqualTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgGreaterEqualTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGreaterEqual_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgGreaterScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgGreaterTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGreaterTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgGreaterTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGreater_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgGridSampler(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, ...)
• func AtgGridSampler2d(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, ...)
• func AtgGridSampler2dBackward(ptr *Ctensor, gradOutput Ctensor, input Ctensor, grid Ctensor, ...)
• func AtgGridSampler3d(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, ...)
• func AtgGridSampler3dBackward(ptr *Ctensor, gradOutput Ctensor, input Ctensor, grid Ctensor, ...)
• func AtgGroupNorm(ptr *Ctensor, input Ctensor, numGroups int64, weight Ctensor, bias Ctensor, ...)
• func AtgGru(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, ...)
• func AtgGruCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, ...)
• func AtgGruData(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, ...)
• func AtgGt(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgGtScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgGtTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGtTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgGtTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgGt_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgHammingWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)
• func AtgHammingWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, ...)
• func AtgHammingWindowPeriodicAlpha(ptr *Ctensor, windowLength int64, periodic int32, alpha float64, ...)
• func AtgHammingWindowPeriodicAlphaBeta(ptr *Ctensor, windowLength int64, periodic int32, alpha float64, beta float64, ...)
• func AtgHannWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)
• func AtgHannWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, ...)
• func AtgHardshrink(ptr *Ctensor, self Ctensor)
• func AtgHardshrinkBackward(ptr *Ctensor, gradOut Ctensor, self Ctensor, lambd Cscalar)
• func AtgHardshrinkBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOut Ctensor, self Ctensor, lambd Cscalar)
• func AtgHardshrinkOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgHardsigmoid(ptr *Ctensor, self Ctensor)
• func AtgHardsigmoidBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)
• func AtgHardsigmoidBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor)
• func AtgHardsigmoidOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgHardsigmoid_(ptr *Ctensor, self Ctensor)
• func AtgHardswish(ptr *Ctensor, self Ctensor)
• func AtgHardswishBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)
• func AtgHardswishOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgHardswish_(ptr *Ctensor, self Ctensor)
• func AtgHardtanh(ptr *Ctensor, self Ctensor)
• func AtgHardtanhBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, minVal Cscalar, maxVal Cscalar)
• func AtgHardtanhBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgHardtanhOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgHardtanh_(ptr *Ctensor, self Ctensor)
• func AtgHeaviside(ptr *Ctensor, self Ctensor, values Ctensor)
• func AtgHeavisideOut(ptr *Ctensor, out Ctensor, self Ctensor, values Ctensor)
• func AtgHeaviside_(ptr *Ctensor, self Ctensor, values Ctensor)
• func AtgHingeEmbeddingLoss(ptr *Ctensor, self Ctensor, target Ctensor, margin float64, reduction int64)
• func AtgHistc(ptr *Ctensor, self Ctensor, bins int64)
• func AtgHistcOut(ptr *Ctensor, out Ctensor, self Ctensor, bins int64)
• func AtgHspmm(ptr *Ctensor, mat1 Ctensor, mat2 Ctensor)
• func AtgHspmmOut(ptr *Ctensor, out Ctensor, mat1 Ctensor, mat2 Ctensor)
• func AtgHstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgHstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgHuberLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64, delta float64)
• func AtgHuberLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, ...)
• func AtgHuberLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgHuberLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64, ...)
• func AtgHypot(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgHypotOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgHypot_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgI0(ptr *Ctensor, self Ctensor)
• func AtgI0Out(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgI0_(ptr *Ctensor, self Ctensor)
• func AtgIgamma(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgIgammaOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgIgamma_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgIgammac(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgIgammacOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgIgammac_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgIm2col(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgIm2colBackward(ptr *Ctensor, gradOutput Ctensor, inputSizeData []int64, inputSizeLen int, ...)
• func AtgIm2colBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, inputSizeData []int64, ...)
• func AtgIm2colOut(ptr *Ctensor, out Ctensor, self Ctensor, kernelSizeData []int64, ...)
• func AtgImag(ptr *Ctensor, self Ctensor)
• func AtgIndex(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int)
• func AtgIndexAdd(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)
• func AtgIndexAddAlpha(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor, ...)
• func AtgIndexAddAlpha_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor, ...)
• func AtgIndexAdd_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)
• func AtgIndexCopy(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)
• func AtgIndexCopy_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)
• func AtgIndexFill(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)
• func AtgIndexFillIntTensor(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Ctensor)
• func AtgIndexFillIntTensor_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Ctensor)
• func AtgIndexFill_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)
• func AtgIndexPut(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, ...)
• func AtgIndexPut_(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, ...)
• func AtgIndexSelect(ptr *Ctensor, self Ctensor, dim int64, index Ctensor)
• func AtgIndexSelectBackward(ptr *Ctensor, grad Ctensor, selfSizesData []int64, selfSizesLen int, dim int64, ...)
• func AtgIndexSelectOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor)
• func AtgIndices(ptr *Ctensor, self Ctensor)
• func AtgInfinitelyDifferentiableGeluBackward(ptr *Ctensor, grad Ctensor, self Ctensor)
• func AtgInner(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgInnerOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgInstanceNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, ...)
• func AtgIntRepr(ptr *Ctensor, self Ctensor)
• func AtgInverse(ptr *Ctensor, self Ctensor)
• func AtgInverseOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgIsCoalesced(self Ctensor) bool
• func AtgIsComplex(self Ctensor) bool
• func AtgIsConj(self Ctensor) bool
• func AtgIsDistributed(self Ctensor) bool
• func AtgIsFloatingPoint(self Ctensor) bool
• func AtgIsInference(self Ctensor) bool
• func AtgIsLeaf(self Ctensor) bool
• func AtgIsNeg(self Ctensor) bool
• func AtgIsNonzero(self Ctensor) bool
• func AtgIsPinned(self Ctensor, device int32) bool
• func AtgIsSameSize(self Ctensor, other Ctensor) bool
• func AtgIsSetTo(self Ctensor, tensor Ctensor) bool
• func AtgIsSigned(self Ctensor) bool
• func AtgIsVulkanAvailable() bool
• func AtgIsclose(ptr *Ctensor, self Ctensor, other Ctensor, rtol float64, atol float64, ...)
• func AtgIsfinite(ptr *Ctensor, self Ctensor)
• func AtgIsin(ptr *Ctensor, elements Ctensor, testElements Ctensor, assumeUnique int32, ...)
• func AtgIsinScalarTensor(ptr *Ctensor, element Cscalar, testElements Ctensor, assumeUnique int32, ...)
• func AtgIsinScalarTensorOut(ptr *Ctensor, out Ctensor, element Cscalar, testElements Ctensor, ...)
• func AtgIsinTensorScalar(ptr *Ctensor, elements Ctensor, testElement Cscalar, assumeUnique int32, ...)
• func AtgIsinTensorScalarOut(ptr *Ctensor, out Ctensor, elements Ctensor, testElement Cscalar, ...)
• func AtgIsinTensorTensorOut(ptr *Ctensor, out Ctensor, elements Ctensor, testElements Ctensor, ...)
• func AtgIsinf(ptr *Ctensor, self Ctensor)
• func AtgIsnan(ptr *Ctensor, self Ctensor)
• func AtgIsneginf(ptr *Ctensor, self Ctensor)
• func AtgIsneginfOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgIsposinf(ptr *Ctensor, self Ctensor)
• func AtgIsposinfOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgIsreal(ptr *Ctensor, self Ctensor)
• func AtgIstft(ptr *Ctensor, self Ctensor, nFft int64, hopLengthVal int64, hopLengthNull int, ...)
• func AtgKaiserWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)
• func AtgKaiserWindowBeta(ptr *Ctensor, windowLength int64, periodic int32, beta float64, ...)
• func AtgKaiserWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, ...)
• func AtgKlDiv(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64, logTarget int32)
• func AtgKlDivBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, ...)
• func AtgKron(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgKronOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgKthvalue(ptr *Ctensor, self Ctensor, k int64, dim int64, keepdim int32)
• func AtgKthvalueValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, k int64, ...)
• func AtgL1Loss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64)
• func AtgL1LossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, ...)
• func AtgL1LossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgL1LossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64)
• func AtgLayerNorm(ptr *Ctensor, input Ctensor, normalizedShapeData []int64, ...)
• func AtgLcm(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLcmOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLcm_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLdexp(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLdexpOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLdexp_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLe(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgLeScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgLeTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLeTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLeTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLe_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgLeakyRelu(ptr *Ctensor, self Ctensor)
• func AtgLeakyReluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, negativeSlope Cscalar, ...)
• func AtgLeakyReluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgLeakyReluOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLeakyRelu_(ptr *Ctensor, self Ctensor)
• func AtgLerp(ptr *Ctensor, self Ctensor, end Ctensor, weight Cscalar)
• func AtgLerpScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, end Ctensor, weight Cscalar)
• func AtgLerpTensor(ptr *Ctensor, self Ctensor, end Ctensor, weight Ctensor)
• func AtgLerpTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, end Ctensor, weight Ctensor)
• func AtgLerpTensor_(ptr *Ctensor, self Ctensor, end Ctensor, weight Ctensor)
• func AtgLerp_(ptr *Ctensor, self Ctensor, end Ctensor, weight Cscalar)
• func AtgLess(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgLessEqual(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgLessEqualScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgLessEqualTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLessEqualTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLessEqualTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLessEqual_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgLessScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgLessTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLessTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLessTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLess_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgLgamma(ptr *Ctensor, self Ctensor)
• func AtgLgammaOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLgamma_(ptr *Ctensor, self Ctensor)
• func AtgLinalgCholesky(ptr *Ctensor, self Ctensor, upper int32)
• func AtgLinalgCholeskyEx(ptr *Ctensor, self Ctensor, upper int32, checkErrors int32)
• func AtgLinalgCholeskyExL(ptr *Ctensor, l Ctensor, info Ctensor, self Ctensor, upper int32, ...)
• func AtgLinalgCholeskyOut(ptr *Ctensor, out Ctensor, self Ctensor, upper int32)
• func AtgLinalgCond(ptr *Ctensor, self Ctensor, p Cscalar)
• func AtgLinalgCondOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar)
• func AtgLinalgCondPStr(ptr *Ctensor, self Ctensor, p string)
• func AtgLinalgCondPStrOut(ptr *Ctensor, out Ctensor, self Ctensor, p string)
• func AtgLinalgDet(ptr *Ctensor, self Ctensor)
• func AtgLinalgDetOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLinalgEig(ptr *Ctensor, self Ctensor)
• func AtgLinalgEigOut(ptr *Ctensor, eigenvalues Ctensor, eigenvectors Ctensor, self Ctensor)
• func AtgLinalgEigh(ptr *Ctensor, self Ctensor, uPLO string)
• func AtgLinalgEighEigvals(ptr *Ctensor, eigvals Ctensor, eigvecs Ctensor, self Ctensor, uPLO string)
• func AtgLinalgEigvals(ptr *Ctensor, self Ctensor)
• func AtgLinalgEigvalsOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLinalgEigvalsh(ptr *Ctensor, self Ctensor, uPLO string)
• func AtgLinalgEigvalshOut(ptr *Ctensor, out Ctensor, self Ctensor, uPLO string)
• func AtgLinalgHouseholderProduct(ptr *Ctensor, input Ctensor, tau Ctensor)
• func AtgLinalgHouseholderProductOut(ptr *Ctensor, out Ctensor, input Ctensor, tau Ctensor)
• func AtgLinalgInv(ptr *Ctensor, self Ctensor)
• func AtgLinalgInvEx(ptr *Ctensor, self Ctensor, checkErrors int32)
• func AtgLinalgInvExInverse(ptr *Ctensor, inverse Ctensor, info Ctensor, self Ctensor, checkErrors int32)
• func AtgLinalgInvOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLinalgLstsq(ptr *Ctensor, self Ctensor, b Ctensor, rcondVal float64, rcondNull int, ...)
• func AtgLinalgLstsqOut(ptr *Ctensor, solution Ctensor, residuals Ctensor, rank Ctensor, ...)
• func AtgLinalgMatmul(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLinalgMatmulOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLinalgMatrixPower(ptr *Ctensor, self Ctensor, n int64)
• func AtgLinalgMatrixPowerOut(ptr *Ctensor, out Ctensor, self Ctensor, n int64)
• func AtgLinalgMatrixRank(ptr *Ctensor, self Ctensor, tolVal float64, tolNull int, hermitian int32)
• func AtgLinalgMatrixRankOut(ptr *Ctensor, out Ctensor, self Ctensor, tolVal float64, tolNull int, ...)
• func AtgLinalgMatrixRankOutTolTensor(ptr *Ctensor, out Ctensor, input Ctensor, tol Ctensor, hermitian int32)
• func AtgLinalgMatrixRankTolTensor(ptr *Ctensor, input Ctensor, tol Ctensor, hermitian int32)
• func AtgLinalgMultiDot(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgLinalgMultiDotOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgLinalgNorm(ptr *Ctensor, self Ctensor, ord Cscalar, dimData []int64, dimLen int, ...)
• func AtgLinalgNormOrdStr(ptr *Ctensor, self Ctensor, ord string, dimData []int64, dimLen int, ...)
• func AtgLinalgNormOrdStrOut(ptr *Ctensor, out Ctensor, self Ctensor, ord string, dimData []int64, ...)
• func AtgLinalgNormOut(ptr *Ctensor, out Ctensor, self Ctensor, ord Cscalar, dimData []int64, ...)
• func AtgLinalgPinv(ptr *Ctensor, self Ctensor, rcond float64, hermitian int32)
• func AtgLinalgPinvOut(ptr *Ctensor, out Ctensor, self Ctensor, rcond float64, hermitian int32)
• func AtgLinalgPinvOutRcondTensor(ptr *Ctensor, out Ctensor, self Ctensor, rcond Ctensor, hermitian int32)
• func AtgLinalgPinvRcondTensor(ptr *Ctensor, self Ctensor, rcond Ctensor, hermitian int32)
• func AtgLinalgQr(ptr *Ctensor, self Ctensor, mode string)
• func AtgLinalgQrOut(ptr *Ctensor, q Ctensor, r Ctensor, self Ctensor, mode string)
• func AtgLinalgSlogdet(ptr *Ctensor, self Ctensor)
• func AtgLinalgSlogdetOut(ptr *Ctensor, sign Ctensor, logabsdet Ctensor, self Ctensor)
• func AtgLinalgSolve(ptr *Ctensor, input Ctensor, other Ctensor)
• func AtgLinalgSolveOut(ptr *Ctensor, out Ctensor, input Ctensor, other Ctensor)
• func AtgLinalgSvd(ptr *Ctensor, self Ctensor, fullMatrices int32)
• func AtgLinalgSvdU(ptr *Ctensor, u Ctensor, s Ctensor, vh Ctensor, self Ctensor, ...)
• func AtgLinalgSvdvals(ptr *Ctensor, input Ctensor)
• func AtgLinalgSvdvalsOut(ptr *Ctensor, out Ctensor, input Ctensor)
• func AtgLinalgTensorinv(ptr *Ctensor, self Ctensor, ind int64)
• func AtgLinalgTensorinvOut(ptr *Ctensor, out Ctensor, self Ctensor, ind int64)
• func AtgLinalgTensorsolve(ptr *Ctensor, self Ctensor, other Ctensor, dimsData []int64, dimsLen int)
• func AtgLinalgTensorsolveOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, dimsData []int64, ...)
• func AtgLinear(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor)
• func AtgLinearOut(ptr *Ctensor, out Ctensor, input Ctensor, weight Ctensor, bias Ctensor)
• func AtgLinspace(ptr *Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int, ...)
• func AtgLinspaceOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar, stepsVal int64, ...)
• func AtgLog(ptr *Ctensor, self Ctensor)
• func AtgLog10(ptr *Ctensor, self Ctensor)
• func AtgLog10Out(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLog10_(ptr *Ctensor, self Ctensor)
• func AtgLog1p(ptr *Ctensor, self Ctensor)
• func AtgLog1pOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLog1p_(ptr *Ctensor, self Ctensor)
• func AtgLog2(ptr *Ctensor, self Ctensor)
• func AtgLog2Out(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLog2_(ptr *Ctensor, self Ctensor)
• func AtgLogNormal_(ptr *Ctensor, self Ctensor, mean float64, std float64)
• func AtgLogOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLogSigmoid(ptr *Ctensor, self Ctensor)
• func AtgLogSigmoidBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, buffer Ctensor)
• func AtgLogSigmoidBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgLogSigmoidOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLogSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
• func AtgLog_(ptr *Ctensor, self Ctensor)
• func AtgLogaddexp(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLogaddexp2(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLogaddexp2Out(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLogaddexpOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLogcumsumexp(ptr *Ctensor, self Ctensor, dim int64)
• func AtgLogcumsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64)
• func AtgLogdet(ptr *Ctensor, self Ctensor)
• func AtgLogicalAnd(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLogicalAndOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLogicalAnd_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLogicalNot(ptr *Ctensor, self Ctensor)
• func AtgLogicalNotOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgLogicalNot_(ptr *Ctensor, self Ctensor)
• func AtgLogicalOr(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLogicalOrOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLogicalOr_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLogicalXor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLogicalXorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLogicalXor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLogit(ptr *Ctensor, self Ctensor, epsVal float64, epsNull int)
• func AtgLogitBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, epsVal float64, epsNull int)
• func AtgLogitBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgLogitOut(ptr *Ctensor, out Ctensor, self Ctensor, epsVal float64, epsNull int)
• func AtgLogit_(ptr *Ctensor, self Ctensor, epsVal float64, epsNull int)
• func AtgLogspace(ptr *Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int, ...)
• func AtgLogspaceOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar, stepsVal int64, ...)
• func AtgLogsumexp(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)
• func AtgLogsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgLstm(ptr *Ctensor, input Ctensor, hxData []Ctensor, hxLen int, paramsData []Ctensor, ...)
• func AtgLstmCell(ptr *Ctensor, input Ctensor, hxData []Ctensor, hxLen int, wIh Ctensor, ...)
• func AtgLstmData(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hxData []Ctensor, hxLen int, ...)
• func AtgLstsq(ptr *Ctensor, self Ctensor, a Ctensor)
• func AtgLstsqX(ptr *Ctensor, x Ctensor, qr Ctensor, self Ctensor, a Ctensor)
• func AtgLt(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgLtScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgLtTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLtTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgLtTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgLt_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgLuSolve(ptr *Ctensor, self Ctensor, lUData Ctensor, lUPivots Ctensor)
• func AtgLuSolveOut(ptr *Ctensor, out Ctensor, self Ctensor, lUData Ctensor, lUPivots Ctensor)
• func AtgLuUnpack(ptr *Ctensor, lUData Ctensor, lUPivots Ctensor, unpackData int32, ...)
• func AtgLuUnpackOut(ptr *Ctensor, p Ctensor, l Ctensor, u Ctensor, lUData Ctensor, ...)
• func AtgMarginRankingLoss(ptr *Ctensor, input1 Ctensor, input2 Ctensor, target Ctensor, margin float64, ...)
• func AtgMaskedFill(ptr *Ctensor, self Ctensor, mask Ctensor, value Cscalar)
• func AtgMaskedFillTensor(ptr *Ctensor, self Ctensor, mask Ctensor, value Ctensor)
• func AtgMaskedFillTensor_(ptr *Ctensor, self Ctensor, mask Ctensor, value Ctensor)
• func AtgMaskedFill_(ptr *Ctensor, self Ctensor, mask Ctensor, value Cscalar)
• func AtgMaskedScatter(ptr *Ctensor, self Ctensor, mask Ctensor, source Ctensor)
• func AtgMaskedScatter_(ptr *Ctensor, self Ctensor, mask Ctensor, source Ctensor)
• func AtgMaskedSelect(ptr *Ctensor, self Ctensor, mask Ctensor)
• func AtgMaskedSelectBackward(ptr *Ctensor, grad Ctensor, input Ctensor, mask Ctensor)
• func AtgMaskedSelectOut(ptr *Ctensor, out Ctensor, self Ctensor, mask Ctensor)
• func AtgMatmul(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgMatmulOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgMatrixExp(ptr *Ctensor, self Ctensor)
• func AtgMatrixExpBackward(ptr *Ctensor, self Ctensor, grad Ctensor)
• func AtgMatrixPower(ptr *Ctensor, self Ctensor, n int64)
• func AtgMatrixPowerOut(ptr *Ctensor, out Ctensor, self Ctensor, n int64)
• func AtgMatrixRank(ptr *Ctensor, self Ctensor, symmetric int32)
• func AtgMatrixRankTol(ptr *Ctensor, self Ctensor, tol float64, symmetric int32)
• func AtgMax(ptr *Ctensor, self Ctensor)
• func AtgMaxDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
• func AtgMaxDimMax(ptr *Ctensor, max Ctensor, maxValues Ctensor, self Ctensor, dim int64, ...)
• func AtgMaxOther(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgMaxOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgMaxPool1d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgMaxPool1dWithIndices(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgMaxPool2dWithIndices(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgMaxPool2dWithIndicesBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, ...)
• func AtgMaxPool2dWithIndicesBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgMaxPool2dWithIndicesOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, ...)
• func AtgMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgMaxPool3dWithIndices(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgMaxPool3dWithIndicesBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, ...)
• func AtgMaxPool3dWithIndicesBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgMaxPool3dWithIndicesOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, ...)
• func AtgMaxUnpool2d(ptr *Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, ...)
• func AtgMaxUnpool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, ...)
• func AtgMaxUnpool2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgMaxUnpool2dOut(ptr *Ctensor, out Ctensor, self Ctensor, indices Ctensor, ...)
• func AtgMaxUnpool3d(ptr *Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, ...)
• func AtgMaxUnpool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, ...)
• func AtgMaxUnpool3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgMaxUnpool3dOut(ptr *Ctensor, out Ctensor, self Ctensor, indices Ctensor, ...)
• func AtgMaximum(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgMaximumOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgMean(ptr *Ctensor, self Ctensor, dtype int32)
• func AtgMeanDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, ...)
• func AtgMeanOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgMedian(ptr *Ctensor, self Ctensor)
• func AtgMedianDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
• func AtgMedianDimValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, ...)
• func AtgMin(ptr *Ctensor, self Ctensor)
• func AtgMinDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
• func AtgMinDimMin(ptr *Ctensor, min Ctensor, minIndices Ctensor, self Ctensor, dim int64, ...)
• func AtgMinOther(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgMinOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgMinimum(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgMinimumOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgMiopenBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, ...)
• func AtgMiopenBatchNormBackward(ptr *Ctensor, input Ctensor, gradOutput Ctensor, weight Ctensor, ...)
• func AtgMiopenConvolution(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, ...)
• func AtgMiopenConvolutionBackwardBias(ptr *Ctensor, gradOutput Ctensor)
• func AtgMiopenConvolutionBackwardInput(ptr *Ctensor, selfSizeData []int64, selfSizeLen int, gradOutput Ctensor, ...)
• func AtgMiopenConvolutionBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, ...)
• func AtgMiopenConvolutionTranspose(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, ...)
• func AtgMiopenConvolutionTransposeBackwardInput(ptr *Ctensor, gradOutput Ctensor, weight Ctensor, paddingData []int64, ...)
• func AtgMiopenConvolutionTransposeBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, ...)
• func AtgMiopenDepthwiseConvolution(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, ...)
• func AtgMiopenDepthwiseConvolutionBackwardInput(ptr *Ctensor, selfSizeData []int64, selfSizeLen int, gradOutput Ctensor, ...)
• func AtgMiopenDepthwiseConvolutionBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, ...)
• func AtgMiopenRnn(ptr *Ctensor, input Ctensor, weightData []Ctensor, weightLen int, ...)
• func AtgMish(ptr *Ctensor, self Ctensor)
• func AtgMishBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)
• func AtgMishOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgMish_(ptr *Ctensor, self Ctensor)
• func AtgMkldnnAdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
• func AtgMkldnnAdaptiveAvgPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)
• func AtgMkldnnConvolution(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, ...)
• func AtgMkldnnConvolutionBackwardInput(ptr *Ctensor, selfSizeData []int64, selfSizeLen int, gradOutput Ctensor, ...)
• func AtgMkldnnConvolutionBackwardWeights(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, ...)
• func AtgMkldnnLinear(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor)
• func AtgMkldnnLinearBackwardInput(ptr *Ctensor, inputSizeData []int64, inputSizeLen int, gradOutput Ctensor, ...)
• func AtgMkldnnLinearBackwardWeights(ptr *Ctensor, gradOutput Ctensor, input Ctensor, weight Ctensor, ...)
• func AtgMkldnnMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgMkldnnMaxPool2dBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor, input Ctensor, ...)
• func AtgMkldnnMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgMkldnnMaxPool3dBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor, input Ctensor, ...)
• func AtgMkldnnReorderConv2dWeight(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int, ...)
• func AtgMkldnnReorderConv3dWeight(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int, ...)
• func AtgMm(ptr *Ctensor, self Ctensor, mat2 Ctensor)
• func AtgMmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor)
• func AtgMode(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
• func AtgModeValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, ...)
• func AtgMoveaxis(ptr *Ctensor, self Ctensor, sourceData []int64, sourceLen int, ...)
• func AtgMoveaxisInt(ptr *Ctensor, self Ctensor, source int64, destination int64)
• func AtgMovedim(ptr *Ctensor, self Ctensor, sourceData []int64, sourceLen int, ...)
• func AtgMovedimInt(ptr *Ctensor, self Ctensor, source int64, destination int64)
• func AtgMseLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64)
• func AtgMseLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, ...)
• func AtgMseLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgMseLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64)
• func AtgMsort(ptr *Ctensor, self Ctensor)
• func AtgMsortOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgMul(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgMulOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgMulScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgMulScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgMul_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgMultiMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, p Cscalar, ...)
• func AtgMultiMarginLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgMultilabelMarginLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64)
• func AtgMultilabelMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, ...)
• func AtgMultilabelMarginLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgMultilabelMarginLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64)
• func AtgMultinomial(ptr *Ctensor, self Ctensor, numSamples int64, replacement int32)
• func AtgMultinomialOut(ptr *Ctensor, out Ctensor, self Ctensor, numSamples int64, replacement int32)
• func AtgMultiply(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgMultiplyOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgMultiplyScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgMultiplyScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgMultiply_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgMv(ptr *Ctensor, self Ctensor, vec Ctensor)
• func AtgMvOut(ptr *Ctensor, out Ctensor, self Ctensor, vec Ctensor)
• func AtgMvlgamma(ptr *Ctensor, self Ctensor, p int64)
• func AtgMvlgammaOut(ptr *Ctensor, out Ctensor, self Ctensor, p int64)
• func AtgMvlgamma_(ptr *Ctensor, self Ctensor, p int64)
• func AtgNanToNum(ptr *Ctensor, self Ctensor, nanVal float64, nanNull int, posinfVal float64, ...)
• func AtgNanToNumOut(ptr *Ctensor, out Ctensor, self Ctensor, nanVal float64, nanNull int, ...)
• func AtgNanToNum_(ptr *Ctensor, self Ctensor, nanVal float64, nanNull int, posinfVal float64, ...)
• func AtgNanmean(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, ...)
• func AtgNanmeanOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgNanmedian(ptr *Ctensor, self Ctensor)
• func AtgNanmedianDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
• func AtgNanmedianDimValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, ...)
• func AtgNanquantile(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
• func AtgNanquantileNew(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
• func AtgNanquantileNewOut(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
• func AtgNanquantileNewScalar(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
• func AtgNanquantileNewScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
• func AtgNanquantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
• func AtgNanquantileScalar(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
• func AtgNanquantileScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
• func AtgNansum(ptr *Ctensor, self Ctensor, dtype int32)
• func AtgNansumDimIntlist(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, ...)
• func AtgNansumIntlistOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgNarrow(ptr *Ctensor, self Ctensor, dim int64, start int64, length int64)
• func AtgNarrowCopy(ptr *Ctensor, self Ctensor, dim int64, start int64, length int64)
• func AtgNarrowCopyOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, start int64, length int64)
• func AtgNarrowTensor(ptr *Ctensor, self Ctensor, dim int64, start Ctensor, length int64)
• func AtgNativeBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, ...)
• func AtgNativeBatchNormOut(ptr *Ctensor, out Ctensor, saveMean Ctensor, saveInvstd Ctensor, input Ctensor, ...)
• func AtgNativeGroupNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, n int64, c int64, ...)
• func AtgNativeLayerNorm(ptr *Ctensor, input Ctensor, normalizedShapeData []int64, ...)
• func AtgNativeNorm(ptr *Ctensor, self Ctensor)
• func AtgNativeNormScalaroptDimDtype(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, ...)
• func AtgNe(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgNeScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgNeTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgNeTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgNeTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgNe_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgNeg(ptr *Ctensor, self Ctensor)
• func AtgNegOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgNeg_(ptr *Ctensor, self Ctensor)
• func AtgNegative(ptr *Ctensor, self Ctensor)
• func AtgNegativeOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgNegative_(ptr *Ctensor, self Ctensor)
• func AtgNewEmpty(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgNewEmptyStrided(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, ...)
• func AtgNewFull(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar, ...)
• func AtgNewOnes(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgNewZeros(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgNextafter(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgNextafterOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgNextafter_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgNllLoss(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ...)
• func AtgNllLoss2d(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ...)
• func AtgNllLoss2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, ...)
• func AtgNllLoss2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgNllLoss2dOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, weight Ctensor, ...)
• func AtgNllLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, ...)
• func AtgNllLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgNllLossNd(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ...)
• func AtgNllLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, weight Ctensor, ...)
• func AtgNonzero(ptr *Ctensor, self Ctensor)
• func AtgNonzeroOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgNorm(ptr *Ctensor, self Ctensor)
• func AtgNormDtypeOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dimData []int64, ...)
• func AtgNormExceptDim(ptr *Ctensor, v Ctensor, pow int64, dim int64)
• func AtgNormOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dimData []int64, ...)
• func AtgNormScalaroptDim(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, ...)
• func AtgNormScalaroptDimDtype(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, ...)
• func AtgNormScalaroptDtype(ptr *Ctensor, self Ctensor, p Cscalar, dtype int32)
• func AtgNormal(ptr *Ctensor, out Ctensor, mean Ctensor, std float64)
• func AtgNormalFloatFloatOut(ptr *Ctensor, out Ctensor, mean float64, std float64, sizeData []int64, ...)
• func AtgNormalFloatTensorOut(ptr *Ctensor, out Ctensor, mean float64, std Ctensor)
• func AtgNormalTensorTensorOut(ptr *Ctensor, out Ctensor, mean Ctensor, std Ctensor)
• func AtgNormal_(ptr *Ctensor, self Ctensor, mean float64, std float64)
• func AtgNotEqual(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgNotEqualScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgNotEqualTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgNotEqualTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgNotEqualTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgNotEqual_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgNuclearNorm(ptr *Ctensor, self Ctensor, keepdim int32)
• func AtgNuclearNormDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)
• func AtgNuclearNormDimOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgNuclearNormOut(ptr *Ctensor, out Ctensor, self Ctensor, keepdim int32)
• func AtgNumpyT(ptr *Ctensor, self Ctensor)
• func AtgOneHot(ptr *Ctensor, self Ctensor, numClasses int64)
• func AtgOnes(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgOnesLike(ptr *Ctensor, self Ctensor)
• func AtgOnesOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)
• func AtgOrgqr(ptr *Ctensor, self Ctensor, input2 Ctensor)
• func AtgOrgqrOut(ptr *Ctensor, out Ctensor, self Ctensor, input2 Ctensor)
• func AtgOrmqr(ptr *Ctensor, self Ctensor, input2 Ctensor, input3 Ctensor, left int32, ...)
• func AtgOrmqrOut(ptr *Ctensor, out Ctensor, self Ctensor, input2 Ctensor, input3 Ctensor, ...)
• func AtgOuter(ptr *Ctensor, self Ctensor, vec2 Ctensor)
• func AtgOuterOut(ptr *Ctensor, out Ctensor, self Ctensor, vec2 Ctensor)
• func AtgOutputNr(self Ctensor) int64
• func AtgPadSequence(ptr *Ctensor, sequencesData []Ctensor, sequencesLen int, batchFirst int32, ...)
• func AtgPairwiseDistance(ptr *Ctensor, x1 Ctensor, x2 Ctensor, p float64, eps float64, keepdim int32)
• func AtgPdist(ptr *Ctensor, self Ctensor, p float64)
• func AtgPermute(ptr *Ctensor, self Ctensor, dimsData []int64, dimsLen int)
• func AtgPinMemory(ptr *Ctensor, self Ctensor, device int32)
• func AtgPinverse(ptr *Ctensor, self Ctensor, rcond float64)
• func AtgPixelShuffle(ptr *Ctensor, self Ctensor, upscaleFactor int64)
• func AtgPixelUnshuffle(ptr *Ctensor, self Ctensor, downscaleFactor int64)
• func AtgPoisson(ptr *Ctensor, self Ctensor)
• func AtgPoissonNllLoss(ptr *Ctensor, input Ctensor, target Ctensor, logInput int32, full int32, ...)
• func AtgPolar(ptr *Ctensor, abs Ctensor, angle Ctensor)
• func AtgPolarOut(ptr *Ctensor, out Ctensor, abs Ctensor, angle Ctensor)
• func AtgPolygamma(ptr *Ctensor, n int64, self Ctensor)
• func AtgPolygammaOut(ptr *Ctensor, out Ctensor, n int64, self Ctensor)
• func AtgPolygamma_(ptr *Ctensor, self Ctensor, n int64)
• func AtgPositive(ptr *Ctensor, self Ctensor)
• func AtgPow(ptr *Ctensor, self Ctensor, exponent Ctensor)
• func AtgPowScalar(ptr *Ctensor, selfScalar Cscalar, exponent Ctensor)
• func AtgPowScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, exponent Ctensor)
• func AtgPowTensorScalar(ptr *Ctensor, self Ctensor, exponent Cscalar)
• func AtgPowTensorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Cscalar)
• func AtgPowTensorTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Ctensor)
• func AtgPowTensor_(ptr *Ctensor, self Ctensor, exponent Ctensor)
• func AtgPow_(ptr *Ctensor, self Ctensor, exponent Cscalar)
• func AtgPrelu(ptr *Ctensor, self Ctensor, weight Ctensor)
• func AtgPreluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, weight Ctensor)
• func AtgProd(ptr *Ctensor, self Ctensor, dtype int32)
• func AtgProdDimInt(ptr *Ctensor, self Ctensor, dim int64, keepdim int32, dtype int32)
• func AtgProdIntOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32, dtype int32)
• func AtgPut(ptr *Ctensor, self Ctensor, index Ctensor, source Ctensor, accumulate int32)
• func AtgPut_(ptr *Ctensor, self Ctensor, index Ctensor, source Ctensor, accumulate int32)
• func AtgQPerChannelAxis(self Ctensor) int64
• func AtgQPerChannelScales(ptr *Ctensor, self Ctensor)
• func AtgQPerChannelZeroPoints(ptr *Ctensor, self Ctensor)
• func AtgQScale(self Ctensor) float64
• func AtgQZeroPoint(self Ctensor) int64
• func AtgQr(ptr *Ctensor, self Ctensor, some int32)
• func AtgQrQ(ptr *Ctensor, q Ctensor, r Ctensor, self Ctensor, some int32)
• func AtgQuantile(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
• func AtgQuantileNew(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
• func AtgQuantileNewOut(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
• func AtgQuantileNewScalar(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
• func AtgQuantileNewScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
• func AtgQuantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
• func AtgQuantileScalar(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
• func AtgQuantileScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
• func AtgQuantizePerChannel(ptr *Ctensor, self Ctensor, scales Ctensor, zeroPoints Ctensor, axis int64, ...)
• func AtgQuantizePerTensor(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64, dtype int32)
• func AtgQuantizePerTensorTensorQparams(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, dtype int32)
• func AtgQuantizedBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, mean Ctensor, ...)
• func AtgQuantizedGruCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, ...)
• func AtgQuantizedLstmCell(ptr *Ctensor, input Ctensor, hxData []Ctensor, hxLen int, wIh Ctensor, ...)
• func AtgQuantizedMaxPool1d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgQuantizedMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
• func AtgQuantizedRnnReluCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, ...)
• func AtgQuantizedRnnTanhCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, ...)
• func AtgRad2deg(ptr *Ctensor, self Ctensor)
• func AtgRad2degOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgRad2deg_(ptr *Ctensor, self Ctensor)
• func AtgRand(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgRandLike(ptr *Ctensor, self Ctensor)
• func AtgRandOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)
• func AtgRandint(ptr *Ctensor, high int64, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgRandintLike(ptr *Ctensor, self Ctensor, high int64)
• func AtgRandintLikeLowDtype(ptr *Ctensor, self Ctensor, low int64, high int64)
• func AtgRandintLow(ptr *Ctensor, low int64, high int64, sizeData []int64, sizeLen int, ...)
• func AtgRandintLowOut(ptr *Ctensor, out Ctensor, low int64, high int64, sizeData []int64, ...)
• func AtgRandintOut(ptr *Ctensor, out Ctensor, high int64, sizeData []int64, sizeLen int)
• func AtgRandn(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgRandnLike(ptr *Ctensor, self Ctensor)
• func AtgRandnOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)
• func AtgRandomFrom_(ptr *Ctensor, self Ctensor, from int64, toVal int64, toNull int)
• func AtgRandomTo_(ptr *Ctensor, self Ctensor, to int64)
• func AtgRandom_(ptr *Ctensor, self Ctensor)
• func AtgRandperm(ptr *Ctensor, n int64, optionsKind int32, optionsDevice int32)
• func AtgRandpermOut(ptr *Ctensor, out Ctensor, n int64)
• func AtgRange(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, ...)
• func AtgRangeOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar)
• func AtgRangeStep(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, ...)
• func AtgRavel(ptr *Ctensor, self Ctensor)
• func AtgReal(ptr *Ctensor, self Ctensor)
• func AtgReciprocal(ptr *Ctensor, self Ctensor)
• func AtgReciprocalOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgReciprocal_(ptr *Ctensor, self Ctensor)
• func AtgReflectionPad1d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReflectionPad1dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, ...)
• func AtgReflectionPad1dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgReflectionPad1dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReflectionPad2d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReflectionPad2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, ...)
• func AtgReflectionPad2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgReflectionPad2dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReflectionPad3d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReflectionPad3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, ...)
• func AtgReflectionPad3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgReflectionPad3dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgRelu(ptr *Ctensor, self Ctensor)
• func AtgRelu6(ptr *Ctensor, self Ctensor)
• func AtgRelu6_(ptr *Ctensor, self Ctensor)
• func AtgRelu_(ptr *Ctensor, self Ctensor)
• func AtgRemainder(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgRemainderScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgRemainderScalarTensor(ptr *Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgRemainderTensor(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgRemainderTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgRemainderTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgRemainder_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgRenorm(ptr *Ctensor, self Ctensor, p Cscalar, dim int64, maxnorm Cscalar)
• func AtgRenormOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dim int64, maxnorm Cscalar)
• func AtgRenorm_(ptr *Ctensor, self Ctensor, p Cscalar, dim int64, maxnorm Cscalar)
• func AtgRepeat(ptr *Ctensor, self Ctensor, repeatsData []int64, repeatsLen int)
• func AtgRepeatInterleave(ptr *Ctensor, repeats Ctensor, outputSizeVal int64, outputSizeNull int)
• func AtgRepeatInterleaveSelfInt(ptr *Ctensor, self Ctensor, repeats int64, dimVal int64, dimNull int, ...)
• func AtgRepeatInterleaveSelfTensor(ptr *Ctensor, self Ctensor, repeats Ctensor, dimVal int64, dimNull int, ...)
• func AtgReplicationPad1d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReplicationPad1dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, ...)
• func AtgReplicationPad1dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgReplicationPad1dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReplicationPad2d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReplicationPad2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, ...)
• func AtgReplicationPad2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgReplicationPad2dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReplicationPad3d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgReplicationPad3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, ...)
• func AtgReplicationPad3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgReplicationPad3dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)
• func AtgRequiresGrad_(ptr *Ctensor, self Ctensor, requiresGrad int32)
• func AtgReshape(ptr *Ctensor, self Ctensor, shapeData []int64, shapeLen int)
• func AtgReshapeAs(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgResizeAsSparse_(ptr *Ctensor, self Ctensor, theTemplate Ctensor)
• func AtgResizeAs_(ptr *Ctensor, self Ctensor, theTemplate Ctensor)
• func AtgResize_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)
• func AtgResolveConj(ptr *Ctensor, self Ctensor)
• func AtgResolveNeg(ptr *Ctensor, self Ctensor)
• func AtgRetainsGrad(self Ctensor) bool
• func AtgRnnRelu(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, ...)
• func AtgRnnReluCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, ...)
• func AtgRnnReluData(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, ...)
• func AtgRnnTanh(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, ...)
• func AtgRnnTanhCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, ...)
• func AtgRnnTanhData(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, ...)
• func AtgRoll(ptr *Ctensor, self Ctensor, shiftsData []int64, shiftsLen int, ...)
• func AtgRot90(ptr *Ctensor, self Ctensor, k int64, dimsData []int64, dimsLen int)
• func AtgRound(ptr *Ctensor, self Ctensor)
• func AtgRoundOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgRound_(ptr *Ctensor, self Ctensor)
• func AtgRowStack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgRowStackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgRrelu(ptr *Ctensor, self Ctensor, training int32)
• func AtgRreluWithNoise(ptr *Ctensor, self Ctensor, noise Ctensor, training int32)
• func AtgRreluWithNoiseBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, noise Ctensor, lower Cscalar, ...)
• func AtgRreluWithNoiseOut(ptr *Ctensor, out Ctensor, self Ctensor, noise Ctensor, training int32)
• func AtgRreluWithNoise_(ptr *Ctensor, self Ctensor, noise Ctensor, training int32)
• func AtgRrelu_(ptr *Ctensor, self Ctensor, training int32)
• func AtgRsqrt(ptr *Ctensor, self Ctensor)
• func AtgRsqrtOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgRsqrt_(ptr *Ctensor, self Ctensor)
• func AtgRsub(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgRsubScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgScalarTensor(ptr *Ctensor, s Cscalar, optionsKind int32, optionsDevice int32)
• func AtgScatter(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)
• func AtgScatterAdd(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)
• func AtgScatterAddOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)
• func AtgScatterAdd_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)
• func AtgScatterReduce(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, ...)
• func AtgScatterReduceOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, ...)
• func AtgScatterReduce_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, ...)
• func AtgScatterSrcOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)
• func AtgScatterValue(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)
• func AtgScatterValueOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, ...)
• func AtgScatterValueReduce(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar, ...)
• func AtgScatterValueReduceOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, ...)
• func AtgScatterValueReduce_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar, ...)
• func AtgScatterValue_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)
• func AtgScatter_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)
• func AtgSearchsorted(ptr *Ctensor, sortedSequence Ctensor, self Ctensor, outInt32 int32, ...)
• func AtgSearchsortedScalar(ptr *Ctensor, sortedSequence Ctensor, selfScalar Cscalar, outInt32 int32, ...)
• func AtgSearchsortedTensorOut(ptr *Ctensor, out Ctensor, sortedSequence Ctensor, self Ctensor, ...)
• func AtgSegmentReduce(ptr *Ctensor, data Ctensor, reduce string, lengths Ctensor, indices Ctensor, ...)
• func AtgSelect(ptr *Ctensor, self Ctensor, dim int64, index int64)
• func AtgSelectBackward(ptr *Ctensor, gradOutput Ctensor, inputSizesData []int64, inputSizesLen int, ...)
• func AtgSelu(ptr *Ctensor, self Ctensor)
• func AtgSelu_(ptr *Ctensor, self Ctensor)
• func AtgSetRequiresGrad(ptr *Ctensor, self Ctensor, r int32)
• func AtgSetSourceTensor_(ptr *Ctensor, self Ctensor, source Ctensor)
• func AtgSet_(ptr *Ctensor, self Ctensor)
• func AtgSgn(ptr *Ctensor, self Ctensor)
• func AtgSgnOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSgn_(ptr *Ctensor, self Ctensor)
• func AtgSigmoid(ptr *Ctensor, self Ctensor)
• func AtgSigmoidBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor)
• func AtgSigmoidBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, output Ctensor)
• func AtgSigmoidOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSigmoid_(ptr *Ctensor, self Ctensor)
• func AtgSign(ptr *Ctensor, self Ctensor)
• func AtgSignOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSign_(ptr *Ctensor, self Ctensor)
• func AtgSignbit(ptr *Ctensor, self Ctensor)
• func AtgSignbitOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSilu(ptr *Ctensor, self Ctensor)
• func AtgSiluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)
• func AtgSiluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor)
• func AtgSiluOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSilu_(ptr *Ctensor, self Ctensor)
• func AtgSin(ptr *Ctensor, self Ctensor)
• func AtgSinOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSin_(ptr *Ctensor, self Ctensor)
• func AtgSinc(ptr *Ctensor, self Ctensor)
• func AtgSincOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSinc_(ptr *Ctensor, self Ctensor)
• func AtgSinh(ptr *Ctensor, self Ctensor)
• func AtgSinhOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSinh_(ptr *Ctensor, self Ctensor)
• func AtgSlice(ptr *Ctensor, self Ctensor, dim int64, startVal int64, startNull int, ...)
• func AtgSliceBackward(ptr *Ctensor, gradOutput Ctensor, inputSizesData []int64, inputSizesLen int, ...)
• func AtgSlogdet(ptr *Ctensor, self Ctensor)
• func AtgSlowConv3d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, ...)
• func AtgSlowConv3dOut(ptr *Ctensor, out Ctensor, self Ctensor, weight Ctensor, ...)
• func AtgSlowConvDilated2d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, ...)
• func AtgSlowConvDilated3d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, ...)
• func AtgSlowConvTranspose2d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, ...)
• func AtgSlowConvTranspose2dOut(ptr *Ctensor, out Ctensor, self Ctensor, weight Ctensor, ...)
• func AtgSlowConvTranspose3d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, ...)
• func AtgSlowConvTranspose3dOut(ptr *Ctensor, out Ctensor, self Ctensor, weight Ctensor, ...)
• func AtgSmm(ptr *Ctensor, self Ctensor, mat2 Ctensor)
• func AtgSmoothL1Loss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64, beta float64)
• func AtgSmoothL1LossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, ...)
• func AtgSmoothL1LossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgSmoothL1LossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64, ...)
• func AtgSoftMarginLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64)
• func AtgSoftMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, ...)
• func AtgSoftMarginLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgSoftMarginLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64)
• func AtgSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
• func AtgSoftplus(ptr *Ctensor, self Ctensor)
• func AtgSoftplusBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, beta Cscalar, ...)
• func AtgSoftplusBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgSoftplusOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSoftshrink(ptr *Ctensor, self Ctensor)
• func AtgSoftshrinkBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, lambd Cscalar)
• func AtgSoftshrinkBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgSoftshrinkOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSolve(ptr *Ctensor, self Ctensor, a Ctensor)
• func AtgSolveSolution(ptr *Ctensor, solution Ctensor, lu Ctensor, self Ctensor, a Ctensor)
• func AtgSort(ptr *Ctensor, self Ctensor, dim int64, descending int32)
• func AtgSortStable(ptr *Ctensor, self Ctensor, stable int32, dim int64, descending int32)
• func AtgSortValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, ...)
• func AtgSortValuesStable(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, stable int32, ...)
• func AtgSparseCooTensor(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgSparseCooTensorIndices(ptr *Ctensor, indices Ctensor, values Ctensor, optionsKind int32, ...)
• func AtgSparseCooTensorIndicesSize(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, ...)
• func AtgSparseCsrTensor(ptr *Ctensor, crowIndices Ctensor, colIndices Ctensor, values Ctensor, ...)
• func AtgSparseCsrTensorCrowColValueSize(ptr *Ctensor, crowIndices Ctensor, colIndices Ctensor, values Ctensor, ...)
• func AtgSparseDim(self Ctensor) int64
• func AtgSparseMask(ptr *Ctensor, self Ctensor, mask Ctensor)
• func AtgSparseResizeAndClear_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, sparseDim int64, ...)
• func AtgSparseResize_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, sparseDim int64, ...)
• func AtgSpecialDigamma(ptr *Ctensor, self Ctensor)
• func AtgSpecialDigammaOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialEntr(ptr *Ctensor, self Ctensor)
• func AtgSpecialEntrOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialErf(ptr *Ctensor, self Ctensor)
• func AtgSpecialErfOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialErfc(ptr *Ctensor, self Ctensor)
• func AtgSpecialErfcOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialErfcx(ptr *Ctensor, self Ctensor)
• func AtgSpecialErfcxOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialErfinv(ptr *Ctensor, self Ctensor)
• func AtgSpecialErfinvOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialExp2(ptr *Ctensor, self Ctensor)
• func AtgSpecialExp2Out(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialExpit(ptr *Ctensor, self Ctensor)
• func AtgSpecialExpitOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialExpm1(ptr *Ctensor, self Ctensor)
• func AtgSpecialExpm1Out(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialGammainc(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialGammaincOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialGammaincc(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialGammainccOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialGammaln(ptr *Ctensor, self Ctensor)
• func AtgSpecialGammalnOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialI0(ptr *Ctensor, self Ctensor)
• func AtgSpecialI0Out(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialI0e(ptr *Ctensor, self Ctensor)
• func AtgSpecialI0eOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialI1(ptr *Ctensor, self Ctensor)
• func AtgSpecialI1Out(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialI1e(ptr *Ctensor, self Ctensor)
• func AtgSpecialI1eOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialLog1p(ptr *Ctensor, self Ctensor)
• func AtgSpecialLog1pOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialLogSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
• func AtgSpecialLogit(ptr *Ctensor, self Ctensor, epsVal float64, epsNull int)
• func AtgSpecialLogitOut(ptr *Ctensor, out Ctensor, self Ctensor, epsVal float64, epsNull int)
• func AtgSpecialLogsumexp(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)
• func AtgSpecialLogsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgSpecialMultigammaln(ptr *Ctensor, self Ctensor, p int64)
• func AtgSpecialMultigammalnOut(ptr *Ctensor, out Ctensor, self Ctensor, p int64)
• func AtgSpecialNdtr(ptr *Ctensor, self Ctensor)
• func AtgSpecialNdtrOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialNdtri(ptr *Ctensor, self Ctensor)
• func AtgSpecialNdtriOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialPolygamma(ptr *Ctensor, n int64, self Ctensor)
• func AtgSpecialPolygammaOut(ptr *Ctensor, out Ctensor, n int64, self Ctensor)
• func AtgSpecialPsi(ptr *Ctensor, self Ctensor)
• func AtgSpecialPsiOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialRound(ptr *Ctensor, self Ctensor)
• func AtgSpecialRoundOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialSinc(ptr *Ctensor, self Ctensor)
• func AtgSpecialSincOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSpecialXlog1py(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialXlog1pyOtherScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgSpecialXlog1pyOtherScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgSpecialXlog1pyOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialXlog1pySelfScalar(ptr *Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgSpecialXlog1pySelfScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgSpecialXlogy(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialXlogyOtherScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgSpecialXlogyOtherScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgSpecialXlogyOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialXlogySelfScalar(ptr *Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgSpecialXlogySelfScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgSpecialZeta(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialZetaOtherScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgSpecialZetaOtherScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgSpecialZetaOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgSpecialZetaSelfScalar(ptr *Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgSpecialZetaSelfScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgSqrt(ptr *Ctensor, self Ctensor)
• func AtgSqrtOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSqrt_(ptr *Ctensor, self Ctensor)
• func AtgSquare(ptr *Ctensor, self Ctensor)
• func AtgSquareOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgSquare_(ptr *Ctensor, self Ctensor)
• func AtgSqueeze(ptr *Ctensor, self Ctensor)
• func AtgSqueezeDim(ptr *Ctensor, self Ctensor, dim int64)
• func AtgSqueezeDim_(ptr *Ctensor, self Ctensor, dim int64)
• func AtgSqueeze_(ptr *Ctensor, self Ctensor)
• func AtgSspaddmm(ptr *Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)
• func AtgSspaddmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)
• func AtgStack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func AtgStackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func AtgStd(ptr *Ctensor, self Ctensor, unbiased int32)
• func AtgStdCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, ...)
• func AtgStdCorrectionOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgStdDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, ...)
• func AtgStdMean(ptr *Ctensor, self Ctensor, unbiased int32)
• func AtgStdMeanCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, ...)
• func AtgStdMeanDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, ...)
• func AtgStdOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgStft(ptr *Ctensor, self Ctensor, nFft int64, hopLengthVal int64, hopLengthNull int, ...)
• func AtgSub(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgSubOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgSubScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgSubScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgSub_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgSubtract(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgSubtractOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgSubtractScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgSubtractScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgSubtract_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgSum(ptr *Ctensor, self Ctensor, dtype int32)
• func AtgSumDimIntlist(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, ...)
• func AtgSumIntlistOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgSumToSize(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)
• func AtgSvd(ptr *Ctensor, self Ctensor, some int32, computeUv int32)
• func AtgSvdU(ptr *Ctensor, u Ctensor, s Ctensor, v Ctensor, self Ctensor, some int32, ...)
• func AtgSwapaxes(ptr *Ctensor, self Ctensor, axis0 int64, axis1 int64)
• func AtgSwapaxes_(ptr *Ctensor, self Ctensor, axis0 int64, axis1 int64)
• func AtgSwapdims(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)
• func AtgSwapdims_(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)
• func AtgSymeig(ptr *Ctensor, self Ctensor, eigenvectors int32, upper int32)
• func AtgSymeigE(ptr *Ctensor, e Ctensor, v Ctensor, self Ctensor, eigenvectors int32, ...)
• func AtgT(ptr *Ctensor, self Ctensor)
• func AtgT_(ptr *Ctensor, self Ctensor)
• func AtgTake(ptr *Ctensor, self Ctensor, index Ctensor)
• func AtgTakeAlongDim(ptr *Ctensor, self Ctensor, indices Ctensor, dimVal int64, dimNull int)
• func AtgTakeAlongDimOut(ptr *Ctensor, out Ctensor, self Ctensor, indices Ctensor, dimVal int64, ...)
• func AtgTakeOut(ptr *Ctensor, out Ctensor, self Ctensor, index Ctensor)
• func AtgTan(ptr *Ctensor, self Ctensor)
• func AtgTanOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgTan_(ptr *Ctensor, self Ctensor)
• func AtgTanh(ptr *Ctensor, self Ctensor)
• func AtgTanhBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor)
• func AtgTanhBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, output Ctensor)
• func AtgTanhOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgTanh_(ptr *Ctensor, self Ctensor)
• func AtgTensordot(ptr *Ctensor, self Ctensor, other Ctensor, dimsSelfData []int64, ...)
• func AtgTensordotOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, dimsSelfData []int64, ...)
• func AtgThreshold(ptr *Ctensor, self Ctensor, threshold Cscalar, value Cscalar)
• func AtgThresholdBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, threshold Cscalar)
• func AtgThresholdBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
• func AtgThresholdOut(ptr *Ctensor, out Ctensor, self Ctensor, threshold Cscalar, value Cscalar)
• func AtgThreshold_(ptr *Ctensor, self Ctensor, threshold Cscalar, value Cscalar)
• func AtgTile(ptr *Ctensor, self Ctensor, dimsData []int64, dimsLen int)
• func AtgTo(ptr *Ctensor, self Ctensor, device int32)
• func AtgToDense(ptr *Ctensor, self Ctensor, dtype int32)
• func AtgToDenseBackward(ptr *Ctensor, grad Ctensor, input Ctensor)
• func AtgToDevice(ptr *Ctensor, self Ctensor, device int32, dtype int32, nonBlocking int32, ...)
• func AtgToDtype(ptr *Ctensor, self Ctensor, dtype int32, nonBlocking int32, copy int32)
• func AtgToDtypeLayout(ptr *Ctensor, self Ctensor, optionsKind int32, optionsDevice int32, ...)
• func AtgToMkldnn(ptr *Ctensor, self Ctensor, dtype int32)
• func AtgToMkldnnBackward(ptr *Ctensor, grad Ctensor, input Ctensor)
• func AtgToOther(ptr *Ctensor, self Ctensor, other Ctensor, nonBlocking int32, copy int32)
• func AtgToSparse(ptr *Ctensor, self Ctensor)
• func AtgToSparseSparseDim(ptr *Ctensor, self Ctensor, sparseDim int64)
• func AtgTopk(ptr *Ctensor, self Ctensor, k int64, dim int64, largest int32, sorted int32)
• func AtgTopkValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, k int64, ...)
• func AtgTotype(ptr *Ctensor, self Ctensor, scalarType int32)
• func AtgTrace(ptr *Ctensor, self Ctensor)
• func AtgTraceBackward(ptr *Ctensor, grad Ctensor, sizesData []int64, sizesLen int)
• func AtgTranspose(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)
• func AtgTranspose_(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)
• func AtgTrapezoid(ptr *Ctensor, y Ctensor, dim int64)
• func AtgTrapezoidX(ptr *Ctensor, y Ctensor, x Ctensor, dim int64)
• func AtgTrapz(ptr *Ctensor, y Ctensor, x Ctensor, dim int64)
• func AtgTrapzDx(ptr *Ctensor, y Ctensor, dx float64, dim int64)
• func AtgTriangularSolve(ptr *Ctensor, self Ctensor, a Ctensor, upper int32, transpose int32, ...)
• func AtgTriangularSolveX(ptr *Ctensor, x Ctensor, m Ctensor, self Ctensor, a Ctensor, upper int32, ...)
• func AtgTril(ptr *Ctensor, self Ctensor, diagonal int64)
• func AtgTrilIndices(ptr *Ctensor, row int64, col int64, offset int64, optionsKind int32, ...)
• func AtgTrilOut(ptr *Ctensor, out Ctensor, self Ctensor, diagonal int64)
• func AtgTril_(ptr *Ctensor, self Ctensor, diagonal int64)
• func AtgTripletMarginLoss(ptr *Ctensor, anchor Ctensor, positive Ctensor, negative Ctensor, ...)
• func AtgTriu(ptr *Ctensor, self Ctensor, diagonal int64)
• func AtgTriuIndices(ptr *Ctensor, row int64, col int64, offset int64, optionsKind int32, ...)
• func AtgTriuOut(ptr *Ctensor, out Ctensor, self Ctensor, diagonal int64)
• func AtgTriu_(ptr *Ctensor, self Ctensor, diagonal int64)
• func AtgTrueDivide(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgTrueDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgTrueDivideScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgTrueDivideScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgTrueDivide_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgTrunc(ptr *Ctensor, self Ctensor)
• func AtgTruncOut(ptr *Ctensor, out Ctensor, self Ctensor)
• func AtgTrunc_(ptr *Ctensor, self Ctensor)
• func AtgTypeAs(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgUnflatten(ptr *Ctensor, self Ctensor, dim int64, sizesData []int64, sizesLen int)
• func AtgUnfold(ptr *Ctensor, self Ctensor, dimension int64, size int64, step int64)
• func AtgUnfoldBackward(ptr *Ctensor, gradIn Ctensor, inputSizesData []int64, inputSizesLen int, ...)
• func AtgUniform_(ptr *Ctensor, self Ctensor, from float64, to float64)
• func AtgUniqueConsecutive(ptr *Ctensor, self Ctensor, returnInverse int32, returnCounts int32, ...)
• func AtgUniqueDim(ptr *Ctensor, self Ctensor, dim int64, sorted int32, returnInverse int32, ...)
• func AtgUniqueDimConsecutive(ptr *Ctensor, self Ctensor, dim int64, returnInverse int32, returnCounts int32)
• func AtgUnsqueeze(ptr *Ctensor, self Ctensor, dim int64)
• func AtgUnsqueeze_(ptr *Ctensor, self Ctensor, dim int64)
• func AtgUpsampleBicubic2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleBicubic2dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleBicubic2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleBicubic2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleBilinear2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleBilinear2dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleBilinear2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleBilinear2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleLinear1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleLinear1dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleLinear1dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleLinear1dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleNearest1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleNearest1dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleNearest1dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleNearest1dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleNearest2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleNearest2dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleNearest2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleNearest2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleNearest3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleNearest3dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleNearest3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleNearest3dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleTrilinear3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleTrilinear3dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, ...)
• func AtgUpsampleTrilinear3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, ...)
• func AtgUpsampleTrilinear3dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
• func AtgValueSelectingReductionBackward(ptr *Ctensor, grad Ctensor, dim int64, indices Ctensor, sizesData []int64, ...)
• func AtgValues(ptr *Ctensor, self Ctensor)
• func AtgVander(ptr *Ctensor, x Ctensor, nVal int64, nNull int, increasing int32)
• func AtgVar(ptr *Ctensor, self Ctensor, unbiased int32)
• func AtgVarCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, ...)
• func AtgVarCorrectionOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgVarDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, ...)
• func AtgVarMean(ptr *Ctensor, self Ctensor, unbiased int32)
• func AtgVarMeanCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, ...)
• func AtgVarMeanDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, ...)
• func AtgVarOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func AtgVdot(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgVdotOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgView(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)
• func AtgViewAs(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgViewAsComplex(ptr *Ctensor, self Ctensor)
• func AtgViewAsReal(ptr *Ctensor, self Ctensor)
• func AtgViewDtype(ptr *Ctensor, self Ctensor, dtype int32)
• func AtgVstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgVstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)
• func AtgWhereScalar(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Cscalar)
• func AtgWhereScalarother(ptr *Ctensor, condition Ctensor, self Ctensor, other Cscalar)
• func AtgWhereScalarself(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgWhereSelf(ptr *Ctensor, condition Ctensor, self Ctensor, other Ctensor)
• func AtgXlogy(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgXlogyOutscalarOther(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
• func AtgXlogyOutscalarSelf(ptr *Ctensor, out Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgXlogyOuttensor(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func AtgXlogyScalarOther(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgXlogyScalarOther_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtgXlogyScalarSelf(ptr *Ctensor, selfScalar Cscalar, other Ctensor)
• func AtgXlogy_(ptr *Ctensor, self Ctensor, other Ctensor)
• func AtgZero_(ptr *Ctensor, self Ctensor)
• func AtgZeros(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func AtgZerosLike(ptr *Ctensor, self Ctensor)
• func AtgZerosOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)
• func Atg_AdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
• func Atg_AdaptiveAvgPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)
• func Atg_AdaptiveAvgPool3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
• func Atg_AdaptiveAvgPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)
• func Atg_AddBatchDim(ptr *Ctensor, self Ctensor, batchDim int64, level int64)
• func Atg_AddRelu(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg_AddReluOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
• func Atg_AddReluScalar(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg_AddReluScalar_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg_AddRelu_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg_Aminmax(ptr *Ctensor, self Ctensor)
• func Atg_AminmaxDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
• func Atg_AmpUpdateScale_(ptr *Ctensor, self Ctensor, growthTracker Ctensor, foundInf Ctensor, ...)
• func Atg_BaddbmmMkl_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)
• func Atg_CastByte(ptr *Ctensor, self Ctensor, nonBlocking int32)
• func Atg_CastChar(ptr *Ctensor, self Ctensor, nonBlocking int32)
• func Atg_CastDouble(ptr *Ctensor, self Ctensor, nonBlocking int32)
• func Atg_CastFloat(ptr *Ctensor, self Ctensor, nonBlocking int32)
• func Atg_CastHalf(ptr *Ctensor, self Ctensor, nonBlocking int32)
• func Atg_CastInt(ptr *Ctensor, self Ctensor, nonBlocking int32)
• func Atg_CastLong(ptr *Ctensor, self Ctensor, nonBlocking int32)
• func Atg_CastShort(ptr *Ctensor, self Ctensor, nonBlocking int32)
• func Atg_Cat(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func Atg_CatOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func Atg_CdistBackward(ptr *Ctensor, grad Ctensor, x1 Ctensor, x2 Ctensor, p float64, cdist Ctensor)
• func Atg_CholeskySolveHelper(ptr *Ctensor, self Ctensor, a Ctensor, upper int32)
• func Atg_Coalesce(ptr *Ctensor, self Ctensor)
• func Atg_Coalesced_(ptr *Ctensor, self Ctensor, coalesced int32)
• func Atg_ComputeLinearCombination(ptr *Ctensor, input Ctensor, coefficients Ctensor)
• func Atg_ComputeLinearCombinationOut(ptr *Ctensor, out Ctensor, input Ctensor, coefficients Ctensor)
• func Atg_Conj(ptr *Ctensor, self Ctensor)
• func Atg_ConjPhysical(ptr *Ctensor, self Ctensor)
• func Atg_ConvDepthwise2d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, ...)
• func Atg_ConvDepthwise2dBackward(ptr *Ctensor, gradInput Ctensor, gradWeight Ctensor, gradOutput Ctensor, ...)
• func Atg_ConvDepthwise2dOut(ptr *Ctensor, out Ctensor, self Ctensor, weight Ctensor, ...)
• func Atg_ConvertIndicesFromCooToCsr(ptr *Ctensor, self Ctensor, size int64, outInt32 int32)
• func Atg_ConvertIndicesFromCooToCsrOut(ptr *Ctensor, out Ctensor, self Ctensor, size int64, outInt32 int32)
• func Atg_Convolution(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func Atg_ConvolutionDeprecated(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func Atg_ConvolutionMode(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func Atg_ConvolutionNogroup(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
• func Atg_CopyFrom(ptr *Ctensor, self Ctensor, dst Ctensor, nonBlocking int32)
• func Atg_CopyFromAndResize(ptr *Ctensor, self Ctensor, dst Ctensor)
• func Atg_CtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, ...)
• func Atg_CtcLossBackward(ptr *Ctensor, grad Ctensor, logProbs Ctensor, targets Ctensor, ...)
• func Atg_CudnnCtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, ...)
• func Atg_CudnnInitDropoutState(ptr *Ctensor, dropout float64, train int32, dropoutSeed int64, ...)
• func Atg_CudnnRnn(ptr *Ctensor, input Ctensor, weightData []Ctensor, weightLen int, ...)
• func Atg_CudnnRnnFlattenWeight(ptr *Ctensor, weightArrData []Ctensor, weightArrLen int, weightStride0 int64, ...)
• func Atg_CufftGetPlanCacheMaxSize(deviceIndex int64) int64
• func Atg_CufftGetPlanCacheSize(deviceIndex int64) int64
• func Atg_DebugHasInternalOverlap(self Ctensor) int64
• func Atg_DetLuBasedHelper(ptr *Ctensor, self Ctensor)
• func Atg_DetLuBasedHelperBackwardHelper(ptr *Ctensor, detGrad Ctensor, det Ctensor, self Ctensor, lu Ctensor, ...)
• func Atg_DimArange(ptr *Ctensor, like Ctensor, dim int64)
• func Atg_Dimi(self Ctensor) int64
• func Atg_Dimv(self Ctensor) int64
• func Atg_DirichletGrad(ptr *Ctensor, x Ctensor, alpha Ctensor, total Ctensor)
• func Atg_EmbeddingBag(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, ...)
• func Atg_EmbeddingBagBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, offsets Ctensor, ...)
• func Atg_EmbeddingBagDenseBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, offset2bag Ctensor, ...)
• func Atg_EmbeddingBagForwardOnly(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, ...)
• func Atg_EmbeddingBagPerSampleWeightsBackward(ptr *Ctensor, grad Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, ...)
• func Atg_EmbeddingBagSparseBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, offsets Ctensor, ...)
• func Atg_EmptyAffineQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
• func Atg_EmptyPerChannelAffineQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, scales Ctensor, ...)
• func Atg_EuclideanDist(ptr *Ctensor, x1 Ctensor, x2 Ctensor)
• func Atg_FakeQuantizeLearnablePerChannelAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, ...)
• func Atg_FakeQuantizeLearnablePerChannelAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, ...)
• func Atg_FakeQuantizeLearnablePerTensorAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, quantMin int64, ...)
• func Atg_FakeQuantizeLearnablePerTensorAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, ...)
• func Atg_FakeQuantizePerTensorAffineCachemaskTensorQparams(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, ...)
• func Atg_FftC2c(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, normalization int64, ...)
• func Atg_FftC2cOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func Atg_FftC2r(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, normalization int64, ...)
• func Atg_FftC2rOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func Atg_FftR2c(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, normalization int64, ...)
• func Atg_FftR2cOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
• func Atg_FusedDropout(ptr *Ctensor, self Ctensor, p float64)
• func Atg_FusedMovingAvgObsFqHelper(ptr *Ctensor, self Ctensor, observerOn Ctensor, fakeQuantOn Ctensor, ...)
• func Atg_FwPrimal(ptr *Ctensor, self Ctensor, level int64)
• func Atg_GatherSparseBackward(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, grad Ctensor)
• func Atg_GridSampler2dCpuFallback(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, ...)
• func Atg_GridSampler2dCpuFallbackBackward(ptr *Ctensor, gradOutput Ctensor, input Ctensor, grid Ctensor, ...)
• func Atg_HasCompatibleShallowCopyType(self Ctensor, from Ctensor) bool
• func Atg_IndexCopy_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)
• func Atg_IndexPutImpl_(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, ...)
• func Atg_Indices(ptr *Ctensor, self Ctensor)
• func Atg_InverseHelper(ptr *Ctensor, self Ctensor)
• func Atg_LinalgInvOutHelper_(ptr *Ctensor, self Ctensor, infosLu Ctensor, infosGetri Ctensor)
• func Atg_LinalgQrHelper(ptr *Ctensor, self Ctensor, mode string)
• func Atg_LogSoftmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)
• func Atg_LogSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)
• func Atg_LogSoftmaxBackwardDataOut(ptr *Ctensor, out Ctensor, gradOutput Ctensor, output Ctensor, dim int64, ...)
• func Atg_LogSoftmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, halfToFloat int32)
• func Atg_Logcumsumexp(ptr *Ctensor, self Ctensor, dim int64)
• func Atg_LogcumsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64)
• func Atg_LuWithInfo(ptr *Ctensor, self Ctensor, pivot int32, checkErrors int32)
• func Atg_MakeDual(ptr *Ctensor, primal Ctensor, tangent Ctensor, level int64)
• func Atg_MakePerChannelQuantizedTensor(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64)
• func Atg_MakePerTensorQuantizedTensor(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64)
• func Atg_MaskedScale(ptr *Ctensor, self Ctensor, mask Ctensor, scale float64)
• func Atg_MkldnnReshape(ptr *Ctensor, self Ctensor, shapeData []int64, shapeLen int)
• func Atg_MkldnnTranspose(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)
• func Atg_MkldnnTranspose_(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)
• func Atg_NegView(ptr *Ctensor, self Ctensor)
• func Atg_NnpackAvailable() bool
• func Atg_NnpackSpatialConvolution(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, ...)
• func Atg_NnpackSpatialConvolutionBackwardInput(ptr *Ctensor, input Ctensor, gradOutput Ctensor, weight Ctensor, ...)
• func Atg_NnpackSpatialConvolutionBackwardWeight(ptr *Ctensor, input Ctensor, weightsizeData []int64, weightsizeLen int, ...)
• func Atg_Nnz(self Ctensor) int64
• func Atg_PackPaddedSequence(ptr *Ctensor, input Ctensor, lengths Ctensor, batchFirst int32)
• func Atg_PackPaddedSequenceBackward(ptr *Ctensor, grad Ctensor, inputSizeData []int64, inputSizeLen int, ...)
• func Atg_PadPackedSequence(ptr *Ctensor, data Ctensor, batchSizes Ctensor, batchFirst int32, ...)
• func Atg_PdistBackward(ptr *Ctensor, grad Ctensor, self Ctensor, p float64, pdist Ctensor)
• func Atg_PinMemory(ptr *Ctensor, self Ctensor, device int32)
• func Atg_RemoveBatchDim(ptr *Ctensor, self Ctensor, level int64, batchSize int64, outDim int64)
• func Atg_ReshapeAlias(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, ...)
• func Atg_ReshapeFromTensor(ptr *Ctensor, self Ctensor, shape Ctensor)
• func Atg_RowwisePrune(ptr *Ctensor, weight Ctensor, mask Ctensor, compressedIndicesDtype int32)
• func Atg_SWhere(ptr *Ctensor, condition Ctensor, self Ctensor, other Ctensor)
• func Atg_SampleDirichlet(ptr *Ctensor, self Ctensor)
• func Atg_SaturateWeightToFp16(ptr *Ctensor, weight Ctensor)
• func Atg_SegmentReduceBackward(ptr *Ctensor, grad Ctensor, output Ctensor, data Ctensor, reduce string, ...)
• func Atg_ShapeAsTensor(ptr *Ctensor, self Ctensor)
• func Atg_SobolEngineDraw(ptr *Ctensor, quasi Ctensor, n int64, sobolstate Ctensor, dimension int64, ...)
• func Atg_SobolEngineFf_(ptr *Ctensor, self Ctensor, n int64, sobolstate Ctensor, dimension int64, ...)
• func Atg_SobolEngineInitializeState_(ptr *Ctensor, self Ctensor, dimension int64)
• func Atg_SobolEngineScramble_(ptr *Ctensor, self Ctensor, ltm Ctensor, dimension int64)
• func Atg_Softmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)
• func Atg_SoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)
• func Atg_SoftmaxBackwardDataOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, output Ctensor, dim int64, ...)
• func Atg_SoftmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, halfToFloat int32)
• func Atg_SolveHelper(ptr *Ctensor, self Ctensor, a Ctensor)
• func Atg_SparseAddmm(ptr *Ctensor, self Ctensor, sparse Ctensor, dense Ctensor)
• func Atg_SparseCooTensorUnsafe(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, ...)
• func Atg_SparseCooTensorWithDims(ptr *Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, ...)
• func Atg_SparseCooTensorWithDimsAndTensors(ptr *Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, ...)
• func Atg_SparseCsrTensorUnsafe(ptr *Ctensor, crowIndices Ctensor, colIndices Ctensor, values Ctensor, ...)
• func Atg_SparseLogSoftmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)
• func Atg_SparseLogSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)
• func Atg_SparseLogSoftmaxInt(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
• func Atg_SparseMaskHelper(ptr *Ctensor, t Ctensor, maskIndices Ctensor)
• func Atg_SparseMm(ptr *Ctensor, sparse Ctensor, dense Ctensor)
• func Atg_SparseSoftmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)
• func Atg_SparseSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)
• func Atg_SparseSoftmaxInt(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
• func Atg_SparseSparseMatmul(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg_SparseSum(ptr *Ctensor, self Ctensor)
• func Atg_SparseSumBackward(ptr *Ctensor, grad Ctensor, self Ctensor, dimData []int64, dimLen int)
• func Atg_SparseSumDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int)
• func Atg_SparseSumDimDtype(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, dtype int32)
• func Atg_SparseSumDtype(ptr *Ctensor, self Ctensor, dtype int32)
• func Atg_Stack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func Atg_StackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)
• func Atg_StandardGamma(ptr *Ctensor, self Ctensor)
• func Atg_StandardGammaGrad(ptr *Ctensor, self Ctensor, output Ctensor)
• func Atg_SvdHelper(ptr *Ctensor, self Ctensor, some int32, computeUv int32)
• func Atg_SymeigHelper(ptr *Ctensor, self Ctensor, eigenvectors int32, upper int32)
• func Atg_TestAmbiguousDefaults(ptr *Ctensor, dummy Ctensor, a int64, b int64)
• func Atg_TestAmbiguousDefaultsB(ptr *Ctensor, dummy Ctensor, a int64, b string)
• func Atg_TestOptionalFilledIntlist(ptr *Ctensor, values Ctensor, addendsData []int64, addendsLen int)
• func Atg_TestOptionalIntlist(ptr *Ctensor, values Ctensor, addendsData []int64, addendsLen int)
• func Atg_TestSerializationSubcmul(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg_TestStringDefault(ptr *Ctensor, dummy Ctensor, a string, b string)
• func Atg_ToCopy(ptr *Ctensor, self Ctensor, optionsKind int32, optionsDevice int32, ...)
• func Atg_Trilinear(ptr *Ctensor, i1 Ctensor, i2 Ctensor, i3 Ctensor, expand1Data []int64, ...)
• func Atg_Unique(ptr *Ctensor, self Ctensor, sorted int32, returnInverse int32)
• func Atg_Unique2(ptr *Ctensor, self Ctensor, sorted int32, returnInverse int32, ...)
• func Atg_UnpackDual(ptr *Ctensor, dual Ctensor, level int64)
• func Atg_UnsafeView(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)
• func Atg_UseCudnnCtcLoss(logProbs Ctensor, targets Ctensor, inputLengthsData []int64, ...) bool
• func Atg_UseCudnnRnnFlattenWeight() bool
• func Atg_Values(ptr *Ctensor, self Ctensor)
• func Atg_Version(self Ctensor) int64
• func Atg_WeightNorm(ptr *Ctensor, v Ctensor, g Ctensor, dim int64)
• func Atg_WeightNormCudaInterface(ptr *Ctensor, v Ctensor, g Ctensor, dim int64)
• func Atg_WeightNormCudaInterfaceBackward(ptr *Ctensor, gradW Ctensor, savedV Ctensor, savedG Ctensor, ...)
• func Atg_WeightNormDifferentiableBackward(ptr *Ctensor, gradW Ctensor, savedV Ctensor, savedG Ctensor, ...)
• func Atg__AndTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__And_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg__IandTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__Iand_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg__IlshiftTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__Ilshift_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg__IorTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__Ior_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg__IrshiftTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__Irshift_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg__IxorTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__Ixor_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg__LshiftTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__Lshift_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg__OrTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__Or_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg__RshiftTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__Rshift_(ptr *Ctensor, self Ctensor, other Cscalar)
• func Atg__XorTensor_(ptr *Ctensor, self Ctensor, other Ctensor)
• func Atg__Xor_(ptr *Ctensor, self Ctensor, other Cscalar)
• func AtiFree(val Civalue)
• func AtiLength(val Civalue) int32
• func AtiTag(val Civalue) int32
• func AtiToBool(val Civalue) bool
• func AtiToBoolList(val Civalue, ptr unsafe.Pointer, boolListLen int)
• func AtiToDouble(val Civalue) float64
• func AtiToDoubleList(val Civalue, ptr unsafe.Pointer, doubleListLen int)
• func AtiToGenericDict(val Civalue, ptr *Civalue, genericDictLen int)
• func AtiToGenericList(val Civalue, ptr *Civalue, genericListLen int)
• func AtiToInt(val Civalue) int64
• func AtiToIntList(val Civalue, ptr unsafe.Pointer, intListLen int)
• func AtiToString(val Civalue) string
• func AtiToTensorList(val Civalue, ptr *Ctensor, tensorListLen int)
• func AtiToTuple(val Civalue, ptr *Civalue, tupleLen int)
• func AtiTupleLength(val Civalue) int32
• func AtmEval(m Cmodule)
• func AtmFree(m Cmodule)
• func AtmGetProfilingMode() bool
• func AtmNamedParameters(m Cmodule, dataPtr unsafe.Pointer)
• func AtmSave(m Cmodule, path string)
• func AtmSetProfilingMode(b bool)
• func AtmTo(m Cmodule, device int32, dtype int32, nonBlocking bool)
• func AtmTrain(m Cmodule)
• func AtoAddParamGroup(coptimizer Coptimizer, tensors []Ctensor, ntensors int)
• func AtoAddParameter(coptimizer Coptimizer, tensor Ctensor, group uint)
• func AtoAddParametersOld(coptimizer Coptimizer, tensors []Ctensor, ntensors int)
• func AtoFree(coptimizer Coptimizer)
• func AtoGetLearningRates(coptimizer Coptimizer) []float64
• func AtoParamGroupNum(coptimizer Coptimizer) int64
• func AtoSetLearningRate(coptimizer Coptimizer, learningRate float64)
• func AtoSetLearningRates(coptimizer Coptimizer, lrs []float64)
• func AtoSetMomentum(coptimizer Coptimizer, momentum float64)
• func AtoStep(coptimizer Coptimizer)
• func AtoZeroGrad(coptimizer Coptimizer)
• func AtsFree(cscalar Cscalar)
• func AtsToFloat(cscalar Cscalar) float64
• func AtsToInt(cscalar Cscalar) int64
• func AtsToString(cscalar Cscalar) string
• func GetAndResetLastErr() *C.char
• type Civalue
  • func AtiBool(val bool) Civalue
  • func AtiBoolList(boolListData []bool, boolListLen int) Civalue
  • func AtiDouble(val float64) Civalue
  • func AtiDoubleList(doubleListData []float64, doubleListLen int) Civalue
  • func AtiGenericDict(genericDictData []Civalue, genericDictLen int) Civalue
  • func AtiGenericList(genericListData []Civalue, genericListLen int) Civalue
  • func AtiInt(val int64) Civalue
  • func AtiIntList(intListData []int64, intListLen int) Civalue
  • func AtiNone() Civalue
  • func AtiString(val string) Civalue
  • func AtiTensor(ts Ctensor) Civalue
  • func AtiTensorList(tensorListData []Ctensor, tensorListLen int) Civalue
  • func AtiTuple(tupleData []Civalue, tupleLen int) Civalue
  • func AtmForward_(m Cmodule, ivalues *Civalue, nivalues int) Civalue
• type Cmodule
  • func AtmLoad(path string) Cmodule
  • func AtmLoadOnDevice(path string, device int32) Cmodule
  • func AtmLoadStr(val string, sz int) Cmodule
  • func AtmLoadStrOnDevice(val string, sz int, device int32) Cmodule
• type Coptimizer
  • func AtoAdam(learningRate, beta1, beta2, weightDecay float64) Coptimizer
  • func AtoAdamW(learningRate, beta1, beta2, weightDecay float64) Coptimizer
  • func AtoRmsProp(learningRate, alpha, eps, weightDecay, momentum float64, centered int) Coptimizer
  • func AtoSgd(learningRate, momentum, dampening, weightDecay float64, nesterov int) Coptimizer
• type Cscalar
  • func AtsFloat(v float64) Cscalar
  • func AtsInt(v int64) Cscalar
• type Ctensor
  • func AtGet(ts Ctensor, index int) Ctensor
  • func AtLoad(path string) Ctensor
  • func AtLoadImage(path string) Ctensor
  • func AtNewTensor() Ctensor
  • func AtResizeImage(ts Ctensor, w, h int64) Ctensor
  • func AtShallowClone(ts Ctensor) Ctensor
  • func AtTensorOfData(vs unsafe.Pointer, dims []int64, ndims uint, elt_size_in_bytes uint, kind int) Ctensor
  • func AtgAlignTensors(tensorsData []Ctensor, tensorsLen int) *Ctensor
  • func AtgBroadcastTensors(tensorsData []Ctensor, tensorsLen int) *Ctensor
  • func AtgChunk(self Ctensor, chunks int64, dim int64) *Ctensor
  • func AtgMeshgrid(tensorsData []Ctensor, tensorsLen int) *Ctensor
  • func AtgNonzeroNumpy(self Ctensor) *Ctensor
  • func AtgSplit(self Ctensor, splitSize int64, dim int64) *Ctensor
  • func AtgSplitWithSizes(self Ctensor, splitSizesData []int64, splitSizesLen int, dim int64) *Ctensor
  • func AtgUnbind(self Ctensor, dim int64) *Ctensor
  • func AtgWhere(condition Ctensor) *Ctensor
  • func AtiToTensor(val Civalue) Ctensor
  • func AtmForward(m Cmodule, tensors *Ctensor, ntensors int) Ctensor
  • func NewTensor() Ctensor
• type LoadData
• type NamedCtensor
• type PointerStore
  • func NewPointerStore() PointerStore
  • func (ps PointerStore) Free(ptr unsafe.Pointer)
  • func (ps PointerStore) Get(ptr unsafe.Pointer) (v interface{})
  • func (ps PointerStore) Set(v interface{}) unsafe.Pointer

Variables

var PStore = NewPointerStore()

Functions

func AtBackward

func AtBackward(ts Ctensor, keepGraph int, createGraph int)

void at_backward(tensor, int, int);

func AtCopyData

func AtCopyData(ts Ctensor, vs unsafe.Pointer, numel uint, element_size_in_bytes uint)

void at_copy_data(tensor tensor, void *vs, size_t numel, size_t element_size_in_bytes);

func AtCopy_

func AtCopy_(dst Ctensor, src Ctensor)

void at_copy_(tensor dst, tensor src);

func AtDataPtr

func AtDataPtr(t Ctensor) unsafe.Pointer

void *at_data_ptr(tensor);

func AtDefined

func AtDefined(ts Ctensor) bool

int at_defined(tensor);

func AtDevice

func AtDevice(ts Ctensor) int

int at_device(tensor);

func AtDim

func AtDim(t Ctensor) uint64

size_t at_dim(tensor);

func AtDoubleValueAtIndexes

func AtDoubleValueAtIndexes(ts Ctensor, indexes unsafe.Pointer, indexesLen int) float64

double at_double_value_at_indexes(tensor, int64_t *indexes, int indexes_len);

func AtFree

func AtFree(ts Ctensor)

void at_free(tensor);

func AtGradSetEnabled

func AtGradSetEnabled(b int) int

int at_grad_set_enabled(int b);

func AtInt64ValueAtIndexes

func AtInt64ValueAtIndexes(ts Ctensor, indexes unsafe.Pointer, indexesLen int) int64

int64_t at_int64_value_at_indexes(tensor, int64_t *indexes, int indexes_len);

func AtIsSparse

func AtIsSparse(ts Ctensor) bool

int at_is_sparse(tensor);

func AtLoadCallback

func AtLoadCallback(filename string, dataPtr unsafe.Pointer)

void at_load_callback(char *filename, void *data, void (*f)(void *, char *, tensor));

• void at_load_callback(char *filename, void *data, void (*f)(void *, char *, tensor)) {
• PROTECT(
• auto module = torch::jit::load(filename);
• for (const auto &p : module.named_parameters()) {
• auto v = p.value;
• f(data, (char*)p.name.c_str(), new torch::Tensor(v));
• }
• )
• } *

func AtLoadCallbackWithDevice

func AtLoadCallbackWithDevice(filename string, dataPtr unsafe.Pointer, device int32)

* void at_load_callback_with_device(char *filename, void *data, void (*f)(void *, char *, tensor), int device_id) { * PROTECT( * auto module = torch::jit::load(filename, device_of_int(device_id)); * for (const auto &p : module.named_parameters()) { * auto v = p.value; * f(data, (char*)p.name.c_str(), new torch::Tensor(v)); * } * ) * } *

func AtLoadMulti

func AtLoadMulti(tensors []Ctensor, tensor_names []string, ntensors int, filename string)

[at_load_multi] takes as input an array of nullptr for [tensors].

void at_load_multi(tensor *tensors, char **tensor_names, int ntensors, char *filename);

func AtPrint

func AtPrint(t Ctensor)

void at_print(tensor);

func AtRequiresGrad

func AtRequiresGrad(ts Ctensor) bool

int at_requires_grad(tensor);

func AtRunBackward

func AtRunBackward(tensorsPtr *Ctensor, ntensors int, inputsPtr *Ctensor, ninputs int, outputsPtr *Ctensor, keepGraph int, createGraph int)

* void at_run_backward(tensor *tensors, * int ntensors, * tensor *inputs, * int ninputs, * tensor *outputs, * int keep_graph, * int create_graph); *

func AtSave

func AtSave(ts Ctensor, path string)

void at_save(tensor, char *filename);

func AtSaveImage

func AtSaveImage(ts Ctensor, path string)

int at_save_image(tensor, char *filename);

func AtSaveMulti

func AtSaveMulti(tensors []Ctensor, tensor_names []string, ntensors int, filename string)

void at_save_multi(tensor *tensors, char **tensor_names, int ntensors, char *filename);

func AtSaveMultiNew

func AtSaveMultiNew(tensors []Ctensor, names []string, filename string)

void at_save_multi(tensor *tensors, char **tensor_names, int ntensors, char *filename);

func AtScalarType

func AtScalarType(t Ctensor) int32

int at_scalar_type(tensor);

func AtShape

func AtShape(t Ctensor, ptr unsafe.Pointer)

void at_shape(tensor, int64_t *);

func AtToString

func AtToString(ts Ctensor, lineSize int64) string

* char *at_to_string(tensor t, int line_size) { * PROTECT( * std::ostringstream oss; * torch::print(oss, *t, line_size); * return strdup(oss.str().c_str()); * ) * return nullptr; * } *

func AtcCudaDeviceCount

func AtcCudaDeviceCount() int

int atc_cuda_device_count();

func AtcCudaIsAvailable

func AtcCudaIsAvailable() bool

int atc_cuda_is_available();

func AtcCudnnIsAvailable

func AtcCudnnIsAvailable() bool

int atc_cudnn_is_available();

func AtcSetBenchmarkCudnn

func AtcSetBenchmarkCudnn(b int)

void atc_set_benchmark_cudnn(int b);

func Atc_cuda_device_count

func Atc_cuda_device_count() int

func AtgAbs

func AtgAbs(ptr *Ctensor, self Ctensor)

func AtgAbsOut

func AtgAbsOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAbs_

func AtgAbs_(ptr *Ctensor, self Ctensor)

func AtgAbsolute

func AtgAbsolute(ptr *Ctensor, self Ctensor)

func AtgAbsoluteOut

func AtgAbsoluteOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAbsolute_

func AtgAbsolute_(ptr *Ctensor, self Ctensor)

func AtgAcos

func AtgAcos(ptr *Ctensor, self Ctensor)

func AtgAcosOut

func AtgAcosOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAcos_

func AtgAcos_(ptr *Ctensor, self Ctensor)

func AtgAcosh

func AtgAcosh(ptr *Ctensor, self Ctensor)

func AtgAcoshOut

func AtgAcoshOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAcosh_

func AtgAcosh_(ptr *Ctensor, self Ctensor)

func AtgAdaptiveAvgPool1d

func AtgAdaptiveAvgPool1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdaptiveAvgPool2d

func AtgAdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdaptiveAvgPool2dOut

func AtgAdaptiveAvgPool2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdaptiveAvgPool3d

func AtgAdaptiveAvgPool3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdaptiveAvgPool3dBackward

func AtgAdaptiveAvgPool3dBackward(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor)

func AtgAdaptiveAvgPool3dOut

func AtgAdaptiveAvgPool3dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdaptiveMaxPool1d

func AtgAdaptiveMaxPool1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdaptiveMaxPool2d

func AtgAdaptiveMaxPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdaptiveMaxPool2dBackward

func AtgAdaptiveMaxPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor)

func AtgAdaptiveMaxPool2dBackwardGradInput

func AtgAdaptiveMaxPool2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor)

func AtgAdaptiveMaxPool2dOut

func AtgAdaptiveMaxPool2dOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdaptiveMaxPool3d

func AtgAdaptiveMaxPool3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdaptiveMaxPool3dBackward

func AtgAdaptiveMaxPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor)

func AtgAdaptiveMaxPool3dBackwardGradInput

func AtgAdaptiveMaxPool3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor)

func AtgAdaptiveMaxPool3dOut

func AtgAdaptiveMaxPool3dOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgAdd

func AtgAdd(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgAddOut

func AtgAddOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgAddScalar

func AtgAddScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgAddScalar_

func AtgAddScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgAdd_

func AtgAdd_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgAddbmm

func AtgAddbmm(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)

func AtgAddbmmOut

func AtgAddbmmOut(ptr *Ctensor, out Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)

func AtgAddbmm_

func AtgAddbmm_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)

func AtgAddcdiv

func AtgAddcdiv(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)

func AtgAddcdivOut

func AtgAddcdivOut(ptr *Ctensor, out Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)

func AtgAddcdiv_

func AtgAddcdiv_(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)

func AtgAddcmul

func AtgAddcmul(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)

func AtgAddcmulOut

func AtgAddcmulOut(ptr *Ctensor, out Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)

func AtgAddcmul_

func AtgAddcmul_(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor)

func AtgAddmm

func AtgAddmm(ptr *Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)

func AtgAddmmOut

func AtgAddmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)

func AtgAddmm_

func AtgAddmm_(ptr *Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)

func AtgAddmv

func AtgAddmv(ptr *Ctensor, self Ctensor, mat Ctensor, vec Ctensor)

func AtgAddmvOut

func AtgAddmvOut(ptr *Ctensor, out Ctensor, self Ctensor, mat Ctensor, vec Ctensor)

func AtgAddmv_

func AtgAddmv_(ptr *Ctensor, self Ctensor, mat Ctensor, vec Ctensor)

func AtgAddr

func AtgAddr(ptr *Ctensor, self Ctensor, vec1 Ctensor, vec2 Ctensor)

func AtgAddrOut

func AtgAddrOut(ptr *Ctensor, out Ctensor, self Ctensor, vec1 Ctensor, vec2 Ctensor)

func AtgAddr_

func AtgAddr_(ptr *Ctensor, self Ctensor, vec1 Ctensor, vec2 Ctensor)

func AtgAffineGridGenerator

func AtgAffineGridGenerator(ptr *Ctensor, theta Ctensor, sizeData []int64, sizeLen int, alignCorners int32)

func AtgAffineGridGeneratorBackward

func AtgAffineGridGeneratorBackward(ptr *Ctensor, grad Ctensor, sizeData []int64, sizeLen int, alignCorners int32)

func AtgAlias

func AtgAlias(ptr *Ctensor, self Ctensor)

func AtgAlignAs

func AtgAlignAs(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgAll

func AtgAll(ptr *Ctensor, self Ctensor)

func AtgAllAllOut

func AtgAllAllOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAllDim

func AtgAllDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgAllOut

func AtgAllOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgAllclose

func AtgAllclose(self Ctensor, other Ctensor, rtol float64, atol float64, equalNan int32) bool

func AtgAlphaDropout

func AtgAlphaDropout(ptr *Ctensor, input Ctensor, p float64, train int32)

func AtgAlphaDropout_

func AtgAlphaDropout_(ptr *Ctensor, self Ctensor, p float64, train int32)

func AtgAmax

func AtgAmax(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgAmaxOut

func AtgAmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgAmin

func AtgAmin(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgAminOut

func AtgAminOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgAminmax

func AtgAminmax(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgAminmaxOut

func AtgAminmaxOut(ptr *Ctensor, min Ctensor, max Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgAngle

func AtgAngle(ptr *Ctensor, self Ctensor)

func AtgAngleOut

func AtgAngleOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAny

func AtgAny(ptr *Ctensor, self Ctensor)

func AtgAnyAllOut

func AtgAnyAllOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAnyDim

func AtgAnyDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgAnyOut

func AtgAnyOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgArange

func AtgArange(ptr *Ctensor, end Cscalar, optionsKind int32, optionsDevice int32)

func AtgArangeOut

func AtgArangeOut(ptr *Ctensor, out Ctensor, end Cscalar)

func AtgArangeStart

func AtgArangeStart(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, optionsDevice int32)

func AtgArangeStartOut

func AtgArangeStartOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar)

func AtgArangeStartStep

func AtgArangeStartStep(ptr *Ctensor, start Cscalar, end Cscalar, step Cscalar, optionsKind int32, optionsDevice int32)

func AtgArccos

func AtgArccos(ptr *Ctensor, self Ctensor)

func AtgArccosOut

func AtgArccosOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgArccos_

func AtgArccos_(ptr *Ctensor, self Ctensor)

func AtgArccosh

func AtgArccosh(ptr *Ctensor, self Ctensor)

func AtgArccoshOut

func AtgArccoshOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgArccosh_

func AtgArccosh_(ptr *Ctensor, self Ctensor)

func AtgArcsin

func AtgArcsin(ptr *Ctensor, self Ctensor)

func AtgArcsinOut

func AtgArcsinOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgArcsin_

func AtgArcsin_(ptr *Ctensor, self Ctensor)

func AtgArcsinh

func AtgArcsinh(ptr *Ctensor, self Ctensor)

func AtgArcsinhOut

func AtgArcsinhOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgArcsinh_

func AtgArcsinh_(ptr *Ctensor, self Ctensor)

func AtgArctan

func AtgArctan(ptr *Ctensor, self Ctensor)

func AtgArctanOut

func AtgArctanOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgArctan_

func AtgArctan_(ptr *Ctensor, self Ctensor)

func AtgArctanh

func AtgArctanh(ptr *Ctensor, self Ctensor)

func AtgArctanhOut

func AtgArctanhOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgArctanh_

func AtgArctanh_(ptr *Ctensor, self Ctensor)

func AtgArgmax

func AtgArgmax(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgArgmaxOut

func AtgArgmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgArgmin

func AtgArgmin(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgArgminOut

func AtgArgminOut(ptr *Ctensor, out Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgArgsort

func AtgArgsort(ptr *Ctensor, self Ctensor, dim int64, descending int32)

func AtgAsStrided

func AtgAsStrided(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, strideLen int, storageOffsetVal int64, storageOffsetNull int)

func AtgAsStrided_

func AtgAsStrided_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, strideLen int, storageOffsetVal int64, storageOffsetNull int)

func AtgAsin

func AtgAsin(ptr *Ctensor, self Ctensor)

func AtgAsinOut

func AtgAsinOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAsin_

func AtgAsin_(ptr *Ctensor, self Ctensor)

func AtgAsinh

func AtgAsinh(ptr *Ctensor, self Ctensor)

func AtgAsinhOut

func AtgAsinhOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAsinh_

func AtgAsinh_(ptr *Ctensor, self Ctensor)

func AtgAtan

func AtgAtan(ptr *Ctensor, self Ctensor)

func AtgAtan2

func AtgAtan2(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgAtan2Out

func AtgAtan2Out(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgAtan2_

func AtgAtan2_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgAtanOut

func AtgAtanOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAtan_

func AtgAtan_(ptr *Ctensor, self Ctensor)

func AtgAtanh

func AtgAtanh(ptr *Ctensor, self Ctensor)

func AtgAtanhOut

func AtgAtanhOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgAtanh_

func AtgAtanh_(ptr *Ctensor, self Ctensor)

func AtgAtleast1d

func AtgAtleast1d(ptr *Ctensor, self Ctensor)

func AtgAtleast2d

func AtgAtleast2d(ptr *Ctensor, self Ctensor)

func AtgAtleast3d

func AtgAtleast3d(ptr *Ctensor, self Ctensor)

func AtgAvgPool1d

func AtgAvgPool1d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32)

func AtgAvgPool2d

func AtgAvgPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32, divisorOverrideVal int64, divisorOverrideNull int)

func AtgAvgPool2dBackward

func AtgAvgPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32, divisorOverrideVal int64, divisorOverrideNull int)

func AtgAvgPool2dBackwardGradInput

func AtgAvgPool2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32, divisorOverrideVal int64, divisorOverrideNull int)

func AtgAvgPool2dOut

func AtgAvgPool2dOut(ptr *Ctensor, out Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32, divisorOverrideVal int64, divisorOverrideNull int)

func AtgAvgPool3d

func AtgAvgPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32, divisorOverrideVal int64, divisorOverrideNull int)

func AtgAvgPool3dBackward

func AtgAvgPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32, divisorOverrideVal int64, divisorOverrideNull int)

func AtgAvgPool3dBackwardGradInput

func AtgAvgPool3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32, divisorOverrideVal int64, divisorOverrideNull int)

func AtgAvgPool3dOut

func AtgAvgPool3dOut(ptr *Ctensor, out Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32, divisorOverrideVal int64, divisorOverrideNull int)

func AtgBaddbmm

func AtgBaddbmm(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)

func AtgBaddbmmOut

func AtgBaddbmmOut(ptr *Ctensor, out Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)

func AtgBaddbmm_

func AtgBaddbmm_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)

func AtgBartlettWindow

func AtgBartlettWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)

func AtgBartlettWindowPeriodic

func AtgBartlettWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32)

func AtgBatchNorm

func AtgBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, momentum float64, eps float64, cudnnEnabled int32)

func AtgBatchNormBackwardElemt

func AtgBatchNormBackwardElemt(ptr *Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, weight Ctensor, meanDy Ctensor, meanDyXmu Ctensor, count Ctensor)

func AtgBatchNormBackwardReduce

func AtgBatchNormBackwardReduce(ptr *Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, weight Ctensor, inputG int32, weightG int32, biasG int32)

func AtgBatchNormElemt

func AtgBatchNormElemt(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, mean Ctensor, invstd Ctensor, eps float64)

func AtgBatchNormElemtOut

func AtgBatchNormElemtOut(ptr *Ctensor, out Ctensor, input Ctensor, weight Ctensor, bias Ctensor, mean Ctensor, invstd Ctensor, eps float64)

func AtgBatchNormGatherStats

func AtgBatchNormGatherStats(ptr *Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, runningMean Ctensor, runningVar Ctensor, momentum float64, eps float64, count int64)

func AtgBatchNormGatherStatsWithCounts

func AtgBatchNormGatherStatsWithCounts(ptr *Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, runningMean Ctensor, runningVar Ctensor, momentum float64, eps float64, counts Ctensor)

func AtgBatchNormStats

func AtgBatchNormStats(ptr *Ctensor, input Ctensor, eps float64)

func AtgBatchNormUpdateStats

func AtgBatchNormUpdateStats(ptr *Ctensor, input Ctensor, runningMean Ctensor, runningVar Ctensor, momentum float64)

func AtgBernoulli

func AtgBernoulli(ptr *Ctensor, self Ctensor)

func AtgBernoulliFloat_

func AtgBernoulliFloat_(ptr *Ctensor, self Ctensor, p float64)

func AtgBernoulliOut

func AtgBernoulliOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgBernoulliP

func AtgBernoulliP(ptr *Ctensor, self Ctensor, p float64)

func AtgBernoulli_

func AtgBernoulli_(ptr *Ctensor, self Ctensor, p Ctensor)

func AtgBilinear

func AtgBilinear(ptr *Ctensor, input1 Ctensor, input2 Ctensor, weight Ctensor, bias Ctensor)

func AtgBinaryCrossEntropy

func AtgBinaryCrossEntropy(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64)

func AtgBinaryCrossEntropyBackward

func AtgBinaryCrossEntropyBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64)

func AtgBinaryCrossEntropyBackwardGradInput

func AtgBinaryCrossEntropyBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64)

func AtgBinaryCrossEntropyOut

func AtgBinaryCrossEntropyOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64)

func AtgBinaryCrossEntropyWithLogits

func AtgBinaryCrossEntropyWithLogits(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, posWeight Ctensor, reduction int64)

func AtgBinaryCrossEntropyWithLogitsBackward

func AtgBinaryCrossEntropyWithLogitsBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, posWeight Ctensor, reduction int64)

func AtgBincount

func AtgBincount(ptr *Ctensor, self Ctensor, weights Ctensor, minlength int64)

func AtgBinomial

func AtgBinomial(ptr *Ctensor, count Ctensor, prob Ctensor)

func AtgBitwiseAnd

func AtgBitwiseAnd(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseAndScalarOut

func AtgBitwiseAndScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseAndTensor

func AtgBitwiseAndTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseAndTensorOut

func AtgBitwiseAndTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseAndTensor_

func AtgBitwiseAndTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseAnd_

func AtgBitwiseAnd_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseLeftShift

func AtgBitwiseLeftShift(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseLeftShiftScalarTensor

func AtgBitwiseLeftShiftScalarTensor(ptr *Ctensor, selfScalar Cscalar, other Ctensor)

func AtgBitwiseLeftShiftTensorOut

func AtgBitwiseLeftShiftTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseLeftShiftTensorScalar

func AtgBitwiseLeftShiftTensorScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseLeftShiftTensorScalarOut

func AtgBitwiseLeftShiftTensorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseLeftShiftTensorScalar_

func AtgBitwiseLeftShiftTensorScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseLeftShift_

func AtgBitwiseLeftShift_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseNot

func AtgBitwiseNot(ptr *Ctensor, self Ctensor)

func AtgBitwiseNotOut

func AtgBitwiseNotOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgBitwiseNot_

func AtgBitwiseNot_(ptr *Ctensor, self Ctensor)

func AtgBitwiseOr

func AtgBitwiseOr(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseOrScalarOut

func AtgBitwiseOrScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseOrTensor

func AtgBitwiseOrTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseOrTensorOut

func AtgBitwiseOrTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseOrTensor_

func AtgBitwiseOrTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseOr_

func AtgBitwiseOr_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseRightShift

func AtgBitwiseRightShift(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseRightShiftScalarTensor

func AtgBitwiseRightShiftScalarTensor(ptr *Ctensor, selfScalar Cscalar, other Ctensor)

func AtgBitwiseRightShiftTensorOut

func AtgBitwiseRightShiftTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseRightShiftTensorScalar

func AtgBitwiseRightShiftTensorScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseRightShiftTensorScalarOut

func AtgBitwiseRightShiftTensorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseRightShiftTensorScalar_

func AtgBitwiseRightShiftTensorScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseRightShift_

func AtgBitwiseRightShift_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseXor

func AtgBitwiseXor(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseXorScalarOut

func AtgBitwiseXorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgBitwiseXorTensor

func AtgBitwiseXorTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseXorTensorOut

func AtgBitwiseXorTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseXorTensor_

func AtgBitwiseXorTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgBitwiseXor_

func AtgBitwiseXor_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgBlackmanWindow

func AtgBlackmanWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)

func AtgBlackmanWindowPeriodic

func AtgBlackmanWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32)

func AtgBlockDiag

func AtgBlockDiag(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgBmm

func AtgBmm(ptr *Ctensor, self Ctensor, mat2 Ctensor)

func AtgBmmOut

func AtgBmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor)

func AtgBroadcastTo

func AtgBroadcastTo(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)

func AtgBucketize

func AtgBucketize(ptr *Ctensor, self Ctensor, boundaries Ctensor, outInt32 int32, right int32)

func AtgBucketizeScalar

func AtgBucketizeScalar(ptr *Ctensor, selfScalar Cscalar, boundaries Ctensor, outInt32 int32, right int32)

func AtgBucketizeTensorOut

func AtgBucketizeTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, boundaries Ctensor, outInt32 int32, right int32)

func AtgCanCast

func AtgCanCast(from int32, to int32) bool

func AtgCartesianProd

func AtgCartesianProd(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgCat

func AtgCat(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func AtgCatOut

func AtgCatOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func AtgCauchy_

func AtgCauchy_(ptr *Ctensor, self Ctensor, median float64, sigma float64)

func AtgCdist

func AtgCdist(ptr *Ctensor, x1 Ctensor, x2 Ctensor, p float64, computeModeVal int64, computeModeNull int)

func AtgCeil

func AtgCeil(ptr *Ctensor, self Ctensor)

func AtgCeilOut

func AtgCeilOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgCeil_

func AtgCeil_(ptr *Ctensor, self Ctensor)

func AtgCelu

func AtgCelu(ptr *Ctensor, self Ctensor)

func AtgCelu_

func AtgCelu_(ptr *Ctensor, self Ctensor)

func AtgChainMatmul

func AtgChainMatmul(ptr *Ctensor, matricesData []Ctensor, matricesLen int)

func AtgChainMatmulOut

func AtgChainMatmulOut(ptr *Ctensor, out Ctensor, matricesData []Ctensor, matricesLen int)

func AtgChannelShuffle

func AtgChannelShuffle(ptr *Ctensor, self Ctensor, groups int64)

func AtgCholesky

func AtgCholesky(ptr *Ctensor, self Ctensor, upper int32)

func AtgCholeskyInverse

func AtgCholeskyInverse(ptr *Ctensor, self Ctensor, upper int32)

func AtgCholeskyInverseOut

func AtgCholeskyInverseOut(ptr *Ctensor, out Ctensor, self Ctensor, upper int32)

func AtgCholeskyOut

func AtgCholeskyOut(ptr *Ctensor, out Ctensor, self Ctensor, upper int32)

func AtgCholeskySolve

func AtgCholeskySolve(ptr *Ctensor, self Ctensor, input2 Ctensor, upper int32)

func AtgCholeskySolveOut

func AtgCholeskySolveOut(ptr *Ctensor, out Ctensor, self Ctensor, input2 Ctensor, upper int32)

func AtgChooseQparamsOptimized

func AtgChooseQparamsOptimized(ptr *Ctensor, input Ctensor, numel int64, nBins int64, ratio float64, bitWidth int64)

func AtgClamp

func AtgClamp(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar)

func AtgClampMax

func AtgClampMax(ptr *Ctensor, self Ctensor, max Cscalar)

func AtgClampMaxOut

func AtgClampMaxOut(ptr *Ctensor, out Ctensor, self Ctensor, max Cscalar)

func AtgClampMaxTensor

func AtgClampMaxTensor(ptr *Ctensor, self Ctensor, max Ctensor)

func AtgClampMaxTensorOut

func AtgClampMaxTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, max Ctensor)

func AtgClampMaxTensor_

func AtgClampMaxTensor_(ptr *Ctensor, self Ctensor, max Ctensor)

func AtgClampMax_

func AtgClampMax_(ptr *Ctensor, self Ctensor, max Cscalar)

func AtgClampMin

func AtgClampMin(ptr *Ctensor, self Ctensor, min Cscalar)

func AtgClampMinOut

func AtgClampMinOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar)

func AtgClampMinTensor

func AtgClampMinTensor(ptr *Ctensor, self Ctensor, min Ctensor)

func AtgClampMinTensorOut

func AtgClampMinTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, min Ctensor)

func AtgClampMinTensor_

func AtgClampMinTensor_(ptr *Ctensor, self Ctensor, min Ctensor)

func AtgClampMin_

func AtgClampMin_(ptr *Ctensor, self Ctensor, min Cscalar)

func AtgClampOut

func AtgClampOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar, max Cscalar)

func AtgClampTensor

func AtgClampTensor(ptr *Ctensor, self Ctensor, min Ctensor, max Ctensor)

func AtgClampTensorOut

func AtgClampTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, min Ctensor, max Ctensor)

func AtgClampTensor_

func AtgClampTensor_(ptr *Ctensor, self Ctensor, min Ctensor, max Ctensor)

func AtgClamp_

func AtgClamp_(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar)

func AtgClip

func AtgClip(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar)

func AtgClipOut

func AtgClipOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar, max Cscalar)

func AtgClipTensor

func AtgClipTensor(ptr *Ctensor, self Ctensor, min Ctensor, max Ctensor)

func AtgClipTensorOut

func AtgClipTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, min Ctensor, max Ctensor)

func AtgClipTensor_

func AtgClipTensor_(ptr *Ctensor, self Ctensor, min Ctensor, max Ctensor)

func AtgClip_

func AtgClip_(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar)

func AtgCoalesce

func AtgCoalesce(ptr *Ctensor, self Ctensor)

func AtgCol2im

func AtgCol2im(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int)

func AtgCol2imBackward

func AtgCol2imBackward(ptr *Ctensor, gradOutput Ctensor, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int)

func AtgCol2imBackwardGradInput

func AtgCol2imBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int)

func AtgCol2imOut

func AtgCol2imOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int)

func AtgColIndices

func AtgColIndices(ptr *Ctensor, self Ctensor)

func AtgColumnStack

func AtgColumnStack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgColumnStackOut

func AtgColumnStackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgCombinations

func AtgCombinations(ptr *Ctensor, self Ctensor, r int64, withReplacement int32)

func AtgComplex

func AtgComplex(ptr *Ctensor, real Ctensor, imag Ctensor)

func AtgComplexOut

func AtgComplexOut(ptr *Ctensor, out Ctensor, real Ctensor, imag Ctensor)

func AtgConcat

func AtgConcat(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func AtgConcatOut

func AtgConcatOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func AtgConj

func AtgConj(ptr *Ctensor, self Ctensor)

func AtgConjPhysical

func AtgConjPhysical(ptr *Ctensor, self Ctensor)

func AtgConjPhysicalOut

func AtgConjPhysicalOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgConjPhysical_

func AtgConjPhysical_(ptr *Ctensor, self Ctensor)

func AtgConstantPadNd

func AtgConstantPadNd(ptr *Ctensor, self Ctensor, padData []int64, padLen int)

func AtgContiguous

func AtgContiguous(ptr *Ctensor, self Ctensor)

func AtgConv1d

func AtgConv1d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, groups int64)

func AtgConv1dPadding

func AtgConv1dPadding(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, padding string, dilationData []int64, dilationLen int, groups int64)

func AtgConv2d

func AtgConv2d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, groups int64)

func AtgConv2dPadding

func AtgConv2dPadding(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, padding string, dilationData []int64, dilationLen int, groups int64)

func AtgConv3d

func AtgConv3d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, groups int64)

func AtgConv3dPadding

func AtgConv3dPadding(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, padding string, dilationData []int64, dilationLen int, groups int64)

func AtgConvDepthwise3d

func AtgConvDepthwise3d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int)

func AtgConvDepthwise3dBackward

func AtgConvDepthwise3dBackward(ptr *Ctensor, gradInput Ctensor, gradWeight Ctensor, gradBias Ctensor, gradOutput Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int)

func AtgConvTbc

func AtgConvTbc(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, pad int64)

func AtgConvTbcBackward

func AtgConvTbcBackward(ptr *Ctensor, self Ctensor, input Ctensor, weight Ctensor, bias Ctensor, pad int64)

func AtgConvTranspose1d

func AtgConvTranspose1d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, groups int64, dilationData []int64, dilationLen int)

func AtgConvTranspose2d

func AtgConvTranspose2d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, groups int64, dilationData []int64, dilationLen int)

func AtgConvTranspose3d

func AtgConvTranspose3d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, groups int64, dilationData []int64, dilationLen int)

func AtgConvolution

func AtgConvolution(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, transposed int32, outputPaddingData []int64, outputPaddingLen int, groups int64)

func AtgConvolutionOverrideable

func AtgConvolutionOverrideable(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, transposed int32, outputPaddingData []int64, outputPaddingLen int, groups int64)

func AtgCopySparseToSparse_

func AtgCopySparseToSparse_(ptr *Ctensor, self Ctensor, src Ctensor, nonBlocking int32)

func AtgCopysign

func AtgCopysign(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgCopysignOut

func AtgCopysignOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgCopysignScalar

func AtgCopysignScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgCopysignScalarOut

func AtgCopysignScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgCopysignScalar_

func AtgCopysignScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgCopysign_

func AtgCopysign_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgCorrcoef

func AtgCorrcoef(ptr *Ctensor, self Ctensor)

func AtgCos

func AtgCos(ptr *Ctensor, self Ctensor)

func AtgCosOut

func AtgCosOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgCos_

func AtgCos_(ptr *Ctensor, self Ctensor)

func AtgCosh

func AtgCosh(ptr *Ctensor, self Ctensor)

func AtgCoshOut

func AtgCoshOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgCosh_

func AtgCosh_(ptr *Ctensor, self Ctensor)

func AtgCosineEmbeddingLoss

func AtgCosineEmbeddingLoss(ptr *Ctensor, input1 Ctensor, input2 Ctensor, target Ctensor, margin float64, reduction int64)

func AtgCosineSimilarity

func AtgCosineSimilarity(ptr *Ctensor, x1 Ctensor, x2 Ctensor, dim int64, eps float64)

func AtgCountNonzero

func AtgCountNonzero(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int)

func AtgCountNonzeroDimIntlist

func AtgCountNonzeroDimIntlist(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int)

func AtgCov

func AtgCov(ptr *Ctensor, self Ctensor, correction int64, fweights Ctensor, aweights Ctensor)

func AtgCross

func AtgCross(ptr *Ctensor, self Ctensor, other Ctensor, dimVal int64, dimNull int)

func AtgCrossEntropyLoss

func AtgCrossEntropyLoss(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, labelSmoothing float64)

func AtgCrossOut

func AtgCrossOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, dimVal int64, dimNull int)

func AtgCrowIndices

func AtgCrowIndices(ptr *Ctensor, self Ctensor)

func AtgCtcLoss

func AtgCtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, inputLengthsLen int, targetLengthsData []int64, targetLengthsLen int, blank int64, reduction int64, zeroInfinity int32)

func AtgCtcLossTensor

func AtgCtcLossTensor(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengths Ctensor, targetLengths Ctensor, blank int64, reduction int64, zeroInfinity int32)

func AtgCudnnAffineGridGenerator

func AtgCudnnAffineGridGenerator(ptr *Ctensor, theta Ctensor, n int64, c int64, h int64, w int64)

func AtgCudnnAffineGridGeneratorBackward

func AtgCudnnAffineGridGeneratorBackward(ptr *Ctensor, grad Ctensor, n int64, c int64, h int64, w int64)

func AtgCudnnBatchNorm

func AtgCudnnBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, exponentialAverageFactor float64, epsilon float64)

func AtgCudnnBatchNormBackward

func AtgCudnnBatchNormBackward(ptr *Ctensor, input Ctensor, gradOutput Ctensor, weight Ctensor, runningMean Ctensor, runningVar Ctensor, saveMean Ctensor, saveVar Ctensor, epsilon float64, reserveSpace Ctensor)

func AtgCudnnConvolution

func AtgCudnnConvolution(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32, allowTf32 int32)

func AtgCudnnConvolutionAddRelu

func AtgCudnnConvolutionAddRelu(ptr *Ctensor, self Ctensor, weight Ctensor, z Ctensor, alpha Cscalar, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, groups int64)

func AtgCudnnConvolutionBackwardInput

func AtgCudnnConvolutionBackwardInput(ptr *Ctensor, selfSizeData []int64, selfSizeLen int, gradOutput Ctensor, weight Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32, allowTf32 int32)

func AtgCudnnConvolutionBackwardWeight

func AtgCudnnConvolutionBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32, allowTf32 int32)

func AtgCudnnConvolutionDeprecated

func AtgCudnnConvolutionDeprecated(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgCudnnConvolutionDeprecated2

func AtgCudnnConvolutionDeprecated2(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgCudnnConvolutionRelu

func AtgCudnnConvolutionRelu(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, groups int64)

func AtgCudnnConvolutionTranspose

func AtgCudnnConvolutionTranspose(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32, allowTf32 int32)

func AtgCudnnConvolutionTransposeBackwardInput

func AtgCudnnConvolutionTransposeBackwardInput(ptr *Ctensor, gradOutput Ctensor, weight Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32, allowTf32 int32)

func AtgCudnnConvolutionTransposeBackwardWeight

func AtgCudnnConvolutionTransposeBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32, allowTf32 int32)

func AtgCudnnConvolutionTransposeDeprecated

func AtgCudnnConvolutionTransposeDeprecated(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgCudnnConvolutionTransposeDeprecated2

func AtgCudnnConvolutionTransposeDeprecated2(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgCudnnGridSampler

func AtgCudnnGridSampler(ptr *Ctensor, self Ctensor, grid Ctensor)

func AtgCudnnGridSamplerBackward

func AtgCudnnGridSamplerBackward(ptr *Ctensor, self Ctensor, grid Ctensor, gradOutput Ctensor)

func AtgCudnnIsAcceptable

func AtgCudnnIsAcceptable(self Ctensor) bool

func AtgCummax

func AtgCummax(ptr *Ctensor, self Ctensor, dim int64)

func AtgCummaxOut

func AtgCummaxOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64)

func AtgCummaxminBackward

func AtgCummaxminBackward(ptr *Ctensor, grad Ctensor, input Ctensor, indices Ctensor, dim int64)

func AtgCummin

func AtgCummin(ptr *Ctensor, self Ctensor, dim int64)

func AtgCumminOut

func AtgCumminOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64)

func AtgCumprod

func AtgCumprod(ptr *Ctensor, self Ctensor, dim int64, dtype int32)

func AtgCumprodBackward

func AtgCumprodBackward(ptr *Ctensor, grad Ctensor, input Ctensor, dim int64, output Ctensor)

func AtgCumprodOut

func AtgCumprodOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, dtype int32)

func AtgCumprod_

func AtgCumprod_(ptr *Ctensor, self Ctensor, dim int64, dtype int32)

func AtgCumsum

func AtgCumsum(ptr *Ctensor, self Ctensor, dim int64, dtype int32)

func AtgCumsumOut

func AtgCumsumOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, dtype int32)

func AtgCumsum_

func AtgCumsum_(ptr *Ctensor, self Ctensor, dim int64, dtype int32)

func AtgCumulativeTrapezoid

func AtgCumulativeTrapezoid(ptr *Ctensor, y Ctensor, dim int64)

func AtgCumulativeTrapezoidX

func AtgCumulativeTrapezoidX(ptr *Ctensor, y Ctensor, x Ctensor, dim int64)

func AtgData

func AtgData(ptr *Ctensor, self Ctensor)

func AtgDeg2rad

func AtgDeg2rad(ptr *Ctensor, self Ctensor)

func AtgDeg2radOut

func AtgDeg2radOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgDeg2rad_

func AtgDeg2rad_(ptr *Ctensor, self Ctensor)

func AtgDenseDim

func AtgDenseDim(self Ctensor) int64

func AtgDequantize

func AtgDequantize(ptr *Ctensor, self Ctensor)

func AtgDet

func AtgDet(ptr *Ctensor, self Ctensor)

func AtgDetach

func AtgDetach(ptr *Ctensor, self Ctensor)

func AtgDetach_

func AtgDetach_(ptr *Ctensor, self Ctensor)

func AtgDiag

func AtgDiag(ptr *Ctensor, self Ctensor, diagonal int64)

func AtgDiagBackward

func AtgDiagBackward(ptr *Ctensor, grad Ctensor, inputSizesData []int64, inputSizesLen int, diagonal int64)

func AtgDiagEmbed

func AtgDiagEmbed(ptr *Ctensor, self Ctensor, offset int64, dim1 int64, dim2 int64)

func AtgDiagOut

func AtgDiagOut(ptr *Ctensor, out Ctensor, self Ctensor, diagonal int64)

func AtgDiagflat

func AtgDiagflat(ptr *Ctensor, self Ctensor, offset int64)

func AtgDiagonal

func AtgDiagonal(ptr *Ctensor, self Ctensor, offset int64, dim1 int64, dim2 int64)

func AtgDiagonalBackward

func AtgDiagonalBackward(ptr *Ctensor, gradOutput Ctensor, inputSizesData []int64, inputSizesLen int, offset int64, dim1 int64, dim2 int64)

func AtgDiff

func AtgDiff(ptr *Ctensor, self Ctensor, n int64, dim int64, prepend Ctensor, append Ctensor)

func AtgDiffOut

func AtgDiffOut(ptr *Ctensor, out Ctensor, self Ctensor, n int64, dim int64, prepend Ctensor, append Ctensor)

func AtgDigamma

func AtgDigamma(ptr *Ctensor, self Ctensor)

func AtgDigammaOut

func AtgDigammaOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgDigamma_

func AtgDigamma_(ptr *Ctensor, self Ctensor)

func AtgDist

func AtgDist(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgDiv

func AtgDiv(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgDivOut

func AtgDivOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgDivOutMode

func AtgDivOutMode(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, roundingMode string)

func AtgDivScalar

func AtgDivScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgDivScalarMode

func AtgDivScalarMode(ptr *Ctensor, self Ctensor, other Cscalar, roundingMode string)

func AtgDivScalarMode_

func AtgDivScalarMode_(ptr *Ctensor, self Ctensor, other Cscalar, roundingMode string)

func AtgDivScalar_

func AtgDivScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgDivTensorMode

func AtgDivTensorMode(ptr *Ctensor, self Ctensor, other Ctensor, roundingMode string)

func AtgDivTensorMode_

func AtgDivTensorMode_(ptr *Ctensor, self Ctensor, other Ctensor, roundingMode string)

func AtgDiv_

func AtgDiv_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgDivide

func AtgDivide(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgDivideOut

func AtgDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgDivideOutMode

func AtgDivideOutMode(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, roundingMode string)

func AtgDivideScalar

func AtgDivideScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgDivideScalarMode

func AtgDivideScalarMode(ptr *Ctensor, self Ctensor, other Cscalar, roundingMode string)

func AtgDivideScalarMode_

func AtgDivideScalarMode_(ptr *Ctensor, self Ctensor, other Cscalar, roundingMode string)

func AtgDivideScalar_

func AtgDivideScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgDivideTensorMode

func AtgDivideTensorMode(ptr *Ctensor, self Ctensor, other Ctensor, roundingMode string)

func AtgDivideTensorMode_

func AtgDivideTensorMode_(ptr *Ctensor, self Ctensor, other Ctensor, roundingMode string)

func AtgDivide_

func AtgDivide_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgDot

func AtgDot(ptr *Ctensor, self Ctensor, tensor Ctensor)

func AtgDotOut

func AtgDotOut(ptr *Ctensor, out Ctensor, self Ctensor, tensor Ctensor)

func AtgDropout

func AtgDropout(ptr *Ctensor, input Ctensor, p float64, train int32)

func AtgDropout_

func AtgDropout_(ptr *Ctensor, self Ctensor, p float64, train int32)

func AtgDstack

func AtgDstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgDstackOut

func AtgDstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgEig

func AtgEig(ptr *Ctensor, self Ctensor, eigenvectors int32)

func AtgEigE

func AtgEigE(ptr *Ctensor, e Ctensor, v Ctensor, self Ctensor, eigenvectors int32)

func AtgEinsum

func AtgEinsum(ptr *Ctensor, equation string, tensorsData []Ctensor, tensorsLen int)

func AtgElu

func AtgElu(ptr *Ctensor, self Ctensor)

func AtgEluBackward

func AtgEluBackward(ptr *Ctensor, gradOutput Ctensor, alpha Cscalar, scale Cscalar, inputScale Cscalar, isResult int32, selfOrResult Ctensor)

func AtgEluBackwardGradInput

func AtgEluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, alpha Cscalar, scale Cscalar, inputScale Cscalar, isResult int32, selfOrResult Ctensor)

func AtgEluOut

func AtgEluOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgElu_

func AtgElu_(ptr *Ctensor, self Ctensor)

func AtgEmbedding

func AtgEmbedding(ptr *Ctensor, weight Ctensor, indices Ctensor, paddingIdx int64, scaleGradByFreq int32, sparse int32)

func AtgEmbeddingBackward

func AtgEmbeddingBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, numWeights int64, paddingIdx int64, scaleGradByFreq int32, sparse int32)

func AtgEmbeddingBag

func AtgEmbeddingBag(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, scaleGradByFreq int32, mode int64, sparse int32, perSampleWeights Ctensor, includeLastOffset int32)

func AtgEmbeddingBagPaddingIdx

func AtgEmbeddingBagPaddingIdx(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, scaleGradByFreq int32, mode int64, sparse int32, perSampleWeights Ctensor, includeLastOffset int32, paddingIdxVal int64, paddingIdxNull int)

func AtgEmbeddingDenseBackward

func AtgEmbeddingDenseBackward(ptr *Ctensor, gradOutput Ctensor, indices Ctensor, numWeights int64, paddingIdx int64, scaleGradByFreq int32)

func AtgEmbeddingRenorm_

func AtgEmbeddingRenorm_(ptr *Ctensor, self Ctensor, indices Ctensor, maxNorm float64, normType float64)

func AtgEmbeddingSparseBackward

func AtgEmbeddingSparseBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, numWeights int64, paddingIdx int64, scaleGradByFreq int32)

func AtgEmpty

func AtgEmpty(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgEmptyLike

func AtgEmptyLike(ptr *Ctensor, self Ctensor)

func AtgEmptyOut

func AtgEmptyOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)

func AtgEmptyQuantized

func AtgEmptyQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, qtensor Ctensor, optionsKind int32, optionsDevice int32)

func AtgEmptyStrided

func AtgEmptyStrided(ptr *Ctensor, sizeData []int64, sizeLen int, strideData []int64, strideLen int, optionsKind int32, optionsDevice int32)

func AtgEq

func AtgEq(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgEqScalarOut

func AtgEqScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgEqTensor

func AtgEqTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgEqTensorOut

func AtgEqTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgEqTensor_

func AtgEqTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgEq_

func AtgEq_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgEqual

func AtgEqual(self Ctensor, other Ctensor) bool

func AtgErf

func AtgErf(ptr *Ctensor, self Ctensor)

func AtgErfOut

func AtgErfOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgErf_

func AtgErf_(ptr *Ctensor, self Ctensor)

func AtgErfc

func AtgErfc(ptr *Ctensor, self Ctensor)

func AtgErfcOut

func AtgErfcOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgErfc_

func AtgErfc_(ptr *Ctensor, self Ctensor)

func AtgErfinv

func AtgErfinv(ptr *Ctensor, self Ctensor)

func AtgErfinvOut

func AtgErfinvOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgErfinv_

func AtgErfinv_(ptr *Ctensor, self Ctensor)

func AtgExp

func AtgExp(ptr *Ctensor, self Ctensor)

func AtgExp2

func AtgExp2(ptr *Ctensor, self Ctensor)

func AtgExp2Out

func AtgExp2Out(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgExp2_

func AtgExp2_(ptr *Ctensor, self Ctensor)

func AtgExpOut

func AtgExpOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgExp_

func AtgExp_(ptr *Ctensor, self Ctensor)

func AtgExpand

func AtgExpand(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, implicit int32)

func AtgExpandAs

func AtgExpandAs(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgExpm1

func AtgExpm1(ptr *Ctensor, self Ctensor)

func AtgExpm1Out

func AtgExpm1Out(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgExpm1_

func AtgExpm1_(ptr *Ctensor, self Ctensor)

func AtgExponential_

func AtgExponential_(ptr *Ctensor, self Ctensor, lambd float64)

func AtgEye

func AtgEye(ptr *Ctensor, n int64, optionsKind int32, optionsDevice int32)

func AtgEyeM

func AtgEyeM(ptr *Ctensor, n int64, m int64, optionsKind int32, optionsDevice int32)

func AtgEyeMOut

func AtgEyeMOut(ptr *Ctensor, out Ctensor, n int64, m int64)

func AtgEyeOut

func AtgEyeOut(ptr *Ctensor, out Ctensor, n int64)

func AtgFakeQuantizePerChannelAffine

func AtgFakeQuantizePerChannelAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, quantMin int64, quantMax int64)

func AtgFakeQuantizePerChannelAffineCachemask

func AtgFakeQuantizePerChannelAffineCachemask(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, quantMin int64, quantMax int64)

func AtgFakeQuantizePerChannelAffineCachemaskBackward

func AtgFakeQuantizePerChannelAffineCachemaskBackward(ptr *Ctensor, grad Ctensor, mask Ctensor)

func AtgFakeQuantizePerTensorAffine

func AtgFakeQuantizePerTensorAffine(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64, quantMin int64, quantMax int64)

func AtgFakeQuantizePerTensorAffineCachemask

func AtgFakeQuantizePerTensorAffineCachemask(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64, quantMin int64, quantMax int64)

func AtgFakeQuantizePerTensorAffineCachemaskBackward

func AtgFakeQuantizePerTensorAffineCachemaskBackward(ptr *Ctensor, grad Ctensor, mask Ctensor)

func AtgFakeQuantizePerTensorAffineTensorQparams

func AtgFakeQuantizePerTensorAffineTensorQparams(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, quantMin int64, quantMax int64)

func AtgFbgemmLinearFp16Weight

func AtgFbgemmLinearFp16Weight(ptr *Ctensor, input Ctensor, packedWeight Ctensor, bias Ctensor)

func AtgFbgemmLinearFp16WeightFp32Activation

func AtgFbgemmLinearFp16WeightFp32Activation(ptr *Ctensor, input Ctensor, packedWeight Ctensor, bias Ctensor)

func AtgFbgemmLinearInt8Weight

func AtgFbgemmLinearInt8Weight(ptr *Ctensor, input Ctensor, weight Ctensor, packed Ctensor, colOffsets Ctensor, weightScale Cscalar, weightZeroPoint Cscalar, bias Ctensor)

func AtgFbgemmLinearInt8WeightFp32Activation

func AtgFbgemmLinearInt8WeightFp32Activation(ptr *Ctensor, input Ctensor, weight Ctensor, packed Ctensor, colOffsets Ctensor, weightScale Cscalar, weightZeroPoint Cscalar, bias Ctensor)

func AtgFbgemmPackGemmMatrixFp16

func AtgFbgemmPackGemmMatrixFp16(ptr *Ctensor, input Ctensor)

func AtgFbgemmPackQuantizedMatrix

func AtgFbgemmPackQuantizedMatrix(ptr *Ctensor, input Ctensor)

func AtgFbgemmPackQuantizedMatrixKn

func AtgFbgemmPackQuantizedMatrixKn(ptr *Ctensor, input Ctensor, k int64, n int64)

func AtgFeatureAlphaDropout

func AtgFeatureAlphaDropout(ptr *Ctensor, input Ctensor, p float64, train int32)

func AtgFeatureAlphaDropout_

func AtgFeatureAlphaDropout_(ptr *Ctensor, self Ctensor, p float64, train int32)

func AtgFeatureDropout

func AtgFeatureDropout(ptr *Ctensor, input Ctensor, p float64, train int32)

func AtgFeatureDropout_

func AtgFeatureDropout_(ptr *Ctensor, self Ctensor, p float64, train int32)

func AtgFftFft

func AtgFftFft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftFft2

func AtgFftFft2(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftFft2Out

func AtgFftFft2Out(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftFftOut

func AtgFftFftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftFftfreq

func AtgFftFftfreq(ptr *Ctensor, n int64, d float64, optionsKind int32, optionsDevice int32)

func AtgFftFftfreqOut

func AtgFftFftfreqOut(ptr *Ctensor, out Ctensor, n int64, d float64)

func AtgFftFftn

func AtgFftFftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftFftnOut

func AtgFftFftnOut(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftFftshift

func AtgFftFftshift(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int)

func AtgFftHfft

func AtgFftHfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftHfftOut

func AtgFftHfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftIfft

func AtgFftIfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftIfft2

func AtgFftIfft2(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftIfft2Out

func AtgFftIfft2Out(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftIfftOut

func AtgFftIfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftIfftn

func AtgFftIfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftIfftnOut

func AtgFftIfftnOut(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftIfftshift

func AtgFftIfftshift(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int)

func AtgFftIhfft

func AtgFftIhfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftIhfftOut

func AtgFftIhfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftIrfft

func AtgFftIrfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftIrfft2

func AtgFftIrfft2(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftIrfft2Out

func AtgFftIrfft2Out(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftIrfftOut

func AtgFftIrfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftIrfftn

func AtgFftIrfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftIrfftnOut

func AtgFftIrfftnOut(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftRfft

func AtgFftRfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftRfft2

func AtgFftRfft2(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftRfft2Out

func AtgFftRfft2Out(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftRfftOut

func AtgFftRfftOut(ptr *Ctensor, out Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)

func AtgFftRfftfreq

func AtgFftRfftfreq(ptr *Ctensor, n int64, d float64, optionsKind int32, optionsDevice int32)

func AtgFftRfftfreqOut

func AtgFftRfftfreqOut(ptr *Ctensor, out Ctensor, n int64, d float64)

func AtgFftRfftn

func AtgFftRfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFftRfftnOut

func AtgFftRfftnOut(ptr *Ctensor, out Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string)

func AtgFillDiagonal_

func AtgFillDiagonal_(ptr *Ctensor, self Ctensor, fillValue Cscalar, wrap int32)

func AtgFillTensor_

func AtgFillTensor_(ptr *Ctensor, self Ctensor, value Ctensor)

func AtgFill_

func AtgFill_(ptr *Ctensor, self Ctensor, value Cscalar)

func AtgFix

func AtgFix(ptr *Ctensor, self Ctensor)

func AtgFixOut

func AtgFixOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgFix_

func AtgFix_(ptr *Ctensor, self Ctensor)

func AtgFlatten

func AtgFlatten(ptr *Ctensor, self Ctensor, startDim int64, endDim int64)

func AtgFlattenDenseTensors

func AtgFlattenDenseTensors(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgFlip

func AtgFlip(ptr *Ctensor, self Ctensor, dimsData []int64, dimsLen int)

func AtgFliplr

func AtgFliplr(ptr *Ctensor, self Ctensor)

func AtgFlipud

func AtgFlipud(ptr *Ctensor, self Ctensor)

func AtgFloatPower

func AtgFloatPower(ptr *Ctensor, self Ctensor, exponent Ctensor)

func AtgFloatPowerScalar

func AtgFloatPowerScalar(ptr *Ctensor, selfScalar Cscalar, exponent Ctensor)

func AtgFloatPowerScalarOut

func AtgFloatPowerScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, exponent Ctensor)

func AtgFloatPowerTensorScalar

func AtgFloatPowerTensorScalar(ptr *Ctensor, self Ctensor, exponent Cscalar)

func AtgFloatPowerTensorScalarOut

func AtgFloatPowerTensorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Cscalar)

func AtgFloatPowerTensorTensorOut

func AtgFloatPowerTensorTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Ctensor)

func AtgFloatPowerTensor_

func AtgFloatPowerTensor_(ptr *Ctensor, self Ctensor, exponent Ctensor)

func AtgFloatPower_

func AtgFloatPower_(ptr *Ctensor, self Ctensor, exponent Cscalar)

func AtgFloor

func AtgFloor(ptr *Ctensor, self Ctensor)

func AtgFloorDivide

func AtgFloorDivide(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgFloorDivideOut

func AtgFloorDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgFloorDivideScalar

func AtgFloorDivideScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgFloorDivideScalar_

func AtgFloorDivideScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgFloorDivide_

func AtgFloorDivide_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgFloorOut

func AtgFloorOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgFloor_

func AtgFloor_(ptr *Ctensor, self Ctensor)

func AtgFmax

func AtgFmax(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgFmaxOut

func AtgFmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgFmin

func AtgFmin(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgFminOut

func AtgFminOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgFmod

func AtgFmod(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgFmodScalarOut

func AtgFmodScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgFmodTensor

func AtgFmodTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgFmodTensorOut

func AtgFmodTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgFmodTensor_

func AtgFmodTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgFmod_

func AtgFmod_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgFrac

func AtgFrac(ptr *Ctensor, self Ctensor)

func AtgFracOut

func AtgFracOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgFrac_

func AtgFrac_(ptr *Ctensor, self Ctensor)

func AtgFractionalMaxPool2d

func AtgFractionalMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, randomSamples Ctensor)

func AtgFractionalMaxPool2dBackward

func AtgFractionalMaxPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, indices Ctensor)

func AtgFractionalMaxPool2dBackwardGradInput

func AtgFractionalMaxPool2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, indices Ctensor)

func AtgFractionalMaxPool2dOutput

func AtgFractionalMaxPool2dOutput(ptr *Ctensor, output Ctensor, indices Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, randomSamples Ctensor)

func AtgFractionalMaxPool3d

func AtgFractionalMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, randomSamples Ctensor)

func AtgFractionalMaxPool3dBackward

func AtgFractionalMaxPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, indices Ctensor)

func AtgFractionalMaxPool3dBackwardGradInput

func AtgFractionalMaxPool3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, indices Ctensor)

func AtgFractionalMaxPool3dOutput

func AtgFractionalMaxPool3dOutput(ptr *Ctensor, output Ctensor, indices Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, randomSamples Ctensor)

func AtgFrexp

func AtgFrexp(ptr *Ctensor, self Ctensor)

func AtgFrexpTensorOut

func AtgFrexpTensorOut(ptr *Ctensor, mantissa Ctensor, exponent Ctensor, self Ctensor)

func AtgFrobeniusNorm

func AtgFrobeniusNorm(ptr *Ctensor, self Ctensor)

func AtgFrobeniusNormDim

func AtgFrobeniusNormDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgFrobeniusNormOut

func AtgFrobeniusNormOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgFromFile

func AtgFromFile(ptr *Ctensor, filename string, shared int32, sizeVal int64, sizeNull int, optionsKind int32, optionsDevice int32)

func AtgFull

func AtgFull(ptr *Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar, optionsKind int32, optionsDevice int32)

func AtgFullLike

func AtgFullLike(ptr *Ctensor, self Ctensor, fillValue Cscalar)

func AtgFullOut

func AtgFullOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar)

func AtgFusedMovingAvgObsFakeQuant

func AtgFusedMovingAvgObsFakeQuant(ptr *Ctensor, self Ctensor, observerOn Ctensor, fakeQuantOn Ctensor, runningMin Ctensor, runningMax Ctensor, scale Ctensor, zeroPoint Ctensor, averagingConst float64, quantMin int64, quantMax int64, chAxis int64, perRowFakeQuant int32, symmetricQuant int32)

func AtgGather

func AtgGather(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, sparseGrad int32)

func AtgGatherBackward

func AtgGatherBackward(ptr *Ctensor, grad Ctensor, self Ctensor, dim int64, index Ctensor, sparseGrad int32)

func AtgGatherOut

func AtgGatherOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, sparseGrad int32)

func AtgGcd

func AtgGcd(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGcdOut

func AtgGcdOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgGcd_

func AtgGcd_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGe

func AtgGe(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgGeScalarOut

func AtgGeScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgGeTensor

func AtgGeTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGeTensorOut

func AtgGeTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgGeTensor_

func AtgGeTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGe_

func AtgGe_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgGelu

func AtgGelu(ptr *Ctensor, self Ctensor)

func AtgGeluBackward

func AtgGeluBackward(ptr *Ctensor, grad Ctensor, self Ctensor)

func AtgGeluBackwardGradInput

func AtgGeluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, grad Ctensor, self Ctensor)

func AtgGeluOut

func AtgGeluOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgGeometric_

func AtgGeometric_(ptr *Ctensor, self Ctensor, p float64)

func AtgGeqrf

func AtgGeqrf(ptr *Ctensor, self Ctensor)

func AtgGeqrfA

func AtgGeqrfA(ptr *Ctensor, a Ctensor, tau Ctensor, self Ctensor)

func AtgGer

func AtgGer(ptr *Ctensor, self Ctensor, vec2 Ctensor)

func AtgGerOut

func AtgGerOut(ptr *Ctensor, out Ctensor, self Ctensor, vec2 Ctensor)

func AtgGlu

func AtgGlu(ptr *Ctensor, self Ctensor, dim int64)

func AtgGluBackward

func AtgGluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, dim int64)

func AtgGluBackwardGradInput

func AtgGluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, dim int64)

func AtgGluOut

func AtgGluOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64)

func AtgGrad

func AtgGrad(ptr *Ctensor, self Ctensor)

func AtgGreater

func AtgGreater(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgGreaterEqual

func AtgGreaterEqual(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgGreaterEqualScalarOut

func AtgGreaterEqualScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgGreaterEqualTensor

func AtgGreaterEqualTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGreaterEqualTensorOut

func AtgGreaterEqualTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgGreaterEqualTensor_

func AtgGreaterEqualTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGreaterEqual_

func AtgGreaterEqual_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgGreaterScalarOut

func AtgGreaterScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgGreaterTensor

func AtgGreaterTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGreaterTensorOut

func AtgGreaterTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgGreaterTensor_

func AtgGreaterTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGreater_

func AtgGreater_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgGridSampler

func AtgGridSampler(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32)

func AtgGridSampler2d

func AtgGridSampler2d(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32)

func AtgGridSampler2dBackward

func AtgGridSampler2dBackward(ptr *Ctensor, gradOutput Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32)

func AtgGridSampler3d

func AtgGridSampler3d(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32)

func AtgGridSampler3dBackward

func AtgGridSampler3dBackward(ptr *Ctensor, gradOutput Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32)

func AtgGroupNorm

func AtgGroupNorm(ptr *Ctensor, input Ctensor, numGroups int64, weight Ctensor, bias Ctensor, eps float64, cudnnEnabled int32)

func AtgGru

func AtgGru(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32, batchFirst int32)

func AtgGruCell

func AtgGruCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor)

func AtgGruData

func AtgGruData(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32)

func AtgGt

func AtgGt(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgGtScalarOut

func AtgGtScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgGtTensor

func AtgGtTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGtTensorOut

func AtgGtTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgGtTensor_

func AtgGtTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgGt_

func AtgGt_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgHammingWindow

func AtgHammingWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)

func AtgHammingWindowPeriodic

func AtgHammingWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32)

func AtgHammingWindowPeriodicAlpha

func AtgHammingWindowPeriodicAlpha(ptr *Ctensor, windowLength int64, periodic int32, alpha float64, optionsKind int32, optionsDevice int32)

func AtgHammingWindowPeriodicAlphaBeta

func AtgHammingWindowPeriodicAlphaBeta(ptr *Ctensor, windowLength int64, periodic int32, alpha float64, beta float64, optionsKind int32, optionsDevice int32)

func AtgHannWindow

func AtgHannWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)

func AtgHannWindowPeriodic

func AtgHannWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32)

func AtgHardshrink

func AtgHardshrink(ptr *Ctensor, self Ctensor)

func AtgHardshrinkBackward

func AtgHardshrinkBackward(ptr *Ctensor, gradOut Ctensor, self Ctensor, lambd Cscalar)

func AtgHardshrinkBackwardGradInput

func AtgHardshrinkBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOut Ctensor, self Ctensor, lambd Cscalar)

func AtgHardshrinkOut

func AtgHardshrinkOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgHardsigmoid

func AtgHardsigmoid(ptr *Ctensor, self Ctensor)

func AtgHardsigmoidBackward

func AtgHardsigmoidBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)

func AtgHardsigmoidBackwardGradInput

func AtgHardsigmoidBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor)

func AtgHardsigmoidOut

func AtgHardsigmoidOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgHardsigmoid_

func AtgHardsigmoid_(ptr *Ctensor, self Ctensor)

func AtgHardswish

func AtgHardswish(ptr *Ctensor, self Ctensor)

func AtgHardswishBackward

func AtgHardswishBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)

func AtgHardswishOut

func AtgHardswishOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgHardswish_

func AtgHardswish_(ptr *Ctensor, self Ctensor)

func AtgHardtanh

func AtgHardtanh(ptr *Ctensor, self Ctensor)

func AtgHardtanhBackward

func AtgHardtanhBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, minVal Cscalar, maxVal Cscalar)

func AtgHardtanhBackwardGradInput

func AtgHardtanhBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, minVal Cscalar, maxVal Cscalar)

func AtgHardtanhOut

func AtgHardtanhOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgHardtanh_

func AtgHardtanh_(ptr *Ctensor, self Ctensor)

func AtgHeaviside

func AtgHeaviside(ptr *Ctensor, self Ctensor, values Ctensor)

func AtgHeavisideOut

func AtgHeavisideOut(ptr *Ctensor, out Ctensor, self Ctensor, values Ctensor)

func AtgHeaviside_

func AtgHeaviside_(ptr *Ctensor, self Ctensor, values Ctensor)

func AtgHingeEmbeddingLoss

func AtgHingeEmbeddingLoss(ptr *Ctensor, self Ctensor, target Ctensor, margin float64, reduction int64)

func AtgHistc

func AtgHistc(ptr *Ctensor, self Ctensor, bins int64)

func AtgHistcOut

func AtgHistcOut(ptr *Ctensor, out Ctensor, self Ctensor, bins int64)

func AtgHspmm

func AtgHspmm(ptr *Ctensor, mat1 Ctensor, mat2 Ctensor)

func AtgHspmmOut

func AtgHspmmOut(ptr *Ctensor, out Ctensor, mat1 Ctensor, mat2 Ctensor)

func AtgHstack

func AtgHstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgHstackOut

func AtgHstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgHuberLoss

func AtgHuberLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64, delta float64)

func AtgHuberLossBackward

func AtgHuberLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, delta float64)

func AtgHuberLossBackwardOut

func AtgHuberLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, delta float64)

func AtgHuberLossOut

func AtgHuberLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64, delta float64)

func AtgHypot

func AtgHypot(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgHypotOut

func AtgHypotOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgHypot_

func AtgHypot_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgI0

func AtgI0(ptr *Ctensor, self Ctensor)

func AtgI0Out

func AtgI0Out(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgI0_

func AtgI0_(ptr *Ctensor, self Ctensor)

func AtgIgamma

func AtgIgamma(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgIgammaOut

func AtgIgammaOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgIgamma_

func AtgIgamma_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgIgammac

func AtgIgammac(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgIgammacOut

func AtgIgammacOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgIgammac_

func AtgIgammac_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgIm2col

func AtgIm2col(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int)

func AtgIm2colBackward

func AtgIm2colBackward(ptr *Ctensor, gradOutput Ctensor, inputSizeData []int64, inputSizeLen int, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int)

func AtgIm2colBackwardGradInput

func AtgIm2colBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, inputSizeData []int64, inputSizeLen int, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int)

func AtgIm2colOut

func AtgIm2colOut(ptr *Ctensor, out Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int)

func AtgImag

func AtgImag(ptr *Ctensor, self Ctensor)

func AtgIndex

func AtgIndex(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int)

func AtgIndexAdd

func AtgIndexAdd(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)

func AtgIndexAddAlpha

func AtgIndexAddAlpha(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor, alpha Cscalar)

func AtgIndexAddAlpha_

func AtgIndexAddAlpha_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor, alpha Cscalar)

func AtgIndexAdd_

func AtgIndexAdd_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)

func AtgIndexCopy

func AtgIndexCopy(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)

func AtgIndexCopy_

func AtgIndexCopy_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)

func AtgIndexFill

func AtgIndexFill(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)

func AtgIndexFillIntTensor

func AtgIndexFillIntTensor(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Ctensor)

func AtgIndexFillIntTensor_

func AtgIndexFillIntTensor_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Ctensor)

func AtgIndexFill_

func AtgIndexFill_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)

func AtgIndexPut

func AtgIndexPut(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, values Ctensor, accumulate int32)

func AtgIndexPut_

func AtgIndexPut_(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, values Ctensor, accumulate int32)

func AtgIndexSelect

func AtgIndexSelect(ptr *Ctensor, self Ctensor, dim int64, index Ctensor)

func AtgIndexSelectBackward

func AtgIndexSelectBackward(ptr *Ctensor, grad Ctensor, selfSizesData []int64, selfSizesLen int, dim int64, index Ctensor)

func AtgIndexSelectOut

func AtgIndexSelectOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor)

func AtgIndices

func AtgIndices(ptr *Ctensor, self Ctensor)

func AtgInfinitelyDifferentiableGeluBackward

func AtgInfinitelyDifferentiableGeluBackward(ptr *Ctensor, grad Ctensor, self Ctensor)

func AtgInner

func AtgInner(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgInnerOut

func AtgInnerOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgInstanceNorm

func AtgInstanceNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, useInputStats int32, momentum float64, eps float64, cudnnEnabled int32)

func AtgIntRepr

func AtgIntRepr(ptr *Ctensor, self Ctensor)

func AtgInverse

func AtgInverse(ptr *Ctensor, self Ctensor)

func AtgInverseOut

func AtgInverseOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgIsCoalesced

func AtgIsCoalesced(self Ctensor) bool

func AtgIsComplex

func AtgIsComplex(self Ctensor) bool

func AtgIsConj

func AtgIsConj(self Ctensor) bool

func AtgIsDistributed

func AtgIsDistributed(self Ctensor) bool

func AtgIsFloatingPoint

func AtgIsFloatingPoint(self Ctensor) bool

func AtgIsInference

func AtgIsInference(self Ctensor) bool

func AtgIsLeaf

func AtgIsLeaf(self Ctensor) bool

func AtgIsNeg

func AtgIsNeg(self Ctensor) bool

func AtgIsNonzero

func AtgIsNonzero(self Ctensor) bool

func AtgIsPinned

func AtgIsPinned(self Ctensor, device int32) bool

func AtgIsSameSize

func AtgIsSameSize(self Ctensor, other Ctensor) bool

func AtgIsSetTo

func AtgIsSetTo(self Ctensor, tensor Ctensor) bool

func AtgIsSigned

func AtgIsSigned(self Ctensor) bool

func AtgIsVulkanAvailable

func AtgIsVulkanAvailable() bool

func AtgIsclose

func AtgIsclose(ptr *Ctensor, self Ctensor, other Ctensor, rtol float64, atol float64, equalNan int32)

func AtgIsfinite

func AtgIsfinite(ptr *Ctensor, self Ctensor)

func AtgIsin

func AtgIsin(ptr *Ctensor, elements Ctensor, testElements Ctensor, assumeUnique int32, invert int32)

func AtgIsinScalarTensor

func AtgIsinScalarTensor(ptr *Ctensor, element Cscalar, testElements Ctensor, assumeUnique int32, invert int32)

func AtgIsinScalarTensorOut

func AtgIsinScalarTensorOut(ptr *Ctensor, out Ctensor, element Cscalar, testElements Ctensor, assumeUnique int32, invert int32)

func AtgIsinTensorScalar

func AtgIsinTensorScalar(ptr *Ctensor, elements Ctensor, testElement Cscalar, assumeUnique int32, invert int32)

func AtgIsinTensorScalarOut

func AtgIsinTensorScalarOut(ptr *Ctensor, out Ctensor, elements Ctensor, testElement Cscalar, assumeUnique int32, invert int32)

func AtgIsinTensorTensorOut

func AtgIsinTensorTensorOut(ptr *Ctensor, out Ctensor, elements Ctensor, testElements Ctensor, assumeUnique int32, invert int32)

func AtgIsinf

func AtgIsinf(ptr *Ctensor, self Ctensor)

func AtgIsnan

func AtgIsnan(ptr *Ctensor, self Ctensor)

func AtgIsneginf

func AtgIsneginf(ptr *Ctensor, self Ctensor)

func AtgIsneginfOut

func AtgIsneginfOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgIsposinf

func AtgIsposinf(ptr *Ctensor, self Ctensor)

func AtgIsposinfOut

func AtgIsposinfOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgIsreal

func AtgIsreal(ptr *Ctensor, self Ctensor)

func AtgIstft

func AtgIstft(ptr *Ctensor, self Ctensor, nFft int64, hopLengthVal int64, hopLengthNull int, winLengthVal int64, winLengthNull int, window Ctensor, center int32, normalized int32, onesided int32, lengthVal int64, lengthNull int, returnComplex int32)

func AtgKaiserWindow

func AtgKaiserWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)

func AtgKaiserWindowBeta

func AtgKaiserWindowBeta(ptr *Ctensor, windowLength int64, periodic int32, beta float64, optionsKind int32, optionsDevice int32)

func AtgKaiserWindowPeriodic

func AtgKaiserWindowPeriodic(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32)

func AtgKlDiv

func AtgKlDiv(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64, logTarget int32)

func AtgKlDivBackward

func AtgKlDivBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, logTarget int32)

func AtgKron

func AtgKron(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgKronOut

func AtgKronOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgKthvalue

func AtgKthvalue(ptr *Ctensor, self Ctensor, k int64, dim int64, keepdim int32)

func AtgKthvalueValues

func AtgKthvalueValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, k int64, dim int64, keepdim int32)

func AtgL1Loss

func AtgL1Loss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgL1LossBackward

func AtgL1LossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgL1LossBackwardGradInput

func AtgL1LossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgL1LossOut

func AtgL1LossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgLayerNorm

func AtgLayerNorm(ptr *Ctensor, input Ctensor, normalizedShapeData []int64, normalizedShapeLen int, weight Ctensor, bias Ctensor, eps float64, cudnnEnable int32)

func AtgLcm

func AtgLcm(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLcmOut

func AtgLcmOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLcm_

func AtgLcm_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLdexp

func AtgLdexp(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLdexpOut

func AtgLdexpOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLdexp_

func AtgLdexp_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLe

func AtgLe(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgLeScalarOut

func AtgLeScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgLeTensor

func AtgLeTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLeTensorOut

func AtgLeTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLeTensor_

func AtgLeTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLe_

func AtgLe_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgLeakyRelu

func AtgLeakyRelu(ptr *Ctensor, self Ctensor)

func AtgLeakyReluBackward

func AtgLeakyReluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, negativeSlope Cscalar, selfIsResult int32)

func AtgLeakyReluBackwardGradInput

func AtgLeakyReluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, negativeSlope Cscalar, selfIsResult int32)

func AtgLeakyReluOut

func AtgLeakyReluOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLeakyRelu_

func AtgLeakyRelu_(ptr *Ctensor, self Ctensor)

func AtgLerp

func AtgLerp(ptr *Ctensor, self Ctensor, end Ctensor, weight Cscalar)

func AtgLerpScalarOut

func AtgLerpScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, end Ctensor, weight Cscalar)

func AtgLerpTensor

func AtgLerpTensor(ptr *Ctensor, self Ctensor, end Ctensor, weight Ctensor)

func AtgLerpTensorOut

func AtgLerpTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, end Ctensor, weight Ctensor)

func AtgLerpTensor_

func AtgLerpTensor_(ptr *Ctensor, self Ctensor, end Ctensor, weight Ctensor)

func AtgLerp_

func AtgLerp_(ptr *Ctensor, self Ctensor, end Ctensor, weight Cscalar)

func AtgLess

func AtgLess(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgLessEqual

func AtgLessEqual(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgLessEqualScalarOut

func AtgLessEqualScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgLessEqualTensor

func AtgLessEqualTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLessEqualTensorOut

func AtgLessEqualTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLessEqualTensor_

func AtgLessEqualTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLessEqual_

func AtgLessEqual_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgLessScalarOut

func AtgLessScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgLessTensor

func AtgLessTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLessTensorOut

func AtgLessTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLessTensor_

func AtgLessTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLess_

func AtgLess_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgLgamma

func AtgLgamma(ptr *Ctensor, self Ctensor)

func AtgLgammaOut

func AtgLgammaOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLgamma_

func AtgLgamma_(ptr *Ctensor, self Ctensor)

func AtgLinalgCholesky

func AtgLinalgCholesky(ptr *Ctensor, self Ctensor, upper int32)

func AtgLinalgCholeskyEx

func AtgLinalgCholeskyEx(ptr *Ctensor, self Ctensor, upper int32, checkErrors int32)

func AtgLinalgCholeskyExL

func AtgLinalgCholeskyExL(ptr *Ctensor, l Ctensor, info Ctensor, self Ctensor, upper int32, checkErrors int32)

func AtgLinalgCholeskyOut

func AtgLinalgCholeskyOut(ptr *Ctensor, out Ctensor, self Ctensor, upper int32)

func AtgLinalgCond

func AtgLinalgCond(ptr *Ctensor, self Ctensor, p Cscalar)

func AtgLinalgCondOut

func AtgLinalgCondOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar)

func AtgLinalgCondPStr

func AtgLinalgCondPStr(ptr *Ctensor, self Ctensor, p string)

func AtgLinalgCondPStrOut

func AtgLinalgCondPStrOut(ptr *Ctensor, out Ctensor, self Ctensor, p string)

func AtgLinalgDet

func AtgLinalgDet(ptr *Ctensor, self Ctensor)

func AtgLinalgDetOut

func AtgLinalgDetOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLinalgEig

func AtgLinalgEig(ptr *Ctensor, self Ctensor)

func AtgLinalgEigOut

func AtgLinalgEigOut(ptr *Ctensor, eigenvalues Ctensor, eigenvectors Ctensor, self Ctensor)

func AtgLinalgEigh

func AtgLinalgEigh(ptr *Ctensor, self Ctensor, uPLO string)

func AtgLinalgEighEigvals

func AtgLinalgEighEigvals(ptr *Ctensor, eigvals Ctensor, eigvecs Ctensor, self Ctensor, uPLO string)

func AtgLinalgEigvals

func AtgLinalgEigvals(ptr *Ctensor, self Ctensor)

func AtgLinalgEigvalsOut

func AtgLinalgEigvalsOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLinalgEigvalsh

func AtgLinalgEigvalsh(ptr *Ctensor, self Ctensor, uPLO string)

func AtgLinalgEigvalshOut

func AtgLinalgEigvalshOut(ptr *Ctensor, out Ctensor, self Ctensor, uPLO string)

func AtgLinalgHouseholderProduct

func AtgLinalgHouseholderProduct(ptr *Ctensor, input Ctensor, tau Ctensor)

func AtgLinalgHouseholderProductOut

func AtgLinalgHouseholderProductOut(ptr *Ctensor, out Ctensor, input Ctensor, tau Ctensor)

func AtgLinalgInv

func AtgLinalgInv(ptr *Ctensor, self Ctensor)

func AtgLinalgInvEx

func AtgLinalgInvEx(ptr *Ctensor, self Ctensor, checkErrors int32)

func AtgLinalgInvExInverse

func AtgLinalgInvExInverse(ptr *Ctensor, inverse Ctensor, info Ctensor, self Ctensor, checkErrors int32)

func AtgLinalgInvOut

func AtgLinalgInvOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLinalgLstsq

func AtgLinalgLstsq(ptr *Ctensor, self Ctensor, b Ctensor, rcondVal float64, rcondNull int, driver string)

func AtgLinalgLstsqOut

func AtgLinalgLstsqOut(ptr *Ctensor, solution Ctensor, residuals Ctensor, rank Ctensor, singularValues Ctensor, self Ctensor, b Ctensor, rcondVal float64, rcondNull int, driver string)

func AtgLinalgMatmul

func AtgLinalgMatmul(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLinalgMatmulOut

func AtgLinalgMatmulOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLinalgMatrixPower

func AtgLinalgMatrixPower(ptr *Ctensor, self Ctensor, n int64)

func AtgLinalgMatrixPowerOut

func AtgLinalgMatrixPowerOut(ptr *Ctensor, out Ctensor, self Ctensor, n int64)

func AtgLinalgMatrixRank

func AtgLinalgMatrixRank(ptr *Ctensor, self Ctensor, tolVal float64, tolNull int, hermitian int32)

func AtgLinalgMatrixRankOut

func AtgLinalgMatrixRankOut(ptr *Ctensor, out Ctensor, self Ctensor, tolVal float64, tolNull int, hermitian int32)

func AtgLinalgMatrixRankOutTolTensor

func AtgLinalgMatrixRankOutTolTensor(ptr *Ctensor, out Ctensor, input Ctensor, tol Ctensor, hermitian int32)

func AtgLinalgMatrixRankTolTensor

func AtgLinalgMatrixRankTolTensor(ptr *Ctensor, input Ctensor, tol Ctensor, hermitian int32)

func AtgLinalgMultiDot

func AtgLinalgMultiDot(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgLinalgMultiDotOut

func AtgLinalgMultiDotOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgLinalgNorm

func AtgLinalgNorm(ptr *Ctensor, self Ctensor, ord Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgLinalgNormOrdStr

func AtgLinalgNormOrdStr(ptr *Ctensor, self Ctensor, ord string, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgLinalgNormOrdStrOut

func AtgLinalgNormOrdStrOut(ptr *Ctensor, out Ctensor, self Ctensor, ord string, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgLinalgNormOut

func AtgLinalgNormOut(ptr *Ctensor, out Ctensor, self Ctensor, ord Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgLinalgPinv

func AtgLinalgPinv(ptr *Ctensor, self Ctensor, rcond float64, hermitian int32)

func AtgLinalgPinvOut

func AtgLinalgPinvOut(ptr *Ctensor, out Ctensor, self Ctensor, rcond float64, hermitian int32)

func AtgLinalgPinvOutRcondTensor

func AtgLinalgPinvOutRcondTensor(ptr *Ctensor, out Ctensor, self Ctensor, rcond Ctensor, hermitian int32)

func AtgLinalgPinvRcondTensor

func AtgLinalgPinvRcondTensor(ptr *Ctensor, self Ctensor, rcond Ctensor, hermitian int32)

func AtgLinalgQr

func AtgLinalgQr(ptr *Ctensor, self Ctensor, mode string)

func AtgLinalgQrOut

func AtgLinalgQrOut(ptr *Ctensor, q Ctensor, r Ctensor, self Ctensor, mode string)

func AtgLinalgSlogdet

func AtgLinalgSlogdet(ptr *Ctensor, self Ctensor)

func AtgLinalgSlogdetOut

func AtgLinalgSlogdetOut(ptr *Ctensor, sign Ctensor, logabsdet Ctensor, self Ctensor)

func AtgLinalgSolve

func AtgLinalgSolve(ptr *Ctensor, input Ctensor, other Ctensor)

func AtgLinalgSolveOut

func AtgLinalgSolveOut(ptr *Ctensor, out Ctensor, input Ctensor, other Ctensor)

func AtgLinalgSvd

func AtgLinalgSvd(ptr *Ctensor, self Ctensor, fullMatrices int32)

func AtgLinalgSvdU

func AtgLinalgSvdU(ptr *Ctensor, u Ctensor, s Ctensor, vh Ctensor, self Ctensor, fullMatrices int32)

func AtgLinalgSvdvals

func AtgLinalgSvdvals(ptr *Ctensor, input Ctensor)

func AtgLinalgSvdvalsOut

func AtgLinalgSvdvalsOut(ptr *Ctensor, out Ctensor, input Ctensor)

func AtgLinalgTensorinv

func AtgLinalgTensorinv(ptr *Ctensor, self Ctensor, ind int64)

func AtgLinalgTensorinvOut

func AtgLinalgTensorinvOut(ptr *Ctensor, out Ctensor, self Ctensor, ind int64)

func AtgLinalgTensorsolve

func AtgLinalgTensorsolve(ptr *Ctensor, self Ctensor, other Ctensor, dimsData []int64, dimsLen int)

func AtgLinalgTensorsolveOut

func AtgLinalgTensorsolveOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, dimsData []int64, dimsLen int)

func AtgLinear

func AtgLinear(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor)

func AtgLinearOut

func AtgLinearOut(ptr *Ctensor, out Ctensor, input Ctensor, weight Ctensor, bias Ctensor)

func AtgLinspace

func AtgLinspace(ptr *Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int, optionsKind int32, optionsDevice int32)

func AtgLinspaceOut

func AtgLinspaceOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int)

func AtgLog

func AtgLog(ptr *Ctensor, self Ctensor)

func AtgLog10

func AtgLog10(ptr *Ctensor, self Ctensor)

func AtgLog10Out

func AtgLog10Out(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLog10_

func AtgLog10_(ptr *Ctensor, self Ctensor)

func AtgLog1p

func AtgLog1p(ptr *Ctensor, self Ctensor)

func AtgLog1pOut

func AtgLog1pOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLog1p_

func AtgLog1p_(ptr *Ctensor, self Ctensor)

func AtgLog2

func AtgLog2(ptr *Ctensor, self Ctensor)

func AtgLog2Out

func AtgLog2Out(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLog2_

func AtgLog2_(ptr *Ctensor, self Ctensor)

func AtgLogNormal_

func AtgLogNormal_(ptr *Ctensor, self Ctensor, mean float64, std float64)

func AtgLogOut

func AtgLogOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLogSigmoid

func AtgLogSigmoid(ptr *Ctensor, self Ctensor)

func AtgLogSigmoidBackward

func AtgLogSigmoidBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, buffer Ctensor)

func AtgLogSigmoidBackwardGradInput

func AtgLogSigmoidBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, buffer Ctensor)

func AtgLogSigmoidOut

func AtgLogSigmoidOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLogSoftmax

func AtgLogSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32)

func AtgLog_

func AtgLog_(ptr *Ctensor, self Ctensor)

func AtgLogaddexp

func AtgLogaddexp(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLogaddexp2

func AtgLogaddexp2(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLogaddexp2Out

func AtgLogaddexp2Out(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLogaddexpOut

func AtgLogaddexpOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLogcumsumexp

func AtgLogcumsumexp(ptr *Ctensor, self Ctensor, dim int64)

func AtgLogcumsumexpOut

func AtgLogcumsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64)

func AtgLogdet

func AtgLogdet(ptr *Ctensor, self Ctensor)

func AtgLogicalAnd

func AtgLogicalAnd(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLogicalAndOut

func AtgLogicalAndOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLogicalAnd_

func AtgLogicalAnd_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLogicalNot

func AtgLogicalNot(ptr *Ctensor, self Ctensor)

func AtgLogicalNotOut

func AtgLogicalNotOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgLogicalNot_

func AtgLogicalNot_(ptr *Ctensor, self Ctensor)

func AtgLogicalOr

func AtgLogicalOr(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLogicalOrOut

func AtgLogicalOrOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLogicalOr_

func AtgLogicalOr_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLogicalXor

func AtgLogicalXor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLogicalXorOut

func AtgLogicalXorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLogicalXor_

func AtgLogicalXor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLogit

func AtgLogit(ptr *Ctensor, self Ctensor, epsVal float64, epsNull int)

func AtgLogitBackward

func AtgLogitBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, epsVal float64, epsNull int)

func AtgLogitBackwardGradInput

func AtgLogitBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, epsVal float64, epsNull int)

func AtgLogitOut

func AtgLogitOut(ptr *Ctensor, out Ctensor, self Ctensor, epsVal float64, epsNull int)

func AtgLogit_

func AtgLogit_(ptr *Ctensor, self Ctensor, epsVal float64, epsNull int)

func AtgLogspace

func AtgLogspace(ptr *Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int, base float64, optionsKind int32, optionsDevice int32)

func AtgLogspaceOut

func AtgLogspaceOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int, base float64)

func AtgLogsumexp

func AtgLogsumexp(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgLogsumexpOut

func AtgLogsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgLstm

func AtgLstm(ptr *Ctensor, input Ctensor, hxData []Ctensor, hxLen int, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32, batchFirst int32)

func AtgLstmCell

func AtgLstmCell(ptr *Ctensor, input Ctensor, hxData []Ctensor, hxLen int, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor)

func AtgLstmData

func AtgLstmData(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hxData []Ctensor, hxLen int, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32)

func AtgLstsq

func AtgLstsq(ptr *Ctensor, self Ctensor, a Ctensor)

func AtgLstsqX

func AtgLstsqX(ptr *Ctensor, x Ctensor, qr Ctensor, self Ctensor, a Ctensor)

func AtgLt

func AtgLt(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgLtScalarOut

func AtgLtScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgLtTensor

func AtgLtTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLtTensorOut

func AtgLtTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgLtTensor_

func AtgLtTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgLt_

func AtgLt_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgLuSolve

func AtgLuSolve(ptr *Ctensor, self Ctensor, lUData Ctensor, lUPivots Ctensor)

func AtgLuSolveOut

func AtgLuSolveOut(ptr *Ctensor, out Ctensor, self Ctensor, lUData Ctensor, lUPivots Ctensor)

func AtgLuUnpack

func AtgLuUnpack(ptr *Ctensor, lUData Ctensor, lUPivots Ctensor, unpackData int32, unpackPivots int32)

func AtgLuUnpackOut

func AtgLuUnpackOut(ptr *Ctensor, p Ctensor, l Ctensor, u Ctensor, lUData Ctensor, lUPivots Ctensor, unpackData int32, unpackPivots int32)

func AtgMarginRankingLoss

func AtgMarginRankingLoss(ptr *Ctensor, input1 Ctensor, input2 Ctensor, target Ctensor, margin float64, reduction int64)

func AtgMaskedFill

func AtgMaskedFill(ptr *Ctensor, self Ctensor, mask Ctensor, value Cscalar)

func AtgMaskedFillTensor

func AtgMaskedFillTensor(ptr *Ctensor, self Ctensor, mask Ctensor, value Ctensor)

func AtgMaskedFillTensor_

func AtgMaskedFillTensor_(ptr *Ctensor, self Ctensor, mask Ctensor, value Ctensor)

func AtgMaskedFill_

func AtgMaskedFill_(ptr *Ctensor, self Ctensor, mask Ctensor, value Cscalar)

func AtgMaskedScatter

func AtgMaskedScatter(ptr *Ctensor, self Ctensor, mask Ctensor, source Ctensor)

func AtgMaskedScatter_

func AtgMaskedScatter_(ptr *Ctensor, self Ctensor, mask Ctensor, source Ctensor)

func AtgMaskedSelect

func AtgMaskedSelect(ptr *Ctensor, self Ctensor, mask Ctensor)

func AtgMaskedSelectBackward

func AtgMaskedSelectBackward(ptr *Ctensor, grad Ctensor, input Ctensor, mask Ctensor)

func AtgMaskedSelectOut

func AtgMaskedSelectOut(ptr *Ctensor, out Ctensor, self Ctensor, mask Ctensor)

func AtgMatmul

func AtgMatmul(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgMatmulOut

func AtgMatmulOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgMatrixExp

func AtgMatrixExp(ptr *Ctensor, self Ctensor)

func AtgMatrixExpBackward

func AtgMatrixExpBackward(ptr *Ctensor, self Ctensor, grad Ctensor)

func AtgMatrixPower

func AtgMatrixPower(ptr *Ctensor, self Ctensor, n int64)

func AtgMatrixPowerOut

func AtgMatrixPowerOut(ptr *Ctensor, out Ctensor, self Ctensor, n int64)

func AtgMatrixRank

func AtgMatrixRank(ptr *Ctensor, self Ctensor, symmetric int32)

func AtgMatrixRankTol

func AtgMatrixRankTol(ptr *Ctensor, self Ctensor, tol float64, symmetric int32)

func AtgMax

func AtgMax(ptr *Ctensor, self Ctensor)

func AtgMaxDim

func AtgMaxDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgMaxDimMax

func AtgMaxDimMax(ptr *Ctensor, max Ctensor, maxValues Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgMaxOther

func AtgMaxOther(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgMaxOut

func AtgMaxOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgMaxPool1d

func AtgMaxPool1d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMaxPool1dWithIndices

func AtgMaxPool1dWithIndices(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMaxPool2d

func AtgMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMaxPool2dWithIndices

func AtgMaxPool2dWithIndices(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMaxPool2dWithIndicesBackward

func AtgMaxPool2dWithIndicesBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32, indices Ctensor)

func AtgMaxPool2dWithIndicesBackwardGradInput

func AtgMaxPool2dWithIndicesBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32, indices Ctensor)

func AtgMaxPool2dWithIndicesOut

func AtgMaxPool2dWithIndicesOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMaxPool3d

func AtgMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMaxPool3dWithIndices

func AtgMaxPool3dWithIndices(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMaxPool3dWithIndicesBackward

func AtgMaxPool3dWithIndicesBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32, indices Ctensor)

func AtgMaxPool3dWithIndicesBackwardGradInput

func AtgMaxPool3dWithIndicesBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32, indices Ctensor)

func AtgMaxPool3dWithIndicesOut

func AtgMaxPool3dWithIndicesOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMaxUnpool2d

func AtgMaxUnpool2d(ptr *Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgMaxUnpool2dBackward

func AtgMaxUnpool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgMaxUnpool2dBackwardGradInput

func AtgMaxUnpool2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgMaxUnpool2dOut

func AtgMaxUnpool2dOut(ptr *Ctensor, out Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgMaxUnpool3d

func AtgMaxUnpool3d(ptr *Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int)

func AtgMaxUnpool3dBackward

func AtgMaxUnpool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int)

func AtgMaxUnpool3dBackwardGradInput

func AtgMaxUnpool3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int)

func AtgMaxUnpool3dOut

func AtgMaxUnpool3dOut(ptr *Ctensor, out Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int)

func AtgMaximum

func AtgMaximum(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgMaximumOut

func AtgMaximumOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgMean

func AtgMean(ptr *Ctensor, self Ctensor, dtype int32)

func AtgMeanDim

func AtgMeanDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgMeanOut

func AtgMeanOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgMedian

func AtgMedian(ptr *Ctensor, self Ctensor)

func AtgMedianDim

func AtgMedianDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgMedianDimValues

func AtgMedianDimValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgMin

func AtgMin(ptr *Ctensor, self Ctensor)

func AtgMinDim

func AtgMinDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgMinDimMin

func AtgMinDimMin(ptr *Ctensor, min Ctensor, minIndices Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgMinOther

func AtgMinOther(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgMinOut

func AtgMinOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgMinimum

func AtgMinimum(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgMinimumOut

func AtgMinimumOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgMiopenBatchNorm

func AtgMiopenBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, exponentialAverageFactor float64, epsilon float64)

func AtgMiopenBatchNormBackward

func AtgMiopenBatchNormBackward(ptr *Ctensor, input Ctensor, gradOutput Ctensor, weight Ctensor, runningMean Ctensor, runningVar Ctensor, saveMean Ctensor, saveVar Ctensor, epsilon float64)

func AtgMiopenConvolution

func AtgMiopenConvolution(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgMiopenConvolutionBackwardBias

func AtgMiopenConvolutionBackwardBias(ptr *Ctensor, gradOutput Ctensor)

func AtgMiopenConvolutionBackwardInput

func AtgMiopenConvolutionBackwardInput(ptr *Ctensor, selfSizeData []int64, selfSizeLen int, gradOutput Ctensor, weight Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgMiopenConvolutionBackwardWeight

func AtgMiopenConvolutionBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgMiopenConvolutionTranspose

func AtgMiopenConvolutionTranspose(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgMiopenConvolutionTransposeBackwardInput

func AtgMiopenConvolutionTransposeBackwardInput(ptr *Ctensor, gradOutput Ctensor, weight Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgMiopenConvolutionTransposeBackwardWeight

func AtgMiopenConvolutionTransposeBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgMiopenDepthwiseConvolution

func AtgMiopenDepthwiseConvolution(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgMiopenDepthwiseConvolutionBackwardInput

func AtgMiopenDepthwiseConvolutionBackwardInput(ptr *Ctensor, selfSizeData []int64, selfSizeLen int, gradOutput Ctensor, weight Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgMiopenDepthwiseConvolutionBackwardWeight

func AtgMiopenDepthwiseConvolutionBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, benchmark int32, deterministic int32)

func AtgMiopenRnn

func AtgMiopenRnn(ptr *Ctensor, input Ctensor, weightData []Ctensor, weightLen int, weightStride0 int64, hx Ctensor, cx Ctensor, mode int64, hiddenSize int64, numLayers int64, batchFirst int32, dropout float64, train int32, bidirectional int32, batchSizesData []int64, batchSizesLen int, dropoutState Ctensor)

func AtgMish

func AtgMish(ptr *Ctensor, self Ctensor)

func AtgMishBackward

func AtgMishBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)

func AtgMishOut

func AtgMishOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgMish_

func AtgMish_(ptr *Ctensor, self Ctensor)

func AtgMkldnnAdaptiveAvgPool2d

func AtgMkldnnAdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func AtgMkldnnAdaptiveAvgPool2dBackward

func AtgMkldnnAdaptiveAvgPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)

func AtgMkldnnConvolution

func AtgMkldnnConvolution(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64)

func AtgMkldnnConvolutionBackwardInput

func AtgMkldnnConvolutionBackwardInput(ptr *Ctensor, selfSizeData []int64, selfSizeLen int, gradOutput Ctensor, weight Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, biasDefined int32)

func AtgMkldnnConvolutionBackwardWeights

func AtgMkldnnConvolutionBackwardWeights(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64, biasDefined int32)

func AtgMkldnnLinear

func AtgMkldnnLinear(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor)

func AtgMkldnnLinearBackwardInput

func AtgMkldnnLinearBackwardInput(ptr *Ctensor, inputSizeData []int64, inputSizeLen int, gradOutput Ctensor, weight Ctensor)

func AtgMkldnnLinearBackwardWeights

func AtgMkldnnLinearBackwardWeights(ptr *Ctensor, gradOutput Ctensor, input Ctensor, weight Ctensor, biasDefined int32)

func AtgMkldnnMaxPool2d

func AtgMkldnnMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMkldnnMaxPool2dBackward

func AtgMkldnnMaxPool2dBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor, input Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMkldnnMaxPool3d

func AtgMkldnnMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMkldnnMaxPool3dBackward

func AtgMkldnnMaxPool3dBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor, input Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgMkldnnReorderConv2dWeight

func AtgMkldnnReorderConv2dWeight(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64)

func AtgMkldnnReorderConv3dWeight

func AtgMkldnnReorderConv3dWeight(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64)

func AtgMm

func AtgMm(ptr *Ctensor, self Ctensor, mat2 Ctensor)

func AtgMmOut

func AtgMmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor)

func AtgMode

func AtgMode(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgModeValues

func AtgModeValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgMoveaxis

func AtgMoveaxis(ptr *Ctensor, self Ctensor, sourceData []int64, sourceLen int, destinationData []int64, destinationLen int)

func AtgMoveaxisInt

func AtgMoveaxisInt(ptr *Ctensor, self Ctensor, source int64, destination int64)

func AtgMovedim

func AtgMovedim(ptr *Ctensor, self Ctensor, sourceData []int64, sourceLen int, destinationData []int64, destinationLen int)

func AtgMovedimInt

func AtgMovedimInt(ptr *Ctensor, self Ctensor, source int64, destination int64)

func AtgMseLoss

func AtgMseLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgMseLossBackward

func AtgMseLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgMseLossBackwardGradInput

func AtgMseLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgMseLossOut

func AtgMseLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgMsort

func AtgMsort(ptr *Ctensor, self Ctensor)

func AtgMsortOut

func AtgMsortOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgMul

func AtgMul(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgMulOut

func AtgMulOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgMulScalar

func AtgMulScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgMulScalar_

func AtgMulScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgMul_

func AtgMul_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgMultiMarginLossBackward

func AtgMultiMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, p Cscalar, margin Cscalar, weight Ctensor, reduction int64)

func AtgMultiMarginLossBackwardGradInput

func AtgMultiMarginLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, p Cscalar, margin Cscalar, weight Ctensor, reduction int64)

func AtgMultilabelMarginLoss

func AtgMultilabelMarginLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgMultilabelMarginLossBackward

func AtgMultilabelMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, isTarget Ctensor)

func AtgMultilabelMarginLossBackwardGradInput

func AtgMultilabelMarginLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, isTarget Ctensor)

func AtgMultilabelMarginLossOut

func AtgMultilabelMarginLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgMultinomial

func AtgMultinomial(ptr *Ctensor, self Ctensor, numSamples int64, replacement int32)

func AtgMultinomialOut

func AtgMultinomialOut(ptr *Ctensor, out Ctensor, self Ctensor, numSamples int64, replacement int32)

func AtgMultiply

func AtgMultiply(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgMultiplyOut

func AtgMultiplyOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgMultiplyScalar

func AtgMultiplyScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgMultiplyScalar_

func AtgMultiplyScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgMultiply_

func AtgMultiply_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgMv

func AtgMv(ptr *Ctensor, self Ctensor, vec Ctensor)

func AtgMvOut

func AtgMvOut(ptr *Ctensor, out Ctensor, self Ctensor, vec Ctensor)

func AtgMvlgamma

func AtgMvlgamma(ptr *Ctensor, self Ctensor, p int64)

func AtgMvlgammaOut

func AtgMvlgammaOut(ptr *Ctensor, out Ctensor, self Ctensor, p int64)

func AtgMvlgamma_

func AtgMvlgamma_(ptr *Ctensor, self Ctensor, p int64)

func AtgNanToNum

func AtgNanToNum(ptr *Ctensor, self Ctensor, nanVal float64, nanNull int, posinfVal float64, posinfNull int, neginfVal float64, neginfNull int)

func AtgNanToNumOut

func AtgNanToNumOut(ptr *Ctensor, out Ctensor, self Ctensor, nanVal float64, nanNull int, posinfVal float64, posinfNull int, neginfVal float64, neginfNull int)

func AtgNanToNum_

func AtgNanToNum_(ptr *Ctensor, self Ctensor, nanVal float64, nanNull int, posinfVal float64, posinfNull int, neginfVal float64, neginfNull int)

func AtgNanmean

func AtgNanmean(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgNanmeanOut

func AtgNanmeanOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgNanmedian

func AtgNanmedian(ptr *Ctensor, self Ctensor)

func AtgNanmedianDim

func AtgNanmedianDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgNanmedianDimValues

func AtgNanmedianDimValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, keepdim int32)

func AtgNanquantile

func AtgNanquantile(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgNanquantileNew

func AtgNanquantileNew(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32, interpolation string)

func AtgNanquantileNewOut

func AtgNanquantileNewOut(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32, interpolation string)

func AtgNanquantileNewScalar

func AtgNanquantileNewScalar(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32, interpolation string)

func AtgNanquantileNewScalarOut

func AtgNanquantileNewScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32, interpolation string)

func AtgNanquantileOut

func AtgNanquantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgNanquantileScalar

func AtgNanquantileScalar(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32)

func AtgNanquantileScalarOut

func AtgNanquantileScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32)

func AtgNansum

func AtgNansum(ptr *Ctensor, self Ctensor, dtype int32)

func AtgNansumDimIntlist

func AtgNansumDimIntlist(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgNansumIntlistOut

func AtgNansumIntlistOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgNarrow

func AtgNarrow(ptr *Ctensor, self Ctensor, dim int64, start int64, length int64)

func AtgNarrowCopy

func AtgNarrowCopy(ptr *Ctensor, self Ctensor, dim int64, start int64, length int64)

func AtgNarrowCopyOut

func AtgNarrowCopyOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, start int64, length int64)

func AtgNarrowTensor

func AtgNarrowTensor(ptr *Ctensor, self Ctensor, dim int64, start Ctensor, length int64)

func AtgNativeBatchNorm

func AtgNativeBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, momentum float64, eps float64)

func AtgNativeBatchNormOut

func AtgNativeBatchNormOut(ptr *Ctensor, out Ctensor, saveMean Ctensor, saveInvstd Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, momentum float64, eps float64)

func AtgNativeGroupNorm

func AtgNativeGroupNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, n int64, c int64, hxW int64, group int64, eps float64)

func AtgNativeLayerNorm

func AtgNativeLayerNorm(ptr *Ctensor, input Ctensor, normalizedShapeData []int64, normalizedShapeLen int, weight Ctensor, bias Ctensor, eps float64)

func AtgNativeNorm

func AtgNativeNorm(ptr *Ctensor, self Ctensor)

func AtgNativeNormScalaroptDimDtype

func AtgNativeNormScalaroptDimDtype(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgNe

func AtgNe(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgNeScalarOut

func AtgNeScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgNeTensor

func AtgNeTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgNeTensorOut

func AtgNeTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgNeTensor_

func AtgNeTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgNe_

func AtgNe_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgNeg

func AtgNeg(ptr *Ctensor, self Ctensor)

func AtgNegOut

func AtgNegOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgNeg_

func AtgNeg_(ptr *Ctensor, self Ctensor)

func AtgNegative

func AtgNegative(ptr *Ctensor, self Ctensor)

func AtgNegativeOut

func AtgNegativeOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgNegative_

func AtgNegative_(ptr *Ctensor, self Ctensor)

func AtgNewEmpty

func AtgNewEmpty(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgNewEmptyStrided

func AtgNewEmptyStrided(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, strideLen int, optionsKind int32, optionsDevice int32)

func AtgNewFull

func AtgNewFull(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar, optionsKind int32, optionsDevice int32)

func AtgNewOnes

func AtgNewOnes(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgNewZeros

func AtgNewZeros(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgNextafter

func AtgNextafter(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgNextafterOut

func AtgNextafterOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgNextafter_

func AtgNextafter_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgNllLoss

func AtgNllLoss(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64)

func AtgNllLoss2d

func AtgNllLoss2d(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64)

func AtgNllLoss2dBackward

func AtgNllLoss2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, totalWeight Ctensor)

func AtgNllLoss2dBackwardGradInput

func AtgNllLoss2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, totalWeight Ctensor)

func AtgNllLoss2dOut

func AtgNllLoss2dOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64)

func AtgNllLossBackward

func AtgNllLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, totalWeight Ctensor)

func AtgNllLossBackwardGradInput

func AtgNllLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, totalWeight Ctensor)

func AtgNllLossNd

func AtgNllLossNd(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64)

func AtgNllLossOut

func AtgNllLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64)

func AtgNonzero

func AtgNonzero(ptr *Ctensor, self Ctensor)

func AtgNonzeroOut

func AtgNonzeroOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgNorm

func AtgNorm(ptr *Ctensor, self Ctensor)

func AtgNormDtypeOut

func AtgNormDtypeOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgNormExceptDim

func AtgNormExceptDim(ptr *Ctensor, v Ctensor, pow int64, dim int64)

func AtgNormOut

func AtgNormOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32)

func AtgNormScalaroptDim

func AtgNormScalaroptDim(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32)

func AtgNormScalaroptDimDtype

func AtgNormScalaroptDimDtype(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgNormScalaroptDtype

func AtgNormScalaroptDtype(ptr *Ctensor, self Ctensor, p Cscalar, dtype int32)

func AtgNormal

func AtgNormal(ptr *Ctensor, out Ctensor, mean Ctensor, std float64)

func AtgNormalFloatFloatOut

func AtgNormalFloatFloatOut(ptr *Ctensor, out Ctensor, mean float64, std float64, sizeData []int64, sizeLen int)

func AtgNormalFloatTensorOut

func AtgNormalFloatTensorOut(ptr *Ctensor, out Ctensor, mean float64, std Ctensor)

func AtgNormalTensorTensorOut

func AtgNormalTensorTensorOut(ptr *Ctensor, out Ctensor, mean Ctensor, std Ctensor)

func AtgNormal_

func AtgNormal_(ptr *Ctensor, self Ctensor, mean float64, std float64)

func AtgNotEqual

func AtgNotEqual(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgNotEqualScalarOut

func AtgNotEqualScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgNotEqualTensor

func AtgNotEqualTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgNotEqualTensorOut

func AtgNotEqualTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgNotEqualTensor_

func AtgNotEqualTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgNotEqual_

func AtgNotEqual_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgNuclearNorm

func AtgNuclearNorm(ptr *Ctensor, self Ctensor, keepdim int32)

func AtgNuclearNormDim

func AtgNuclearNormDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgNuclearNormDimOut

func AtgNuclearNormDimOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgNuclearNormOut

func AtgNuclearNormOut(ptr *Ctensor, out Ctensor, self Ctensor, keepdim int32)

func AtgNumpyT

func AtgNumpyT(ptr *Ctensor, self Ctensor)

func AtgOneHot

func AtgOneHot(ptr *Ctensor, self Ctensor, numClasses int64)

func AtgOnes

func AtgOnes(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgOnesLike

func AtgOnesLike(ptr *Ctensor, self Ctensor)

func AtgOnesOut

func AtgOnesOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)

func AtgOrgqr

func AtgOrgqr(ptr *Ctensor, self Ctensor, input2 Ctensor)

func AtgOrgqrOut

func AtgOrgqrOut(ptr *Ctensor, out Ctensor, self Ctensor, input2 Ctensor)

func AtgOrmqr

func AtgOrmqr(ptr *Ctensor, self Ctensor, input2 Ctensor, input3 Ctensor, left int32, transpose int32)

func AtgOrmqrOut

func AtgOrmqrOut(ptr *Ctensor, out Ctensor, self Ctensor, input2 Ctensor, input3 Ctensor, left int32, transpose int32)

func AtgOuter

func AtgOuter(ptr *Ctensor, self Ctensor, vec2 Ctensor)

func AtgOuterOut

func AtgOuterOut(ptr *Ctensor, out Ctensor, self Ctensor, vec2 Ctensor)

func AtgOutputNr

func AtgOutputNr(self Ctensor) int64

func AtgPadSequence

func AtgPadSequence(ptr *Ctensor, sequencesData []Ctensor, sequencesLen int, batchFirst int32, paddingValue float64)

func AtgPairwiseDistance

func AtgPairwiseDistance(ptr *Ctensor, x1 Ctensor, x2 Ctensor, p float64, eps float64, keepdim int32)

func AtgPdist

func AtgPdist(ptr *Ctensor, self Ctensor, p float64)

func AtgPermute

func AtgPermute(ptr *Ctensor, self Ctensor, dimsData []int64, dimsLen int)

func AtgPinMemory

func AtgPinMemory(ptr *Ctensor, self Ctensor, device int32)

func AtgPinverse

func AtgPinverse(ptr *Ctensor, self Ctensor, rcond float64)

func AtgPixelShuffle

func AtgPixelShuffle(ptr *Ctensor, self Ctensor, upscaleFactor int64)

func AtgPixelUnshuffle

func AtgPixelUnshuffle(ptr *Ctensor, self Ctensor, downscaleFactor int64)

func AtgPoisson

func AtgPoisson(ptr *Ctensor, self Ctensor)

func AtgPoissonNllLoss

func AtgPoissonNllLoss(ptr *Ctensor, input Ctensor, target Ctensor, logInput int32, full int32, eps float64, reduction int64)

func AtgPolar

func AtgPolar(ptr *Ctensor, abs Ctensor, angle Ctensor)

func AtgPolarOut

func AtgPolarOut(ptr *Ctensor, out Ctensor, abs Ctensor, angle Ctensor)

func AtgPolygamma

func AtgPolygamma(ptr *Ctensor, n int64, self Ctensor)

func AtgPolygammaOut

func AtgPolygammaOut(ptr *Ctensor, out Ctensor, n int64, self Ctensor)

func AtgPolygamma_

func AtgPolygamma_(ptr *Ctensor, self Ctensor, n int64)

func AtgPositive

func AtgPositive(ptr *Ctensor, self Ctensor)

func AtgPow

func AtgPow(ptr *Ctensor, self Ctensor, exponent Ctensor)

func AtgPowScalar

func AtgPowScalar(ptr *Ctensor, selfScalar Cscalar, exponent Ctensor)

func AtgPowScalarOut

func AtgPowScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, exponent Ctensor)

func AtgPowTensorScalar

func AtgPowTensorScalar(ptr *Ctensor, self Ctensor, exponent Cscalar)

func AtgPowTensorScalarOut

func AtgPowTensorScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Cscalar)

func AtgPowTensorTensorOut

func AtgPowTensorTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Ctensor)

func AtgPowTensor_

func AtgPowTensor_(ptr *Ctensor, self Ctensor, exponent Ctensor)

func AtgPow_

func AtgPow_(ptr *Ctensor, self Ctensor, exponent Cscalar)

func AtgPrelu

func AtgPrelu(ptr *Ctensor, self Ctensor, weight Ctensor)

func AtgPreluBackward

func AtgPreluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, weight Ctensor)

func AtgProd

func AtgProd(ptr *Ctensor, self Ctensor, dtype int32)

func AtgProdDimInt

func AtgProdDimInt(ptr *Ctensor, self Ctensor, dim int64, keepdim int32, dtype int32)

func AtgProdIntOut

func AtgProdIntOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32, dtype int32)

func AtgPut

func AtgPut(ptr *Ctensor, self Ctensor, index Ctensor, source Ctensor, accumulate int32)

func AtgPut_

func AtgPut_(ptr *Ctensor, self Ctensor, index Ctensor, source Ctensor, accumulate int32)

func AtgQPerChannelAxis

func AtgQPerChannelAxis(self Ctensor) int64

func AtgQPerChannelScales

func AtgQPerChannelScales(ptr *Ctensor, self Ctensor)

func AtgQPerChannelZeroPoints

func AtgQPerChannelZeroPoints(ptr *Ctensor, self Ctensor)

func AtgQScale

func AtgQScale(self Ctensor) float64

func AtgQZeroPoint

func AtgQZeroPoint(self Ctensor) int64

func AtgQr

func AtgQr(ptr *Ctensor, self Ctensor, some int32)

func AtgQrQ

func AtgQrQ(ptr *Ctensor, q Ctensor, r Ctensor, self Ctensor, some int32)

func AtgQuantile

func AtgQuantile(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgQuantileNew

func AtgQuantileNew(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32, interpolation string)

func AtgQuantileNewOut

func AtgQuantileNewOut(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32, interpolation string)

func AtgQuantileNewScalar

func AtgQuantileNewScalar(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32, interpolation string)

func AtgQuantileNewScalarOut

func AtgQuantileNewScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32, interpolation string)

func AtgQuantileOut

func AtgQuantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32)

func AtgQuantileScalar

func AtgQuantileScalar(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32)

func AtgQuantileScalarOut

func AtgQuantileScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32)

func AtgQuantizePerChannel

func AtgQuantizePerChannel(ptr *Ctensor, self Ctensor, scales Ctensor, zeroPoints Ctensor, axis int64, dtype int32)

func AtgQuantizePerTensor

func AtgQuantizePerTensor(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64, dtype int32)

func AtgQuantizePerTensorTensorQparams

func AtgQuantizePerTensorTensorQparams(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, dtype int32)

func AtgQuantizedBatchNorm

func AtgQuantizedBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, mean Ctensor, vari Ctensor, eps float64, outputScale float64, outputZeroPoint int64)

func AtgQuantizedGruCell

func AtgQuantizedGruCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor, packedIh Ctensor, packedHh Ctensor, colOffsetsIh Ctensor, colOffsetsHh Ctensor, scaleIh Cscalar, scaleHh Cscalar, zeroPointIh Cscalar, zeroPointHh Cscalar)

func AtgQuantizedLstmCell

func AtgQuantizedLstmCell(ptr *Ctensor, input Ctensor, hxData []Ctensor, hxLen int, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor, packedIh Ctensor, packedHh Ctensor, colOffsetsIh Ctensor, colOffsetsHh Ctensor, scaleIh Cscalar, scaleHh Cscalar, zeroPointIh Cscalar, zeroPointHh Cscalar)

func AtgQuantizedMaxPool1d

func AtgQuantizedMaxPool1d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgQuantizedMaxPool2d

func AtgQuantizedMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32)

func AtgQuantizedRnnReluCell

func AtgQuantizedRnnReluCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor, packedIh Ctensor, packedHh Ctensor, colOffsetsIh Ctensor, colOffsetsHh Ctensor, scaleIh Cscalar, scaleHh Cscalar, zeroPointIh Cscalar, zeroPointHh Cscalar)

func AtgQuantizedRnnTanhCell

func AtgQuantizedRnnTanhCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor, packedIh Ctensor, packedHh Ctensor, colOffsetsIh Ctensor, colOffsetsHh Ctensor, scaleIh Cscalar, scaleHh Cscalar, zeroPointIh Cscalar, zeroPointHh Cscalar)

func AtgRad2deg

func AtgRad2deg(ptr *Ctensor, self Ctensor)

func AtgRad2degOut

func AtgRad2degOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgRad2deg_

func AtgRad2deg_(ptr *Ctensor, self Ctensor)

func AtgRand

func AtgRand(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgRandLike

func AtgRandLike(ptr *Ctensor, self Ctensor)

func AtgRandOut

func AtgRandOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)

func AtgRandint

func AtgRandint(ptr *Ctensor, high int64, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgRandintLike

func AtgRandintLike(ptr *Ctensor, self Ctensor, high int64)

func AtgRandintLikeLowDtype

func AtgRandintLikeLowDtype(ptr *Ctensor, self Ctensor, low int64, high int64)

func AtgRandintLow

func AtgRandintLow(ptr *Ctensor, low int64, high int64, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgRandintLowOut

func AtgRandintLowOut(ptr *Ctensor, out Ctensor, low int64, high int64, sizeData []int64, sizeLen int)

func AtgRandintOut

func AtgRandintOut(ptr *Ctensor, out Ctensor, high int64, sizeData []int64, sizeLen int)

func AtgRandn

func AtgRandn(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgRandnLike

func AtgRandnLike(ptr *Ctensor, self Ctensor)

func AtgRandnOut

func AtgRandnOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)

func AtgRandomFrom_

func AtgRandomFrom_(ptr *Ctensor, self Ctensor, from int64, toVal int64, toNull int)

func AtgRandomTo_

func AtgRandomTo_(ptr *Ctensor, self Ctensor, to int64)

func AtgRandom_

func AtgRandom_(ptr *Ctensor, self Ctensor)

func AtgRandperm

func AtgRandperm(ptr *Ctensor, n int64, optionsKind int32, optionsDevice int32)

func AtgRandpermOut

func AtgRandpermOut(ptr *Ctensor, out Ctensor, n int64)

func AtgRange

func AtgRange(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, optionsDevice int32)

func AtgRangeOut

func AtgRangeOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar)

func AtgRangeStep

func AtgRangeStep(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, optionsDevice int32)

func AtgRavel

func AtgRavel(ptr *Ctensor, self Ctensor)

func AtgReal

func AtgReal(ptr *Ctensor, self Ctensor)

func AtgReciprocal

func AtgReciprocal(ptr *Ctensor, self Ctensor)

func AtgReciprocalOut

func AtgReciprocalOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgReciprocal_

func AtgReciprocal_(ptr *Ctensor, self Ctensor)

func AtgReflectionPad1d

func AtgReflectionPad1d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad1dBackward

func AtgReflectionPad1dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad1dBackwardGradInput

func AtgReflectionPad1dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad1dOut

func AtgReflectionPad1dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad2d

func AtgReflectionPad2d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad2dBackward

func AtgReflectionPad2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad2dBackwardGradInput

func AtgReflectionPad2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad2dOut

func AtgReflectionPad2dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad3d

func AtgReflectionPad3d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad3dBackward

func AtgReflectionPad3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad3dBackwardGradInput

func AtgReflectionPad3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReflectionPad3dOut

func AtgReflectionPad3dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgRelu

func AtgRelu(ptr *Ctensor, self Ctensor)

func AtgRelu6

func AtgRelu6(ptr *Ctensor, self Ctensor)

func AtgRelu6_

func AtgRelu6_(ptr *Ctensor, self Ctensor)

func AtgRelu_

func AtgRelu_(ptr *Ctensor, self Ctensor)

func AtgRemainder

func AtgRemainder(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgRemainderScalarOut

func AtgRemainderScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgRemainderScalarTensor

func AtgRemainderScalarTensor(ptr *Ctensor, selfScalar Cscalar, other Ctensor)

func AtgRemainderTensor

func AtgRemainderTensor(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgRemainderTensorOut

func AtgRemainderTensorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgRemainderTensor_

func AtgRemainderTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgRemainder_

func AtgRemainder_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgRenorm

func AtgRenorm(ptr *Ctensor, self Ctensor, p Cscalar, dim int64, maxnorm Cscalar)

func AtgRenormOut

func AtgRenormOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dim int64, maxnorm Cscalar)

func AtgRenorm_

func AtgRenorm_(ptr *Ctensor, self Ctensor, p Cscalar, dim int64, maxnorm Cscalar)

func AtgRepeat

func AtgRepeat(ptr *Ctensor, self Ctensor, repeatsData []int64, repeatsLen int)

func AtgRepeatInterleave

func AtgRepeatInterleave(ptr *Ctensor, repeats Ctensor, outputSizeVal int64, outputSizeNull int)

func AtgRepeatInterleaveSelfInt

func AtgRepeatInterleaveSelfInt(ptr *Ctensor, self Ctensor, repeats int64, dimVal int64, dimNull int, outputSizeVal int64, outputSizeNull int)

func AtgRepeatInterleaveSelfTensor

func AtgRepeatInterleaveSelfTensor(ptr *Ctensor, self Ctensor, repeats Ctensor, dimVal int64, dimNull int, outputSizeVal int64, outputSizeNull int)

func AtgReplicationPad1d

func AtgReplicationPad1d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad1dBackward

func AtgReplicationPad1dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad1dBackwardGradInput

func AtgReplicationPad1dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad1dOut

func AtgReplicationPad1dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad2d

func AtgReplicationPad2d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad2dBackward

func AtgReplicationPad2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad2dBackwardGradInput

func AtgReplicationPad2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad2dOut

func AtgReplicationPad2dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad3d

func AtgReplicationPad3d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad3dBackward

func AtgReplicationPad3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad3dBackwardGradInput

func AtgReplicationPad3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgReplicationPad3dOut

func AtgReplicationPad3dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)

func AtgRequiresGrad_

func AtgRequiresGrad_(ptr *Ctensor, self Ctensor, requiresGrad int32)

func AtgReshape

func AtgReshape(ptr *Ctensor, self Ctensor, shapeData []int64, shapeLen int)

func AtgReshapeAs

func AtgReshapeAs(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgResizeAsSparse_

func AtgResizeAsSparse_(ptr *Ctensor, self Ctensor, theTemplate Ctensor)

func AtgResizeAs_

func AtgResizeAs_(ptr *Ctensor, self Ctensor, theTemplate Ctensor)

func AtgResize_

func AtgResize_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)

func AtgResolveConj

func AtgResolveConj(ptr *Ctensor, self Ctensor)

func AtgResolveNeg

func AtgResolveNeg(ptr *Ctensor, self Ctensor)

func AtgRetainsGrad

func AtgRetainsGrad(self Ctensor) bool

func AtgRnnRelu

func AtgRnnRelu(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32, batchFirst int32)

func AtgRnnReluCell

func AtgRnnReluCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor)

func AtgRnnReluData

func AtgRnnReluData(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32)

func AtgRnnTanh

func AtgRnnTanh(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32, batchFirst int32)

func AtgRnnTanhCell

func AtgRnnTanhCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor)

func AtgRnnTanhData

func AtgRnnTanhData(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32)

func AtgRoll

func AtgRoll(ptr *Ctensor, self Ctensor, shiftsData []int64, shiftsLen int, dimsData []int64, dimsLen int)

func AtgRot90

func AtgRot90(ptr *Ctensor, self Ctensor, k int64, dimsData []int64, dimsLen int)

func AtgRound

func AtgRound(ptr *Ctensor, self Ctensor)

func AtgRoundOut

func AtgRoundOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgRound_

func AtgRound_(ptr *Ctensor, self Ctensor)

func AtgRowStack

func AtgRowStack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgRowStackOut

func AtgRowStackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgRrelu

func AtgRrelu(ptr *Ctensor, self Ctensor, training int32)

func AtgRreluWithNoise

func AtgRreluWithNoise(ptr *Ctensor, self Ctensor, noise Ctensor, training int32)

func AtgRreluWithNoiseBackward

func AtgRreluWithNoiseBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, noise Ctensor, lower Cscalar, upper Cscalar, training int32, selfIsResult int32)

func AtgRreluWithNoiseOut

func AtgRreluWithNoiseOut(ptr *Ctensor, out Ctensor, self Ctensor, noise Ctensor, training int32)

func AtgRreluWithNoise_

func AtgRreluWithNoise_(ptr *Ctensor, self Ctensor, noise Ctensor, training int32)

func AtgRrelu_

func AtgRrelu_(ptr *Ctensor, self Ctensor, training int32)

func AtgRsqrt

func AtgRsqrt(ptr *Ctensor, self Ctensor)

func AtgRsqrtOut

func AtgRsqrtOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgRsqrt_

func AtgRsqrt_(ptr *Ctensor, self Ctensor)

func AtgRsub

func AtgRsub(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgRsubScalar

func AtgRsubScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgScalarTensor

func AtgScalarTensor(ptr *Ctensor, s Cscalar, optionsKind int32, optionsDevice int32)

func AtgScatter

func AtgScatter(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)

func AtgScatterAdd

func AtgScatterAdd(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)

func AtgScatterAddOut

func AtgScatterAddOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)

func AtgScatterAdd_

func AtgScatterAdd_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)

func AtgScatterReduce

func AtgScatterReduce(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, reduce string)

func AtgScatterReduceOut

func AtgScatterReduceOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, reduce string)

func AtgScatterReduce_

func AtgScatterReduce_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, reduce string)

func AtgScatterSrcOut

func AtgScatterSrcOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)

func AtgScatterValue

func AtgScatterValue(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)

func AtgScatterValueOut

func AtgScatterValueOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)

func AtgScatterValueReduce

func AtgScatterValueReduce(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar, reduce string)

func AtgScatterValueReduceOut

func AtgScatterValueReduceOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar, reduce string)

func AtgScatterValueReduce_

func AtgScatterValueReduce_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar, reduce string)

func AtgScatterValue_

func AtgScatterValue_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)

func AtgScatter_

func AtgScatter_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)

func AtgSearchsorted

func AtgSearchsorted(ptr *Ctensor, sortedSequence Ctensor, self Ctensor, outInt32 int32, right int32)

func AtgSearchsortedScalar

func AtgSearchsortedScalar(ptr *Ctensor, sortedSequence Ctensor, selfScalar Cscalar, outInt32 int32, right int32)

func AtgSearchsortedTensorOut

func AtgSearchsortedTensorOut(ptr *Ctensor, out Ctensor, sortedSequence Ctensor, self Ctensor, outInt32 int32, right int32)

func AtgSegmentReduce

func AtgSegmentReduce(ptr *Ctensor, data Ctensor, reduce string, lengths Ctensor, indices Ctensor, axis int64, unsafety int32, initial Cscalar)

func AtgSelect

func AtgSelect(ptr *Ctensor, self Ctensor, dim int64, index int64)

func AtgSelectBackward

func AtgSelectBackward(ptr *Ctensor, gradOutput Ctensor, inputSizesData []int64, inputSizesLen int, dim int64, index int64)

func AtgSelu

func AtgSelu(ptr *Ctensor, self Ctensor)

func AtgSelu_

func AtgSelu_(ptr *Ctensor, self Ctensor)

func AtgSetRequiresGrad

func AtgSetRequiresGrad(ptr *Ctensor, self Ctensor, r int32)

func AtgSetSourceTensor_

func AtgSetSourceTensor_(ptr *Ctensor, self Ctensor, source Ctensor)

func AtgSet_

func AtgSet_(ptr *Ctensor, self Ctensor)

func AtgSgn

func AtgSgn(ptr *Ctensor, self Ctensor)

func AtgSgnOut

func AtgSgnOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSgn_

func AtgSgn_(ptr *Ctensor, self Ctensor)

func AtgSigmoid

func AtgSigmoid(ptr *Ctensor, self Ctensor)

func AtgSigmoidBackward

func AtgSigmoidBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor)

func AtgSigmoidBackwardGradInput

func AtgSigmoidBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, output Ctensor)

func AtgSigmoidOut

func AtgSigmoidOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSigmoid_

func AtgSigmoid_(ptr *Ctensor, self Ctensor)

func AtgSign

func AtgSign(ptr *Ctensor, self Ctensor)

func AtgSignOut

func AtgSignOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSign_

func AtgSign_(ptr *Ctensor, self Ctensor)

func AtgSignbit

func AtgSignbit(ptr *Ctensor, self Ctensor)

func AtgSignbitOut

func AtgSignbitOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSilu

func AtgSilu(ptr *Ctensor, self Ctensor)

func AtgSiluBackward

func AtgSiluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)

func AtgSiluBackwardGradInput

func AtgSiluBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor)

func AtgSiluOut

func AtgSiluOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSilu_

func AtgSilu_(ptr *Ctensor, self Ctensor)

func AtgSin

func AtgSin(ptr *Ctensor, self Ctensor)

func AtgSinOut

func AtgSinOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSin_

func AtgSin_(ptr *Ctensor, self Ctensor)

func AtgSinc

func AtgSinc(ptr *Ctensor, self Ctensor)

func AtgSincOut

func AtgSincOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSinc_

func AtgSinc_(ptr *Ctensor, self Ctensor)

func AtgSinh

func AtgSinh(ptr *Ctensor, self Ctensor)

func AtgSinhOut

func AtgSinhOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSinh_

func AtgSinh_(ptr *Ctensor, self Ctensor)

func AtgSlice

func AtgSlice(ptr *Ctensor, self Ctensor, dim int64, startVal int64, startNull int, endVal int64, endNull int, step int64)

func AtgSliceBackward

func AtgSliceBackward(ptr *Ctensor, gradOutput Ctensor, inputSizesData []int64, inputSizesLen int, dim int64, start int64, end int64, step int64)

func AtgSlogdet

func AtgSlogdet(ptr *Ctensor, self Ctensor)

func AtgSlowConv3d

func AtgSlowConv3d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int)

func AtgSlowConv3dOut

func AtgSlowConv3dOut(ptr *Ctensor, out Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int)

func AtgSlowConvDilated2d

func AtgSlowConvDilated2d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int)

func AtgSlowConvDilated3d

func AtgSlowConvDilated3d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int)

func AtgSlowConvTranspose2d

func AtgSlowConvTranspose2d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, dilationData []int64, dilationLen int)

func AtgSlowConvTranspose2dOut

func AtgSlowConvTranspose2dOut(ptr *Ctensor, out Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, dilationData []int64, dilationLen int)

func AtgSlowConvTranspose3d

func AtgSlowConvTranspose3d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, dilationData []int64, dilationLen int)

func AtgSlowConvTranspose3dOut

func AtgSlowConvTranspose3dOut(ptr *Ctensor, out Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, outputPaddingData []int64, outputPaddingLen int, dilationData []int64, dilationLen int)

func AtgSmm

func AtgSmm(ptr *Ctensor, self Ctensor, mat2 Ctensor)

func AtgSmoothL1Loss

func AtgSmoothL1Loss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64, beta float64)

func AtgSmoothL1LossBackward

func AtgSmoothL1LossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, beta float64)

func AtgSmoothL1LossBackwardGradInput

func AtgSmoothL1LossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, beta float64)

func AtgSmoothL1LossOut

func AtgSmoothL1LossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64, beta float64)

func AtgSoftMarginLoss

func AtgSoftMarginLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgSoftMarginLossBackward

func AtgSoftMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgSoftMarginLossBackwardGradInput

func AtgSoftMarginLossBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgSoftMarginLossOut

func AtgSoftMarginLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64)

func AtgSoftmax

func AtgSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32)

func AtgSoftplus

func AtgSoftplus(ptr *Ctensor, self Ctensor)

func AtgSoftplusBackward

func AtgSoftplusBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, beta Cscalar, threshold Cscalar, output Ctensor)

func AtgSoftplusBackwardGradInput

func AtgSoftplusBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, beta Cscalar, threshold Cscalar, output Ctensor)

func AtgSoftplusOut

func AtgSoftplusOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSoftshrink

func AtgSoftshrink(ptr *Ctensor, self Ctensor)

func AtgSoftshrinkBackward

func AtgSoftshrinkBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, lambd Cscalar)

func AtgSoftshrinkBackwardGradInput

func AtgSoftshrinkBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, lambd Cscalar)

func AtgSoftshrinkOut

func AtgSoftshrinkOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSolve

func AtgSolve(ptr *Ctensor, self Ctensor, a Ctensor)

func AtgSolveSolution

func AtgSolveSolution(ptr *Ctensor, solution Ctensor, lu Ctensor, self Ctensor, a Ctensor)

func AtgSort

func AtgSort(ptr *Ctensor, self Ctensor, dim int64, descending int32)

func AtgSortStable

func AtgSortStable(ptr *Ctensor, self Ctensor, stable int32, dim int64, descending int32)

func AtgSortValues

func AtgSortValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, descending int32)

func AtgSortValuesStable

func AtgSortValuesStable(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, stable int32, dim int64, descending int32)

func AtgSparseCooTensor

func AtgSparseCooTensor(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgSparseCooTensorIndices

func AtgSparseCooTensorIndices(ptr *Ctensor, indices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32)

func AtgSparseCooTensorIndicesSize

func AtgSparseCooTensorIndicesSize(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgSparseCsrTensor

func AtgSparseCsrTensor(ptr *Ctensor, crowIndices Ctensor, colIndices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32)

func AtgSparseCsrTensorCrowColValueSize

func AtgSparseCsrTensorCrowColValueSize(ptr *Ctensor, crowIndices Ctensor, colIndices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgSparseDim

func AtgSparseDim(self Ctensor) int64

func AtgSparseMask

func AtgSparseMask(ptr *Ctensor, self Ctensor, mask Ctensor)

func AtgSparseResizeAndClear_

func AtgSparseResizeAndClear_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, sparseDim int64, denseDim int64)

func AtgSparseResize_

func AtgSparseResize_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, sparseDim int64, denseDim int64)

func AtgSpecialDigamma

func AtgSpecialDigamma(ptr *Ctensor, self Ctensor)

func AtgSpecialDigammaOut

func AtgSpecialDigammaOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialEntr

func AtgSpecialEntr(ptr *Ctensor, self Ctensor)

func AtgSpecialEntrOut

func AtgSpecialEntrOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialErf

func AtgSpecialErf(ptr *Ctensor, self Ctensor)

func AtgSpecialErfOut

func AtgSpecialErfOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialErfc

func AtgSpecialErfc(ptr *Ctensor, self Ctensor)

func AtgSpecialErfcOut

func AtgSpecialErfcOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialErfcx

func AtgSpecialErfcx(ptr *Ctensor, self Ctensor)

func AtgSpecialErfcxOut

func AtgSpecialErfcxOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialErfinv

func AtgSpecialErfinv(ptr *Ctensor, self Ctensor)

func AtgSpecialErfinvOut

func AtgSpecialErfinvOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialExp2

func AtgSpecialExp2(ptr *Ctensor, self Ctensor)

func AtgSpecialExp2Out

func AtgSpecialExp2Out(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialExpit

func AtgSpecialExpit(ptr *Ctensor, self Ctensor)

func AtgSpecialExpitOut

func AtgSpecialExpitOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialExpm1

func AtgSpecialExpm1(ptr *Ctensor, self Ctensor)

func AtgSpecialExpm1Out

func AtgSpecialExpm1Out(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialGammainc

func AtgSpecialGammainc(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgSpecialGammaincOut

func AtgSpecialGammaincOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgSpecialGammaincc

func AtgSpecialGammaincc(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgSpecialGammainccOut

func AtgSpecialGammainccOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgSpecialGammaln

func AtgSpecialGammaln(ptr *Ctensor, self Ctensor)

func AtgSpecialGammalnOut

func AtgSpecialGammalnOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialI0

func AtgSpecialI0(ptr *Ctensor, self Ctensor)

func AtgSpecialI0Out

func AtgSpecialI0Out(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialI0e

func AtgSpecialI0e(ptr *Ctensor, self Ctensor)

func AtgSpecialI0eOut

func AtgSpecialI0eOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialI1

func AtgSpecialI1(ptr *Ctensor, self Ctensor)

func AtgSpecialI1Out

func AtgSpecialI1Out(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialI1e

func AtgSpecialI1e(ptr *Ctensor, self Ctensor)

func AtgSpecialI1eOut

func AtgSpecialI1eOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialLog1p

func AtgSpecialLog1p(ptr *Ctensor, self Ctensor)

func AtgSpecialLog1pOut

func AtgSpecialLog1pOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialLogSoftmax

func AtgSpecialLogSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32)

func AtgSpecialLogit

func AtgSpecialLogit(ptr *Ctensor, self Ctensor, epsVal float64, epsNull int)

func AtgSpecialLogitOut

func AtgSpecialLogitOut(ptr *Ctensor, out Ctensor, self Ctensor, epsVal float64, epsNull int)

func AtgSpecialLogsumexp

func AtgSpecialLogsumexp(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgSpecialLogsumexpOut

func AtgSpecialLogsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)

func AtgSpecialMultigammaln

func AtgSpecialMultigammaln(ptr *Ctensor, self Ctensor, p int64)

func AtgSpecialMultigammalnOut

func AtgSpecialMultigammalnOut(ptr *Ctensor, out Ctensor, self Ctensor, p int64)

func AtgSpecialNdtr

func AtgSpecialNdtr(ptr *Ctensor, self Ctensor)

func AtgSpecialNdtrOut

func AtgSpecialNdtrOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialNdtri

func AtgSpecialNdtri(ptr *Ctensor, self Ctensor)

func AtgSpecialNdtriOut

func AtgSpecialNdtriOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialPolygamma

func AtgSpecialPolygamma(ptr *Ctensor, n int64, self Ctensor)

func AtgSpecialPolygammaOut

func AtgSpecialPolygammaOut(ptr *Ctensor, out Ctensor, n int64, self Ctensor)

func AtgSpecialPsi

func AtgSpecialPsi(ptr *Ctensor, self Ctensor)

func AtgSpecialPsiOut

func AtgSpecialPsiOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialRound

func AtgSpecialRound(ptr *Ctensor, self Ctensor)

func AtgSpecialRoundOut

func AtgSpecialRoundOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialSinc

func AtgSpecialSinc(ptr *Ctensor, self Ctensor)

func AtgSpecialSincOut

func AtgSpecialSincOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSpecialXlog1py

func AtgSpecialXlog1py(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgSpecialXlog1pyOtherScalar

func AtgSpecialXlog1pyOtherScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgSpecialXlog1pyOtherScalarOut

func AtgSpecialXlog1pyOtherScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgSpecialXlog1pyOut

func AtgSpecialXlog1pyOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgSpecialXlog1pySelfScalar

func AtgSpecialXlog1pySelfScalar(ptr *Ctensor, selfScalar Cscalar, other Ctensor)

func AtgSpecialXlog1pySelfScalarOut

func AtgSpecialXlog1pySelfScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, other Ctensor)

func AtgSpecialXlogy

func AtgSpecialXlogy(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgSpecialXlogyOtherScalar

func AtgSpecialXlogyOtherScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgSpecialXlogyOtherScalarOut

func AtgSpecialXlogyOtherScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgSpecialXlogyOut

func AtgSpecialXlogyOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgSpecialXlogySelfScalar

func AtgSpecialXlogySelfScalar(ptr *Ctensor, selfScalar Cscalar, other Ctensor)

func AtgSpecialXlogySelfScalarOut

func AtgSpecialXlogySelfScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, other Ctensor)

func AtgSpecialZeta

func AtgSpecialZeta(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgSpecialZetaOtherScalar

func AtgSpecialZetaOtherScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgSpecialZetaOtherScalarOut

func AtgSpecialZetaOtherScalarOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgSpecialZetaOut

func AtgSpecialZetaOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgSpecialZetaSelfScalar

func AtgSpecialZetaSelfScalar(ptr *Ctensor, selfScalar Cscalar, other Ctensor)

func AtgSpecialZetaSelfScalarOut

func AtgSpecialZetaSelfScalarOut(ptr *Ctensor, out Ctensor, selfScalar Cscalar, other Ctensor)

func AtgSqrt

func AtgSqrt(ptr *Ctensor, self Ctensor)

func AtgSqrtOut

func AtgSqrtOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSqrt_

func AtgSqrt_(ptr *Ctensor, self Ctensor)

func AtgSquare

func AtgSquare(ptr *Ctensor, self Ctensor)

func AtgSquareOut

func AtgSquareOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgSquare_

func AtgSquare_(ptr *Ctensor, self Ctensor)

func AtgSqueeze

func AtgSqueeze(ptr *Ctensor, self Ctensor)

func AtgSqueezeDim

func AtgSqueezeDim(ptr *Ctensor, self Ctensor, dim int64)

func AtgSqueezeDim_

func AtgSqueezeDim_(ptr *Ctensor, self Ctensor, dim int64)

func AtgSqueeze_

func AtgSqueeze_(ptr *Ctensor, self Ctensor)

func AtgSspaddmm

func AtgSspaddmm(ptr *Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)

func AtgSspaddmmOut

func AtgSspaddmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor)

func AtgStack

func AtgStack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func AtgStackOut

func AtgStackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func AtgStd

func AtgStd(ptr *Ctensor, self Ctensor, unbiased int32)

func AtgStdCorrection

func AtgStdCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32)

func AtgStdCorrectionOut

func AtgStdCorrectionOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32)

func AtgStdDim

func AtgStdDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32)

func AtgStdMean

func AtgStdMean(ptr *Ctensor, self Ctensor, unbiased int32)

func AtgStdMeanCorrection

func AtgStdMeanCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32)

func AtgStdMeanDim

func AtgStdMeanDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32)

func AtgStdOut

func AtgStdOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32)

func AtgStft

func AtgStft(ptr *Ctensor, self Ctensor, nFft int64, hopLengthVal int64, hopLengthNull int, winLengthVal int64, winLengthNull int, window Ctensor, normalized int32, onesided int32, returnComplex int32)

func AtgSub

func AtgSub(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgSubOut

func AtgSubOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgSubScalar

func AtgSubScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgSubScalar_

func AtgSubScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgSub_

func AtgSub_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgSubtract

func AtgSubtract(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgSubtractOut

func AtgSubtractOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgSubtractScalar

func AtgSubtractScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgSubtractScalar_

func AtgSubtractScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgSubtract_

func AtgSubtract_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgSum

func AtgSum(ptr *Ctensor, self Ctensor, dtype int32)

func AtgSumDimIntlist

func AtgSumDimIntlist(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgSumIntlistOut

func AtgSumIntlistOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32)

func AtgSumToSize

func AtgSumToSize(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)

func AtgSvd

func AtgSvd(ptr *Ctensor, self Ctensor, some int32, computeUv int32)

func AtgSvdU

func AtgSvdU(ptr *Ctensor, u Ctensor, s Ctensor, v Ctensor, self Ctensor, some int32, computeUv int32)

func AtgSwapaxes

func AtgSwapaxes(ptr *Ctensor, self Ctensor, axis0 int64, axis1 int64)

func AtgSwapaxes_

func AtgSwapaxes_(ptr *Ctensor, self Ctensor, axis0 int64, axis1 int64)

func AtgSwapdims

func AtgSwapdims(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)

func AtgSwapdims_

func AtgSwapdims_(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)

func AtgSymeig

func AtgSymeig(ptr *Ctensor, self Ctensor, eigenvectors int32, upper int32)

func AtgSymeigE

func AtgSymeigE(ptr *Ctensor, e Ctensor, v Ctensor, self Ctensor, eigenvectors int32, upper int32)

func AtgT

func AtgT(ptr *Ctensor, self Ctensor)

func AtgT_

func AtgT_(ptr *Ctensor, self Ctensor)

func AtgTake

func AtgTake(ptr *Ctensor, self Ctensor, index Ctensor)

func AtgTakeAlongDim

func AtgTakeAlongDim(ptr *Ctensor, self Ctensor, indices Ctensor, dimVal int64, dimNull int)

func AtgTakeAlongDimOut

func AtgTakeAlongDimOut(ptr *Ctensor, out Ctensor, self Ctensor, indices Ctensor, dimVal int64, dimNull int)

func AtgTakeOut

func AtgTakeOut(ptr *Ctensor, out Ctensor, self Ctensor, index Ctensor)

func AtgTan

func AtgTan(ptr *Ctensor, self Ctensor)

func AtgTanOut

func AtgTanOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgTan_

func AtgTan_(ptr *Ctensor, self Ctensor)

func AtgTanh

func AtgTanh(ptr *Ctensor, self Ctensor)

func AtgTanhBackward

func AtgTanhBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor)

func AtgTanhBackwardGradInput

func AtgTanhBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, output Ctensor)

func AtgTanhOut

func AtgTanhOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgTanh_

func AtgTanh_(ptr *Ctensor, self Ctensor)

func AtgTensordot

func AtgTensordot(ptr *Ctensor, self Ctensor, other Ctensor, dimsSelfData []int64, dimsSelfLen int, dimsOtherData []int64, dimsOtherLen int)

func AtgTensordotOut

func AtgTensordotOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, dimsSelfData []int64, dimsSelfLen int, dimsOtherData []int64, dimsOtherLen int)

func AtgThreshold

func AtgThreshold(ptr *Ctensor, self Ctensor, threshold Cscalar, value Cscalar)

func AtgThresholdBackward

func AtgThresholdBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, threshold Cscalar)

func AtgThresholdBackwardGradInput

func AtgThresholdBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, threshold Cscalar)

func AtgThresholdOut

func AtgThresholdOut(ptr *Ctensor, out Ctensor, self Ctensor, threshold Cscalar, value Cscalar)

func AtgThreshold_

func AtgThreshold_(ptr *Ctensor, self Ctensor, threshold Cscalar, value Cscalar)

func AtgTile

func AtgTile(ptr *Ctensor, self Ctensor, dimsData []int64, dimsLen int)

func AtgTo

func AtgTo(ptr *Ctensor, self Ctensor, device int32)

func AtgToDense

func AtgToDense(ptr *Ctensor, self Ctensor, dtype int32)

func AtgToDenseBackward

func AtgToDenseBackward(ptr *Ctensor, grad Ctensor, input Ctensor)

func AtgToDevice

func AtgToDevice(ptr *Ctensor, self Ctensor, device int32, dtype int32, nonBlocking int32, copy int32)

func AtgToDtype

func AtgToDtype(ptr *Ctensor, self Ctensor, dtype int32, nonBlocking int32, copy int32)

func AtgToDtypeLayout

func AtgToDtypeLayout(ptr *Ctensor, self Ctensor, optionsKind int32, optionsDevice int32, nonBlocking int32, copy int32)

func AtgToMkldnn

func AtgToMkldnn(ptr *Ctensor, self Ctensor, dtype int32)

func AtgToMkldnnBackward

func AtgToMkldnnBackward(ptr *Ctensor, grad Ctensor, input Ctensor)

func AtgToOther

func AtgToOther(ptr *Ctensor, self Ctensor, other Ctensor, nonBlocking int32, copy int32)

func AtgToSparse

func AtgToSparse(ptr *Ctensor, self Ctensor)

func AtgToSparseSparseDim

func AtgToSparseSparseDim(ptr *Ctensor, self Ctensor, sparseDim int64)

func AtgTopk

func AtgTopk(ptr *Ctensor, self Ctensor, k int64, dim int64, largest int32, sorted int32)

func AtgTopkValues

func AtgTopkValues(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, k int64, dim int64, largest int32, sorted int32)

func AtgTotype

func AtgTotype(ptr *Ctensor, self Ctensor, scalarType int32)

func AtgTrace

func AtgTrace(ptr *Ctensor, self Ctensor)

func AtgTraceBackward

func AtgTraceBackward(ptr *Ctensor, grad Ctensor, sizesData []int64, sizesLen int)

func AtgTranspose

func AtgTranspose(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)

func AtgTranspose_

func AtgTranspose_(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)

func AtgTrapezoid

func AtgTrapezoid(ptr *Ctensor, y Ctensor, dim int64)

func AtgTrapezoidX

func AtgTrapezoidX(ptr *Ctensor, y Ctensor, x Ctensor, dim int64)

func AtgTrapz

func AtgTrapz(ptr *Ctensor, y Ctensor, x Ctensor, dim int64)

func AtgTrapzDx

func AtgTrapzDx(ptr *Ctensor, y Ctensor, dx float64, dim int64)

func AtgTriangularSolve

func AtgTriangularSolve(ptr *Ctensor, self Ctensor, a Ctensor, upper int32, transpose int32, unitriangular int32)

func AtgTriangularSolveX

func AtgTriangularSolveX(ptr *Ctensor, x Ctensor, m Ctensor, self Ctensor, a Ctensor, upper int32, transpose int32, unitriangular int32)

func AtgTril

func AtgTril(ptr *Ctensor, self Ctensor, diagonal int64)

func AtgTrilIndices

func AtgTrilIndices(ptr *Ctensor, row int64, col int64, offset int64, optionsKind int32, optionsDevice int32)

func AtgTrilOut

func AtgTrilOut(ptr *Ctensor, out Ctensor, self Ctensor, diagonal int64)

func AtgTril_

func AtgTril_(ptr *Ctensor, self Ctensor, diagonal int64)

func AtgTripletMarginLoss

func AtgTripletMarginLoss(ptr *Ctensor, anchor Ctensor, positive Ctensor, negative Ctensor, margin float64, p float64, eps float64, swap int32, reduction int64)

func AtgTriu

func AtgTriu(ptr *Ctensor, self Ctensor, diagonal int64)

func AtgTriuIndices

func AtgTriuIndices(ptr *Ctensor, row int64, col int64, offset int64, optionsKind int32, optionsDevice int32)

func AtgTriuOut

func AtgTriuOut(ptr *Ctensor, out Ctensor, self Ctensor, diagonal int64)

func AtgTriu_

func AtgTriu_(ptr *Ctensor, self Ctensor, diagonal int64)

func AtgTrueDivide

func AtgTrueDivide(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgTrueDivideOut

func AtgTrueDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgTrueDivideScalar

func AtgTrueDivideScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgTrueDivideScalar_

func AtgTrueDivideScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgTrueDivide_

func AtgTrueDivide_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgTrunc

func AtgTrunc(ptr *Ctensor, self Ctensor)

func AtgTruncOut

func AtgTruncOut(ptr *Ctensor, out Ctensor, self Ctensor)

func AtgTrunc_

func AtgTrunc_(ptr *Ctensor, self Ctensor)

func AtgTypeAs

func AtgTypeAs(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgUnflatten

func AtgUnflatten(ptr *Ctensor, self Ctensor, dim int64, sizesData []int64, sizesLen int)

func AtgUnfold

func AtgUnfold(ptr *Ctensor, self Ctensor, dimension int64, size int64, step int64)

func AtgUnfoldBackward

func AtgUnfoldBackward(ptr *Ctensor, gradIn Ctensor, inputSizesData []int64, inputSizesLen int, dim int64, size int64, step int64)

func AtgUniform_

func AtgUniform_(ptr *Ctensor, self Ctensor, from float64, to float64)

func AtgUniqueConsecutive

func AtgUniqueConsecutive(ptr *Ctensor, self Ctensor, returnInverse int32, returnCounts int32, dimVal int64, dimNull int)

func AtgUniqueDim

func AtgUniqueDim(ptr *Ctensor, self Ctensor, dim int64, sorted int32, returnInverse int32, returnCounts int32)

func AtgUniqueDimConsecutive

func AtgUniqueDimConsecutive(ptr *Ctensor, self Ctensor, dim int64, returnInverse int32, returnCounts int32)

func AtgUnsqueeze

func AtgUnsqueeze(ptr *Ctensor, self Ctensor, dim int64)

func AtgUnsqueeze_

func AtgUnsqueeze_(ptr *Ctensor, self Ctensor, dim int64)

func AtgUpsampleBicubic2d

func AtgUpsampleBicubic2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleBicubic2dBackward

func AtgUpsampleBicubic2dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleBicubic2dBackwardGradInput

func AtgUpsampleBicubic2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleBicubic2dOut

func AtgUpsampleBicubic2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleBilinear2d

func AtgUpsampleBilinear2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleBilinear2dBackward

func AtgUpsampleBilinear2dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleBilinear2dBackwardGradInput

func AtgUpsampleBilinear2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleBilinear2dOut

func AtgUpsampleBilinear2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleLinear1d

func AtgUpsampleLinear1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesVal float64, scalesNull int)

func AtgUpsampleLinear1dBackward

func AtgUpsampleLinear1dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesVal float64, scalesNull int)

func AtgUpsampleLinear1dBackwardGradInput

func AtgUpsampleLinear1dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesVal float64, scalesNull int)

func AtgUpsampleLinear1dOut

func AtgUpsampleLinear1dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesVal float64, scalesNull int)

func AtgUpsampleNearest1d

func AtgUpsampleNearest1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesVal float64, scalesNull int)

func AtgUpsampleNearest1dBackward

func AtgUpsampleNearest1dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesVal float64, scalesNull int)

func AtgUpsampleNearest1dBackwardGradInput

func AtgUpsampleNearest1dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesVal float64, scalesNull int)

func AtgUpsampleNearest1dOut

func AtgUpsampleNearest1dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesVal float64, scalesNull int)

func AtgUpsampleNearest2d

func AtgUpsampleNearest2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleNearest2dBackward

func AtgUpsampleNearest2dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleNearest2dBackwardGradInput

func AtgUpsampleNearest2dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleNearest2dOut

func AtgUpsampleNearest2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleNearest3d

func AtgUpsampleNearest3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleNearest3dBackward

func AtgUpsampleNearest3dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleNearest3dBackwardGradInput

func AtgUpsampleNearest3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleNearest3dOut

func AtgUpsampleNearest3dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleTrilinear3d

func AtgUpsampleTrilinear3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleTrilinear3dBackward

func AtgUpsampleTrilinear3dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleTrilinear3dBackwardGradInput

func AtgUpsampleTrilinear3dBackwardGradInput(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgUpsampleTrilinear3dOut

func AtgUpsampleTrilinear3dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int)

func AtgValueSelectingReductionBackward

func AtgValueSelectingReductionBackward(ptr *Ctensor, grad Ctensor, dim int64, indices Ctensor, sizesData []int64, sizesLen int, keepdim int32)

func AtgValues

func AtgValues(ptr *Ctensor, self Ctensor)

func AtgVander

func AtgVander(ptr *Ctensor, x Ctensor, nVal int64, nNull int, increasing int32)

func AtgVar

func AtgVar(ptr *Ctensor, self Ctensor, unbiased int32)

func AtgVarCorrection

func AtgVarCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32)

func AtgVarCorrectionOut

func AtgVarCorrectionOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32)

func AtgVarDim

func AtgVarDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32)

func AtgVarMean

func AtgVarMean(ptr *Ctensor, self Ctensor, unbiased int32)

func AtgVarMeanCorrection

func AtgVarMeanCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32)

func AtgVarMeanDim

func AtgVarMeanDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32)

func AtgVarOut

func AtgVarOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32)

func AtgVdot

func AtgVdot(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgVdotOut

func AtgVdotOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgView

func AtgView(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)

func AtgViewAs

func AtgViewAs(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgViewAsComplex

func AtgViewAsComplex(ptr *Ctensor, self Ctensor)

func AtgViewAsReal

func AtgViewAsReal(ptr *Ctensor, self Ctensor)

func AtgViewDtype

func AtgViewDtype(ptr *Ctensor, self Ctensor, dtype int32)

func AtgVstack

func AtgVstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgVstackOut

func AtgVstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)

func AtgWhereScalar

func AtgWhereScalar(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Cscalar)

func AtgWhereScalarother

func AtgWhereScalarother(ptr *Ctensor, condition Ctensor, self Ctensor, other Cscalar)

func AtgWhereScalarself

func AtgWhereScalarself(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Ctensor)

func AtgWhereSelf

func AtgWhereSelf(ptr *Ctensor, condition Ctensor, self Ctensor, other Ctensor)

func AtgXlogy

func AtgXlogy(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgXlogyOutscalarOther

func AtgXlogyOutscalarOther(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)

func AtgXlogyOutscalarSelf

func AtgXlogyOutscalarSelf(ptr *Ctensor, out Ctensor, selfScalar Cscalar, other Ctensor)

func AtgXlogyOuttensor

func AtgXlogyOuttensor(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func AtgXlogyScalarOther

func AtgXlogyScalarOther(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgXlogyScalarOther_

func AtgXlogyScalarOther_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtgXlogyScalarSelf

func AtgXlogyScalarSelf(ptr *Ctensor, selfScalar Cscalar, other Ctensor)

func AtgXlogy_

func AtgXlogy_(ptr *Ctensor, self Ctensor, other Ctensor)

func AtgZero_

func AtgZero_(ptr *Ctensor, self Ctensor)

func AtgZeros

func AtgZeros(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func AtgZerosLike

func AtgZerosLike(ptr *Ctensor, self Ctensor)

func AtgZerosOut

func AtgZerosOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int)

func Atg_AdaptiveAvgPool2d

func Atg_AdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func Atg_AdaptiveAvgPool2dBackward

func Atg_AdaptiveAvgPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)

func Atg_AdaptiveAvgPool3d

func Atg_AdaptiveAvgPool3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)

func Atg_AdaptiveAvgPool3dBackward

func Atg_AdaptiveAvgPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor)

func Atg_AddBatchDim

func Atg_AddBatchDim(ptr *Ctensor, self Ctensor, batchDim int64, level int64)

func Atg_AddRelu

func Atg_AddRelu(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg_AddReluOut

func Atg_AddReluOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)

func Atg_AddReluScalar

func Atg_AddReluScalar(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg_AddReluScalar_

func Atg_AddReluScalar_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg_AddRelu_

func Atg_AddRelu_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg_Aminmax

func Atg_Aminmax(ptr *Ctensor, self Ctensor)

func Atg_AminmaxDim

func Atg_AminmaxDim(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)

func Atg_AmpUpdateScale_

func Atg_AmpUpdateScale_(ptr *Ctensor, self Ctensor, growthTracker Ctensor, foundInf Ctensor, scaleGrowthFactor float64, scaleBackoffFactor float64, growthInterval int64)

func Atg_BaddbmmMkl_

func Atg_BaddbmmMkl_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)

func Atg_CastByte

func Atg_CastByte(ptr *Ctensor, self Ctensor, nonBlocking int32)

func Atg_CastChar

func Atg_CastChar(ptr *Ctensor, self Ctensor, nonBlocking int32)

func Atg_CastDouble

func Atg_CastDouble(ptr *Ctensor, self Ctensor, nonBlocking int32)

func Atg_CastFloat

func Atg_CastFloat(ptr *Ctensor, self Ctensor, nonBlocking int32)

func Atg_CastHalf

func Atg_CastHalf(ptr *Ctensor, self Ctensor, nonBlocking int32)

func Atg_CastInt

func Atg_CastInt(ptr *Ctensor, self Ctensor, nonBlocking int32)

func Atg_CastLong

func Atg_CastLong(ptr *Ctensor, self Ctensor, nonBlocking int32)

func Atg_CastShort

func Atg_CastShort(ptr *Ctensor, self Ctensor, nonBlocking int32)

func Atg_Cat

func Atg_Cat(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func Atg_CatOut

func Atg_CatOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func Atg_CdistBackward

func Atg_CdistBackward(ptr *Ctensor, grad Ctensor, x1 Ctensor, x2 Ctensor, p float64, cdist Ctensor)

func Atg_CholeskySolveHelper

func Atg_CholeskySolveHelper(ptr *Ctensor, self Ctensor, a Ctensor, upper int32)

func Atg_Coalesce

func Atg_Coalesce(ptr *Ctensor, self Ctensor)

func Atg_Coalesced_

func Atg_Coalesced_(ptr *Ctensor, self Ctensor, coalesced int32)

func Atg_ComputeLinearCombination

func Atg_ComputeLinearCombination(ptr *Ctensor, input Ctensor, coefficients Ctensor)

func Atg_ComputeLinearCombinationOut

func Atg_ComputeLinearCombinationOut(ptr *Ctensor, out Ctensor, input Ctensor, coefficients Ctensor)

func Atg_Conj

func Atg_Conj(ptr *Ctensor, self Ctensor)

func Atg_ConjPhysical

func Atg_ConjPhysical(ptr *Ctensor, self Ctensor)

func Atg_ConvDepthwise2d

func Atg_ConvDepthwise2d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int)

func Atg_ConvDepthwise2dBackward

func Atg_ConvDepthwise2dBackward(ptr *Ctensor, gradInput Ctensor, gradWeight Ctensor, gradOutput Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int)

func Atg_ConvDepthwise2dOut

func Atg_ConvDepthwise2dOut(ptr *Ctensor, out Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int)

func Atg_ConvertIndicesFromCooToCsr

func Atg_ConvertIndicesFromCooToCsr(ptr *Ctensor, self Ctensor, size int64, outInt32 int32)

func Atg_ConvertIndicesFromCooToCsrOut

func Atg_ConvertIndicesFromCooToCsrOut(ptr *Ctensor, out Ctensor, self Ctensor, size int64, outInt32 int32)

func Atg_Convolution

func Atg_Convolution(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, transposed int32, outputPaddingData []int64, outputPaddingLen int, groups int64, benchmark int32, deterministic int32, cudnnEnabled int32, allowTf32 int32)

func Atg_ConvolutionDeprecated

func Atg_ConvolutionDeprecated(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, transposed int32, outputPaddingData []int64, outputPaddingLen int, groups int64, benchmark int32, deterministic int32, cudnnEnabled int32)

func Atg_ConvolutionMode

func Atg_ConvolutionMode(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, padding string, dilationData []int64, dilationLen int, groups int64)

func Atg_ConvolutionNogroup

func Atg_ConvolutionNogroup(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, transposed int32, outputPaddingData []int64, outputPaddingLen int)

func Atg_CopyFrom

func Atg_CopyFrom(ptr *Ctensor, self Ctensor, dst Ctensor, nonBlocking int32)

func Atg_CopyFromAndResize

func Atg_CopyFromAndResize(ptr *Ctensor, self Ctensor, dst Ctensor)

func Atg_CtcLoss

func Atg_CtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, inputLengthsLen int, targetLengthsData []int64, targetLengthsLen int, blank int64, zeroInfinity int32)

func Atg_CtcLossBackward

func Atg_CtcLossBackward(ptr *Ctensor, grad Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, inputLengthsLen int, targetLengthsData []int64, targetLengthsLen int, negLogLikelihood Ctensor, logAlpha Ctensor, blank int64, zeroInfinity int32)

func Atg_CudnnCtcLoss

func Atg_CudnnCtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, inputLengthsLen int, targetLengthsData []int64, targetLengthsLen int, blank int64, deterministic int32, zeroInfinity int32)

func Atg_CudnnInitDropoutState

func Atg_CudnnInitDropoutState(ptr *Ctensor, dropout float64, train int32, dropoutSeed int64, optionsKind int32, optionsDevice int32)

func Atg_CudnnRnn

func Atg_CudnnRnn(ptr *Ctensor, input Ctensor, weightData []Ctensor, weightLen int, weightStride0 int64, weightBuf Ctensor, hx Ctensor, cx Ctensor, mode int64, hiddenSize int64, projSize int64, numLayers int64, batchFirst int32, dropout float64, train int32, bidirectional int32, batchSizesData []int64, batchSizesLen int, dropoutState Ctensor)

func Atg_CudnnRnnFlattenWeight

func Atg_CudnnRnnFlattenWeight(ptr *Ctensor, weightArrData []Ctensor, weightArrLen int, weightStride0 int64, inputSize int64, mode int64, hiddenSize int64, projSize int64, numLayers int64, batchFirst int32, bidirectional int32)

func Atg_CufftGetPlanCacheMaxSize

func Atg_CufftGetPlanCacheMaxSize(deviceIndex int64) int64

func Atg_CufftGetPlanCacheSize

func Atg_CufftGetPlanCacheSize(deviceIndex int64) int64

func Atg_DebugHasInternalOverlap

func Atg_DebugHasInternalOverlap(self Ctensor) int64

func Atg_DetLuBasedHelper

func Atg_DetLuBasedHelper(ptr *Ctensor, self Ctensor)

func Atg_DetLuBasedHelperBackwardHelper

func Atg_DetLuBasedHelperBackwardHelper(ptr *Ctensor, detGrad Ctensor, det Ctensor, self Ctensor, lu Ctensor, pivs Ctensor)

func Atg_DimArange

func Atg_DimArange(ptr *Ctensor, like Ctensor, dim int64)

func Atg_Dimi

func Atg_Dimi(self Ctensor) int64

func Atg_Dimv

func Atg_Dimv(self Ctensor) int64

func Atg_DirichletGrad

func Atg_DirichletGrad(ptr *Ctensor, x Ctensor, alpha Ctensor, total Ctensor)

func Atg_EmbeddingBag

func Atg_EmbeddingBag(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, scaleGradByFreq int32, mode int64, sparse int32, perSampleWeights Ctensor, includeLastOffset int32, paddingIdx int64)

func Atg_EmbeddingBagBackward

func Atg_EmbeddingBagBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, offsets Ctensor, offset2bag Ctensor, bagSize Ctensor, maximumIndices Ctensor, numWeights int64, scaleGradByFreq int32, mode int64, sparse int32, perSampleWeights Ctensor, paddingIdx int64)

func Atg_EmbeddingBagDenseBackward

func Atg_EmbeddingBagDenseBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, offset2bag Ctensor, bagSize Ctensor, maximumIndices Ctensor, numWeights int64, scaleGradByFreq int32, mode int64, perSampleWeights Ctensor, paddingIdx int64)

func Atg_EmbeddingBagForwardOnly

func Atg_EmbeddingBagForwardOnly(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, scaleGradByFreq int32, mode int64, sparse int32, perSampleWeights Ctensor, includeLastOffset int32, paddingIdx int64)

func Atg_EmbeddingBagPerSampleWeightsBackward

func Atg_EmbeddingBagPerSampleWeightsBackward(ptr *Ctensor, grad Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, offset2bag Ctensor, mode int64, paddingIdx int64)

func Atg_EmbeddingBagSparseBackward

func Atg_EmbeddingBagSparseBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, offsets Ctensor, offset2bag Ctensor, bagSize Ctensor, numWeights int64, scaleGradByFreq int32, mode int64, perSampleWeights Ctensor, paddingIdx int64)

func Atg_EmptyAffineQuantized

func Atg_EmptyAffineQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32, scale float64, zeroPoint int64)

func Atg_EmptyPerChannelAffineQuantized

func Atg_EmptyPerChannelAffineQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, scales Ctensor, zeroPoints Ctensor, axis int64, optionsKind int32, optionsDevice int32)

func Atg_EuclideanDist

func Atg_EuclideanDist(ptr *Ctensor, x1 Ctensor, x2 Ctensor)

func Atg_FakeQuantizeLearnablePerChannelAffine

func Atg_FakeQuantizeLearnablePerChannelAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, quantMin int64, quantMax int64, gradFactor float64)

func Atg_FakeQuantizeLearnablePerChannelAffineBackward

func Atg_FakeQuantizeLearnablePerChannelAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, quantMin int64, quantMax int64, gradFactor float64)

func Atg_FakeQuantizeLearnablePerTensorAffine

func Atg_FakeQuantizeLearnablePerTensorAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, quantMin int64, quantMax int64, gradFactor float64)

func Atg_FakeQuantizeLearnablePerTensorAffineBackward

func Atg_FakeQuantizeLearnablePerTensorAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, quantMin int64, quantMax int64, gradFactor float64)

func Atg_FakeQuantizePerTensorAffineCachemaskTensorQparams

func Atg_FakeQuantizePerTensorAffineCachemaskTensorQparams(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, fakeQuantEnabled Ctensor, quantMin int64, quantMax int64)

func Atg_FftC2c

func Atg_FftC2c(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, normalization int64, forward int32)

func Atg_FftC2cOut

func Atg_FftC2cOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, normalization int64, forward int32)

func Atg_FftC2r

func Atg_FftC2r(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, normalization int64, lastDimSize int64)

func Atg_FftC2rOut

func Atg_FftC2rOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, normalization int64, lastDimSize int64)

func Atg_FftR2c

func Atg_FftR2c(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, normalization int64, onesided int32)

func Atg_FftR2cOut

func Atg_FftR2cOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, normalization int64, onesided int32)

func Atg_FusedDropout

func Atg_FusedDropout(ptr *Ctensor, self Ctensor, p float64)

func Atg_FusedMovingAvgObsFqHelper

func Atg_FusedMovingAvgObsFqHelper(ptr *Ctensor, self Ctensor, observerOn Ctensor, fakeQuantOn Ctensor, runningMin Ctensor, runningMax Ctensor, scale Ctensor, zeroPoint Ctensor, averagingConst float64, quantMin int64, quantMax int64, chAxis int64, perRowFakeQuant int32, symmetricQuant int32)

func Atg_FwPrimal

func Atg_FwPrimal(ptr *Ctensor, self Ctensor, level int64)

func Atg_GatherSparseBackward

func Atg_GatherSparseBackward(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, grad Ctensor)

func Atg_GridSampler2dCpuFallback

func Atg_GridSampler2dCpuFallback(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32)

func Atg_GridSampler2dCpuFallbackBackward

func Atg_GridSampler2dCpuFallbackBackward(ptr *Ctensor, gradOutput Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32)

func Atg_HasCompatibleShallowCopyType

func Atg_HasCompatibleShallowCopyType(self Ctensor, from Ctensor) bool

func Atg_IndexCopy_

func Atg_IndexCopy_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor)

func Atg_IndexPutImpl_

func Atg_IndexPutImpl_(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, values Ctensor, accumulate int32, unsafety int32)

func Atg_Indices

func Atg_Indices(ptr *Ctensor, self Ctensor)

func Atg_InverseHelper

func Atg_InverseHelper(ptr *Ctensor, self Ctensor)

func Atg_LinalgInvOutHelper_

func Atg_LinalgInvOutHelper_(ptr *Ctensor, self Ctensor, infosLu Ctensor, infosGetri Ctensor)

func Atg_LinalgQrHelper

func Atg_LinalgQrHelper(ptr *Ctensor, self Ctensor, mode string)

func Atg_LogSoftmax

func Atg_LogSoftmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)

func Atg_LogSoftmaxBackwardData

func Atg_LogSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)

func Atg_LogSoftmaxBackwardDataOut

func Atg_LogSoftmaxBackwardDataOut(ptr *Ctensor, out Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)

func Atg_LogSoftmaxOut

func Atg_LogSoftmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, halfToFloat int32)

func Atg_Logcumsumexp

func Atg_Logcumsumexp(ptr *Ctensor, self Ctensor, dim int64)

func Atg_LogcumsumexpOut

func Atg_LogcumsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64)

func Atg_LuWithInfo

func Atg_LuWithInfo(ptr *Ctensor, self Ctensor, pivot int32, checkErrors int32)

func Atg_MakeDual

func Atg_MakeDual(ptr *Ctensor, primal Ctensor, tangent Ctensor, level int64)

func Atg_MakePerChannelQuantizedTensor

func Atg_MakePerChannelQuantizedTensor(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64)

func Atg_MakePerTensorQuantizedTensor

func Atg_MakePerTensorQuantizedTensor(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64)

func Atg_MaskedScale

func Atg_MaskedScale(ptr *Ctensor, self Ctensor, mask Ctensor, scale float64)

func Atg_MkldnnReshape

func Atg_MkldnnReshape(ptr *Ctensor, self Ctensor, shapeData []int64, shapeLen int)

func Atg_MkldnnTranspose

func Atg_MkldnnTranspose(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)

func Atg_MkldnnTranspose_

func Atg_MkldnnTranspose_(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64)

func Atg_NegView

func Atg_NegView(ptr *Ctensor, self Ctensor)

func Atg_NnpackAvailable

func Atg_NnpackAvailable() bool

func Atg_NnpackSpatialConvolution

func Atg_NnpackSpatialConvolution(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int)

func Atg_NnpackSpatialConvolutionBackwardInput

func Atg_NnpackSpatialConvolutionBackwardInput(ptr *Ctensor, input Ctensor, gradOutput Ctensor, weight Ctensor, paddingData []int64, paddingLen int)

func Atg_NnpackSpatialConvolutionBackwardWeight

func Atg_NnpackSpatialConvolutionBackwardWeight(ptr *Ctensor, input Ctensor, weightsizeData []int64, weightsizeLen int, gradOutput Ctensor, paddingData []int64, paddingLen int)

func Atg_Nnz

func Atg_Nnz(self Ctensor) int64

func Atg_PackPaddedSequence

func Atg_PackPaddedSequence(ptr *Ctensor, input Ctensor, lengths Ctensor, batchFirst int32)

func Atg_PackPaddedSequenceBackward

func Atg_PackPaddedSequenceBackward(ptr *Ctensor, grad Ctensor, inputSizeData []int64, inputSizeLen int, batchSizes Ctensor, batchFirst int32)

func Atg_PadPackedSequence

func Atg_PadPackedSequence(ptr *Ctensor, data Ctensor, batchSizes Ctensor, batchFirst int32, paddingValue Cscalar, totalLength int64)

func Atg_PdistBackward

func Atg_PdistBackward(ptr *Ctensor, grad Ctensor, self Ctensor, p float64, pdist Ctensor)

func Atg_PinMemory

func Atg_PinMemory(ptr *Ctensor, self Ctensor, device int32)

func Atg_RemoveBatchDim

func Atg_RemoveBatchDim(ptr *Ctensor, self Ctensor, level int64, batchSize int64, outDim int64)

func Atg_ReshapeAlias

func Atg_ReshapeAlias(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, strideLen int)

func Atg_ReshapeFromTensor

func Atg_ReshapeFromTensor(ptr *Ctensor, self Ctensor, shape Ctensor)

func Atg_RowwisePrune

func Atg_RowwisePrune(ptr *Ctensor, weight Ctensor, mask Ctensor, compressedIndicesDtype int32)

func Atg_SWhere

func Atg_SWhere(ptr *Ctensor, condition Ctensor, self Ctensor, other Ctensor)

func Atg_SampleDirichlet

func Atg_SampleDirichlet(ptr *Ctensor, self Ctensor)

func Atg_SaturateWeightToFp16

func Atg_SaturateWeightToFp16(ptr *Ctensor, weight Ctensor)

func Atg_SegmentReduceBackward

func Atg_SegmentReduceBackward(ptr *Ctensor, grad Ctensor, output Ctensor, data Ctensor, reduce string, lengths Ctensor, axis int64)

func Atg_ShapeAsTensor

func Atg_ShapeAsTensor(ptr *Ctensor, self Ctensor)

func Atg_SobolEngineDraw

func Atg_SobolEngineDraw(ptr *Ctensor, quasi Ctensor, n int64, sobolstate Ctensor, dimension int64, numGenerated int64, dtype int32)

func Atg_SobolEngineFf_

func Atg_SobolEngineFf_(ptr *Ctensor, self Ctensor, n int64, sobolstate Ctensor, dimension int64, numGenerated int64)

func Atg_SobolEngineInitializeState_

func Atg_SobolEngineInitializeState_(ptr *Ctensor, self Ctensor, dimension int64)

func Atg_SobolEngineScramble_

func Atg_SobolEngineScramble_(ptr *Ctensor, self Ctensor, ltm Ctensor, dimension int64)

func Atg_Softmax

func Atg_Softmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)

func Atg_SoftmaxBackwardData

func Atg_SoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)

func Atg_SoftmaxBackwardDataOut

func Atg_SoftmaxBackwardDataOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)

func Atg_SoftmaxOut

func Atg_SoftmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, halfToFloat int32)

func Atg_SolveHelper

func Atg_SolveHelper(ptr *Ctensor, self Ctensor, a Ctensor)

func Atg_SparseAddmm

func Atg_SparseAddmm(ptr *Ctensor, self Ctensor, sparse Ctensor, dense Ctensor)

func Atg_SparseCooTensorUnsafe

func Atg_SparseCooTensorUnsafe(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func Atg_SparseCooTensorWithDims

func Atg_SparseCooTensorWithDims(ptr *Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func Atg_SparseCooTensorWithDimsAndTensors

func Atg_SparseCooTensorWithDimsAndTensors(ptr *Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, indices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32)

func Atg_SparseCsrTensorUnsafe

func Atg_SparseCsrTensorUnsafe(ptr *Ctensor, crowIndices Ctensor, colIndices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32)

func Atg_SparseLogSoftmax

func Atg_SparseLogSoftmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)

func Atg_SparseLogSoftmaxBackwardData

func Atg_SparseLogSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)

func Atg_SparseLogSoftmaxInt

func Atg_SparseLogSoftmaxInt(ptr *Ctensor, self Ctensor, dim int64, dtype int32)

func Atg_SparseMaskHelper

func Atg_SparseMaskHelper(ptr *Ctensor, t Ctensor, maskIndices Ctensor)

func Atg_SparseMm

func Atg_SparseMm(ptr *Ctensor, sparse Ctensor, dense Ctensor)

func Atg_SparseSoftmax

func Atg_SparseSoftmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)

func Atg_SparseSoftmaxBackwardData

func Atg_SparseSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)

func Atg_SparseSoftmaxInt

func Atg_SparseSoftmaxInt(ptr *Ctensor, self Ctensor, dim int64, dtype int32)

func Atg_SparseSparseMatmul

func Atg_SparseSparseMatmul(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg_SparseSum

func Atg_SparseSum(ptr *Ctensor, self Ctensor)

func Atg_SparseSumBackward

func Atg_SparseSumBackward(ptr *Ctensor, grad Ctensor, self Ctensor, dimData []int64, dimLen int)

func Atg_SparseSumDim

func Atg_SparseSumDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int)

func Atg_SparseSumDimDtype

func Atg_SparseSumDimDtype(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, dtype int32)

func Atg_SparseSumDtype

func Atg_SparseSumDtype(ptr *Ctensor, self Ctensor, dtype int32)

func Atg_Stack

func Atg_Stack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func Atg_StackOut

func Atg_StackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64)

func Atg_StandardGamma

func Atg_StandardGamma(ptr *Ctensor, self Ctensor)

func Atg_StandardGammaGrad

func Atg_StandardGammaGrad(ptr *Ctensor, self Ctensor, output Ctensor)

func Atg_SvdHelper

func Atg_SvdHelper(ptr *Ctensor, self Ctensor, some int32, computeUv int32)

func Atg_SymeigHelper

func Atg_SymeigHelper(ptr *Ctensor, self Ctensor, eigenvectors int32, upper int32)

func Atg_TestAmbiguousDefaults

func Atg_TestAmbiguousDefaults(ptr *Ctensor, dummy Ctensor, a int64, b int64)

func Atg_TestAmbiguousDefaultsB

func Atg_TestAmbiguousDefaultsB(ptr *Ctensor, dummy Ctensor, a int64, b string)

func Atg_TestOptionalFilledIntlist

func Atg_TestOptionalFilledIntlist(ptr *Ctensor, values Ctensor, addendsData []int64, addendsLen int)

func Atg_TestOptionalIntlist

func Atg_TestOptionalIntlist(ptr *Ctensor, values Ctensor, addendsData []int64, addendsLen int)

func Atg_TestSerializationSubcmul

func Atg_TestSerializationSubcmul(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg_TestStringDefault

func Atg_TestStringDefault(ptr *Ctensor, dummy Ctensor, a string, b string)

func Atg_ToCopy

func Atg_ToCopy(ptr *Ctensor, self Ctensor, optionsKind int32, optionsDevice int32, nonBlocking int32)

func Atg_Trilinear

func Atg_Trilinear(ptr *Ctensor, i1 Ctensor, i2 Ctensor, i3 Ctensor, expand1Data []int64, expand1Len int, expand2Data []int64, expand2Len int, expand3Data []int64, expand3Len int, sumdimData []int64, sumdimLen int, unrollDim int64)

func Atg_Unique

func Atg_Unique(ptr *Ctensor, self Ctensor, sorted int32, returnInverse int32)

func Atg_Unique2

func Atg_Unique2(ptr *Ctensor, self Ctensor, sorted int32, returnInverse int32, returnCounts int32)

func Atg_UnpackDual

func Atg_UnpackDual(ptr *Ctensor, dual Ctensor, level int64)

func Atg_UnsafeView

func Atg_UnsafeView(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)

func Atg_UseCudnnCtcLoss

func Atg_UseCudnnCtcLoss(logProbs Ctensor, targets Ctensor, inputLengthsData []int64, inputLengthsLen int, targetLengthsData []int64, targetLengthsLen int, blank int64) bool

func Atg_UseCudnnRnnFlattenWeight

func Atg_UseCudnnRnnFlattenWeight() bool

func Atg_Values

func Atg_Values(ptr *Ctensor, self Ctensor)

func Atg_Version

func Atg_Version(self Ctensor) int64

func Atg_WeightNorm

func Atg_WeightNorm(ptr *Ctensor, v Ctensor, g Ctensor, dim int64)

func Atg_WeightNormCudaInterface

func Atg_WeightNormCudaInterface(ptr *Ctensor, v Ctensor, g Ctensor, dim int64)

func Atg_WeightNormCudaInterfaceBackward

func Atg_WeightNormCudaInterfaceBackward(ptr *Ctensor, gradW Ctensor, savedV Ctensor, savedG Ctensor, savedNorms Ctensor, dim int64)

func Atg_WeightNormDifferentiableBackward

func Atg_WeightNormDifferentiableBackward(ptr *Ctensor, gradW Ctensor, savedV Ctensor, savedG Ctensor, savedNorms Ctensor, dim int64)

func Atg__AndTensor_

func Atg__AndTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__And_

func Atg__And_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg__IandTensor_

func Atg__IandTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__Iand_

func Atg__Iand_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg__IlshiftTensor_

func Atg__IlshiftTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__Ilshift_

func Atg__Ilshift_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg__IorTensor_

func Atg__IorTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__Ior_

func Atg__Ior_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg__IrshiftTensor_

func Atg__IrshiftTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__Irshift_

func Atg__Irshift_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg__IxorTensor_

func Atg__IxorTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__Ixor_

func Atg__Ixor_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg__LshiftTensor_

func Atg__LshiftTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__Lshift_

func Atg__Lshift_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg__OrTensor_

func Atg__OrTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__Or_

func Atg__Or_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg__RshiftTensor_

func Atg__RshiftTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__Rshift_

func Atg__Rshift_(ptr *Ctensor, self Ctensor, other Cscalar)

func Atg__XorTensor_

func Atg__XorTensor_(ptr *Ctensor, self Ctensor, other Ctensor)

func Atg__Xor_

func Atg__Xor_(ptr *Ctensor, self Ctensor, other Cscalar)

func AtiFree

func AtiFree(val Civalue)

void ati_free(ivalue);

func AtiLength

func AtiLength(val Civalue) int32

int ati_length(ivalue);

func AtiTag

func AtiTag(val Civalue) int32

int ati_tag(ivalue);

func AtiToBool

func AtiToBool(val Civalue) bool

int ati_to_bool(ivalue);

func AtiToBoolList

func AtiToBoolList(val Civalue, ptr unsafe.Pointer, boolListLen int)

void ati_to_bool_list(ivalue, char *, int);

func AtiToDouble

func AtiToDouble(val Civalue) float64

double ati_to_double(ivalue);

func AtiToDoubleList

func AtiToDoubleList(val Civalue, ptr unsafe.Pointer, doubleListLen int)

void ati_to_double_list(ivalue, double *, int);

func AtiToGenericDict

func AtiToGenericDict(val Civalue, ptr *Civalue, genericDictLen int)

void ati_to_generic_dict(ivalue, ivalue *, int);

func AtiToGenericList

func AtiToGenericList(val Civalue, ptr *Civalue, genericListLen int)

void ati_to_generic_list(ivalue, ivalue *, int);

func AtiToInt

func AtiToInt(val Civalue) int64

int64_t ati_to_int(ivalue);

func AtiToIntList

func AtiToIntList(val Civalue, ptr unsafe.Pointer, intListLen int)

void ati_to_int_list(ivalue, int64_t *, int);

func AtiToString

func AtiToString(val Civalue) string

char *ati_to_string(ivalue);

func AtiToTensorList

func AtiToTensorList(val Civalue, ptr *Ctensor, tensorListLen int)

void ati_to_tensor_list(ivalue, tensor *, int);

func AtiToTuple

func AtiToTuple(val Civalue, ptr *Civalue, tupleLen int)

void ati_to_tuple(ivalue, ivalue *, int);

func AtiTupleLength

func AtiTupleLength(val Civalue) int32

int ati_tuple_length(ivalue);

func AtmEval

func AtmEval(m Cmodule)

void atm_eval(module);

func AtmFree

func AtmFree(m Cmodule)

void atm_free(module);

func AtmGetProfilingMode

func AtmGetProfilingMode() bool

int atm_get_profiling_mode();

func AtmNamedParameters

func AtmNamedParameters(m Cmodule, dataPtr unsafe.Pointer)

void atm_named_parameters(module, void *data, void (*f)(void *, char *, tensor));

func AtmSave

func AtmSave(m Cmodule, path string)

void atm_save(module m, char *);

func AtmSetProfilingMode

func AtmSetProfilingMode(b bool)

void atm_set_profiling_mode(int);

func AtmTo

func AtmTo(m Cmodule, device int32, dtype int32, nonBlocking bool)

void atm_to(module m, int device, int dtype, bool non_blocking);

func AtmTrain

func AtmTrain(m Cmodule)

void atm_train(module);

func AtoAddParamGroup

func AtoAddParamGroup(coptimizer Coptimizer, tensors []Ctensor, ntensors int)

func AtoAddParameter

func AtoAddParameter(coptimizer Coptimizer, tensor Ctensor, group uint)

func AtoAddParametersOld

func AtoAddParametersOld(coptimizer Coptimizer, tensors []Ctensor, ntensors int)

NOTE. Backward compat for param group not updated (#261) void ato_add_parameters(optimizer, tensor *, int ntensors);

func AtoFree

func AtoFree(coptimizer Coptimizer)

void ato_free(optimizer);

func AtoGetLearningRates

func AtoGetLearningRates(coptimizer Coptimizer) []float64

func AtoParamGroupNum

func AtoParamGroupNum(coptimizer Coptimizer) int64

func AtoSetLearningRate

func AtoSetLearningRate(coptimizer Coptimizer, learningRate float64)

void ato_set_learning_rate(optimizer, double learning_rate);

func AtoSetLearningRates

func AtoSetLearningRates(coptimizer Coptimizer, lrs []float64)

func AtoSetMomentum

func AtoSetMomentum(coptimizer Coptimizer, momentum float64)

void ato_set_momentum(optimizer, double momentum);

func AtoStep

func AtoStep(coptimizer Coptimizer)

void ato_step(optimizer);

func AtoZeroGrad

func AtoZeroGrad(coptimizer Coptimizer)

void ato_zero_grad(optimizer);

func AtsFree

func AtsFree(cscalar Cscalar)

void ats_free(scalar);

func AtsToFloat

func AtsToFloat(cscalar Cscalar) float64

double ats_to_float(scalar);

func AtsToInt

func AtsToInt(cscalar Cscalar) int64

int64_t ats_to_int(scalar);

func AtsToString

func AtsToString(cscalar Cscalar) string

char *ats_to_string(scalar);

func GetAndResetLastErr

func GetAndResetLastErr() *C.char

Types

type Civalue

type Civalue = C.ivalue

func AtiBool

func AtiBool(val bool) Civalue

ivalue ati_bool(int);

func AtiBoolList

func AtiBoolList(boolListData []bool, boolListLen int) Civalue

ivalue ati_bool_list(char *, int);

func AtiDouble

func AtiDouble(val float64) Civalue

ivalue ati_double(double);

func AtiDoubleList

func AtiDoubleList(doubleListData []float64, doubleListLen int) Civalue

ivalue ati_double_list(double *, int);

func AtiGenericDict

func AtiGenericDict(genericDictData []Civalue, genericDictLen int) Civalue

ivalue ati_generic_dict(ivalue *, int);

func AtiGenericList

func AtiGenericList(genericListData []Civalue, genericListLen int) Civalue

ivalue ati_generic_list(ivalue *, int);

func AtiInt

func AtiInt(val int64) Civalue

ivalue ati_int(int64_t);

func AtiIntList

func AtiIntList(intListData []int64, intListLen int) Civalue

ivalue ati_int_list(int64_t *, int);

func AtiNone

func AtiNone() Civalue

ivalue ati_none();

func AtiString

func AtiString(val string) Civalue

ivalue ati_string(char *);

func AtiTensor

func AtiTensor(ts Ctensor) Civalue

ivalue ati_tensor(tensor);

func AtiTensorList

func AtiTensorList(tensorListData []Ctensor, tensorListLen int) Civalue

ivalue ati_tensor_list(tensor *, int);

func AtiTuple

func AtiTuple(tupleData []Civalue, tupleLen int) Civalue

ivalue ati_tuple(ivalue *, int);

func AtmForward_

func AtmForward_(m Cmodule, ivalues *Civalue, nivalues int) Civalue

ivalue atm_forward_(module, ivalue *ivalues, int nivalues);

type Cmodule

type Cmodule = C.module

func AtmLoad

func AtmLoad(path string) Cmodule

module atm_load(char *);

func AtmLoadOnDevice

func AtmLoadOnDevice(path string, device int32) Cmodule

module atm_load_on_device(char *, int device);

func AtmLoadStr

func AtmLoadStr(val string, sz int) Cmodule

module atm_load_str(char *, size_t sz);

func AtmLoadStrOnDevice

func AtmLoadStrOnDevice(val string, sz int, device int32) Cmodule

module atm_load_str_on_device(char *, size_t sz, int device);

type Coptimizer

type Coptimizer = C.optimizer

func AtoAdam

func AtoAdam(learningRate, beta1, beta2, weightDecay float64) Coptimizer

* optimizer ato_adam(double learning_rate, * double beta1, * double beta2, * double weight_decay); *

func AtoAdamW

func AtoAdamW(learningRate, beta1, beta2, weightDecay float64) Coptimizer

func AtoRmsProp

func AtoRmsProp(learningRate, alpha, eps, weightDecay, momentum float64, centered int) Coptimizer

* optimizer ato_rms_prop(double learning_rate, * double alpha, * double eps, * double weight_decay, * double momentum, * int centered); *

func AtoSgd

func AtoSgd(learningRate, momentum, dampening, weightDecay float64, nesterov int) Coptimizer

* optimizer ato_sgd(double learning_rate, * double momentum, * double dampening, * double weight_decay, * int nesterov); *

type Cscalar

type Cscalar = C.scalar

func AtsFloat

func AtsFloat(v float64) Cscalar

scalar ats_float(double);

func AtsInt

func AtsInt(v int64) Cscalar

scalar ats_int(int64_t);

type Ctensor

type Ctensor = C.tensor

NOTE: C.tensor is a C pointer to torch::Tensor

func AtGet

func AtGet(ts Ctensor, index int) Ctensor

tensor at_get(tensor, int index);

func AtLoad

func AtLoad(path string) Ctensor

tensor at_load(char *filename);

func AtLoadImage

func AtLoadImage(path string) Ctensor

tensor at_load_image(char *filename);

func AtNewTensor

func AtNewTensor() Ctensor

func AtResizeImage

func AtResizeImage(ts Ctensor, w, h int64) Ctensor

tensor at_resize_image(tensor, int w, int h);

func AtShallowClone

func AtShallowClone(ts Ctensor) Ctensor

tensor at_shallow_clone(tensor);

func AtTensorOfData

func AtTensorOfData(vs unsafe.Pointer, dims []int64, ndims uint, elt_size_in_bytes uint, kind int) Ctensor

tensor at_tensor_of_data(void *vs, int64_t *dims, size_t ndims, size_t element_size_in_bytes, int type);

func AtgAlignTensors

func AtgAlignTensors(tensorsData []Ctensor, tensorsLen int) *Ctensor

tensor *atg_align_tensors(tensor *tensors_data, int tensors_len);

func AtgBroadcastTensors

func AtgBroadcastTensors(tensorsData []Ctensor, tensorsLen int) *Ctensor

tensor *atg_broadcast_tensors(tensor *tensors_data, int tensors_len);

func AtgChunk

func AtgChunk(self Ctensor, chunks int64, dim int64) *Ctensor

tensor *atg_chunk(tensor self, int64_t chunks, int64_t dim);

func AtgMeshgrid

func AtgMeshgrid(tensorsData []Ctensor, tensorsLen int) *Ctensor

tensor *atg_meshgrid(tensor *tensors_data, int tensors_len);

func AtgNonzeroNumpy

func AtgNonzeroNumpy(self Ctensor) *Ctensor

tensor *atg_nonzero_numpy(tensor self);

func AtgSplit

func AtgSplit(self Ctensor, splitSize int64, dim int64) *Ctensor

tensor *atg_split(tensor self, int64_t split_size, int64_t dim);

func AtgSplitWithSizes

func AtgSplitWithSizes(self Ctensor, splitSizesData []int64, splitSizesLen int, dim int64) *Ctensor

tensor *atg_split_with_sizes(tensor self, int64_t *split_sizes_data, int split_sizes_len, int64_t dim);

func AtgUnbind

func AtgUnbind(self Ctensor, dim int64) *Ctensor

tensor *atg_unbind(tensor self, int64_t dim);

func AtgWhere

func AtgWhere(condition Ctensor) *Ctensor

tensor *atg_where(tensor condition);

func AtiToTensor

func AtiToTensor(val Civalue) Ctensor

tensor ati_to_tensor(ivalue);

func AtmForward

func AtmForward(m Cmodule, tensors *Ctensor, ntensors int) Ctensor

tensor atm_forward(module, tensor *tensors, int ntensors);

func NewTensor

func NewTensor() Ctensor

tensor at_new_tensor();

type LoadData

type LoadData struct {
	NamedCtensors []NamedCtensor
}

type NamedCtensor

type NamedCtensor struct {
	Name    string
	Ctensor C.tensor
}

type PointerStore

type PointerStore struct {
	// contains filtered or unexported fields
}

PointerStore is a Go struct to deal with the Go use case that we can not pass Go pointer to C. In other words, it is used to solve error: "panic: runtime error: cgo argument has Go pointer to Go pointer"

NOTE: the concept is taken from: https://github.com/mattn/go-pointer

Example:

store := NewPointerStore()
type Car struct{Name string, Model string}
var landy Car{Name: "Defender", Model: "99"}
landyPtr := store.Set(landy)
landy = store.Get(landyPtr).(Car)
store.Free(landyPtr)

func NewPointerStore

func NewPointerStore() PointerStore

NewPointerStore creates a new PointerStore

func (PointerStore) Free

func (ps PointerStore) Free(ptr unsafe.Pointer)

Delete removes pointer from pointer store and frees up memory.

Example: TODO: an example

func (PointerStore) Get

func (ps PointerStore) Get(ptr unsafe.Pointer) (v interface{})

Get get value back from pointer store

Example: TODO: an example

func (PointerStore) Set

func (ps PointerStore) Set(v interface{}) unsafe.Pointer

Set stores value to pointer store and returns a unsafe.Pointer

NOTE: This is a little hacky. As Go doesn't allow C code to store Go pointers, a one-byte C pointer is created for indexing purpose.

Example: TODO: an example