libtch

package

v0.3.110 Latest Latest Go to latest Published: Jul 3, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/ZonghaoWang/gotch

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, gradOutput Ctensor, self Ctensor)
func AtgAdaptiveAvgPool3dBackwardOut(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 AtgAdaptiveMaxPool2dBackwardOut(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 AtgAdaptiveMaxPool3dBackwardOut(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 AtgAdd1(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgAdd1_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgAddOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
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 AtgAll1(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
func AtgAllOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32)
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 AtgAngle(ptr *Ctensor, self Ctensor)
func AtgAngleOut(ptr *Ctensor, out Ctensor, self Ctensor)
func AtgAny(ptr *Ctensor, self Ctensor)
func AtgAny1(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 AtgArange1(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, ...)
func AtgArange2(ptr *Ctensor, start Cscalar, end Cscalar, step Cscalar, optionsKind int32, ...)
func AtgArangeOut(ptr *Ctensor, out Ctensor, end Cscalar)
func AtgArangeOut1(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar)
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 AtgArgmin(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32)
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 AtgAvgPool2dBackwardOut(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 AtgAvgPool3dBackwardOut(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 AtgBartlettWindow1(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 AtgBernoulli1(ptr *Ctensor, self Ctensor, p float64)
func AtgBernoulli1_(ptr *Ctensor, self Ctensor, p float64)
func AtgBernoulliOut(ptr *Ctensor, out Ctensor, self Ctensor)
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 AtgBinaryCrossEntropyBackwardOut(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 AtgBitwiseAnd1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgBitwiseAnd1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgBitwiseAndOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgBitwiseAndOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgBitwiseAnd_(ptr *Ctensor, self Ctensor, other Cscalar)
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 AtgBitwiseOr1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgBitwiseOr1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgBitwiseOrOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgBitwiseOrOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgBitwiseOr_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgBitwiseXor(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgBitwiseXor1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgBitwiseXor1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgBitwiseXorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgBitwiseXorOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgBitwiseXor_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgBlackmanWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)
func AtgBlackmanWindow1(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 AtgBucketize(ptr *Ctensor, self Ctensor, boundaries Ctensor, outInt32 int32, right int32)
func AtgBucketize1(ptr *Ctensor, selfScalar Cscalar, boundaries Ctensor, outInt32 int32, ...)
func AtgBucketizeOut(ptr *Ctensor, out Ctensor, self Ctensor, boundaries Ctensor, outInt32 int32, ...)
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 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 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 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 AtgClampMin_(ptr *Ctensor, self Ctensor, min Cscalar)
func AtgClampOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar, max Cscalar)
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 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 AtgCol2imBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, kernelSizeData []int64, ...)
func AtgCol2imOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, ...)
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 AtgConj(ptr *Ctensor, self Ctensor)
func AtgConjOut(ptr *Ctensor, out 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 AtgConv2d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
func AtgConv3d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
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 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, dimData []int64, dimLen int)
func AtgCountNonzero1(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int)
func AtgCross(ptr *Ctensor, self Ctensor, other Ctensor, dimVal int64, dimNull int)
func AtgCrossOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, dimVal int64, ...)
func AtgCtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, ...)
func AtgCtcLoss1(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 AtgCudnnConvolution1(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, ...)
func AtgCudnnConvolution2(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, ...)
func AtgCudnnConvolutionBackwardInput(ptr *Ctensor, selfSizeData []int64, selfSizeLen int, gradOutput Ctensor, ...)
func AtgCudnnConvolutionBackwardWeight(ptr *Ctensor, weightSizeData []int64, weightSizeLen int, gradOutput Ctensor, ...)
func AtgCudnnConvolutionTranspose(ptr *Ctensor, self Ctensor, weight Ctensor, paddingData []int64, ...)
func AtgCudnnConvolutionTranspose1(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, ...)
func AtgCudnnConvolutionTranspose2(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 AtgCudnnGridSampler(ptr *Ctensor, self Ctensor, grid Ctensor)
func AtgCudnnGridSamplerBackward(ptr *Ctensor, self Ctensor, grid Ctensor, gradOutput Ctensor)
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)
func AtgCumprodOut(ptr *Ctensor, out 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 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 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, grad Ctensor, inputSizesData []int64, inputSizesLen int, ...)
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 AtgDiv1(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgDiv1_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgDivOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgDiv_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgDivide(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgDivide1(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgDivide1_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
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 AtgEigOut(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 AtgEluBackwardOut(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 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 AtgEmptyMeta(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
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 AtgEq1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgEq1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgEqOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgEqOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgEq_(ptr *Ctensor, self Ctensor, other Cscalar)
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 AtgEye1(ptr *Ctensor, n int64, m int64, optionsKind int32, optionsDevice int32)
func AtgEyeOut(ptr *Ctensor, out Ctensor, n int64)
func AtgEyeOut1(ptr *Ctensor, out Ctensor, n int64, m int64)
func AtgFakeQuantizePerChannelAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, ...)
func AtgFakeQuantizePerChannelAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, ...)
func AtgFakeQuantizePerTensorAffine(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64, quantMin int64, ...)
func AtgFakeQuantizePerTensorAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale float64, zeroPoint 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 AtgFbgemmPackQuantizedMatrix1(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 AtgFft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32)
func AtgFftFft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
func AtgFftFftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
func AtgFftHfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
func AtgFftIfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
func AtgFftIfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
func AtgFftIhfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
func AtgFftIrfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
func AtgFftIrfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
func AtgFftRfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string)
func AtgFftRfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, ...)
func AtgFill1_(ptr *Ctensor, self Ctensor, value Ctensor)
func AtgFillDiagonal_(ptr *Ctensor, self Ctensor, fillValue Cscalar, wrap int32)
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 AtgFlip(ptr *Ctensor, self Ctensor, dimsData []int64, dimsLen int)
func AtgFliplr(ptr *Ctensor, self Ctensor)
func AtgFlipud(ptr *Ctensor, self Ctensor)
func AtgFloor(ptr *Ctensor, self Ctensor)
func AtgFloorDivide(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgFloorDivide1(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgFloorDivide1_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgFloorDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgFloorDivide_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgFloorOut(ptr *Ctensor, out Ctensor, self Ctensor)
func AtgFloor_(ptr *Ctensor, self Ctensor)
func AtgFmod(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgFmod1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgFmod1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgFmodOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgFmodOut1(ptr *Ctensor, out 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 AtgFractionalMaxPool2dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
func AtgFractionalMaxPool2dOut(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 AtgFractionalMaxPool3dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
func AtgFractionalMaxPool3dOut(ptr *Ctensor, output Ctensor, indices Ctensor, self Ctensor, ...)
func AtgFrobeniusNorm(ptr *Ctensor, self Ctensor)
func AtgFrobeniusNorm1(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 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 AtgGe1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgGe1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgGeOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgGeOut1(ptr *Ctensor, out 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 AtgGeometric_(ptr *Ctensor, self Ctensor, p float64)
func AtgGeqrf(ptr *Ctensor, self Ctensor)
func AtgGeqrfOut(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 AtgGluBackwardOut(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 AtgGreater1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgGreater1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgGreaterEqual(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgGreaterEqual1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgGreaterEqual1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgGreaterEqualOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgGreaterEqualOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgGreaterEqual_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgGreaterOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgGreaterOut1(ptr *Ctensor, out 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 AtgGru1(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, ...)
func AtgGruCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, ...)
func AtgGt(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgGt1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgGt1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgGtOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgGtOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgGt_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgHammingWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)
func AtgHammingWindow1(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, ...)
func AtgHammingWindow2(ptr *Ctensor, windowLength int64, periodic int32, alpha float64, ...)
func AtgHammingWindow3(ptr *Ctensor, windowLength int64, periodic int32, alpha float64, beta float64, ...)
func AtgHannWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32)
func AtgHannWindow1(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 AtgHardsigmoid(ptr *Ctensor, self Ctensor)
func AtgHardsigmoidBackward(ptr *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 AtgHardtanhBackwardOut(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 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 AtgIfft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32)
func AtgIm2col(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
func AtgIm2colBackward(ptr *Ctensor, gradOutput Ctensor, inputSizeData []int64, inputSizeLen int, ...)
func AtgIm2colBackwardOut(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 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 AtgIndexFill1(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Ctensor)
func AtgIndexFill1_(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 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 AtgIrfft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32, onesided int32, ...)
func AtgIsclose(ptr *Ctensor, self Ctensor, other Ctensor, rtol float64, atol float64, ...)
func AtgIsfinite(ptr *Ctensor, self 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 AtgKaiserWindow1(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, ...)
func AtgKaiserWindow2(ptr *Ctensor, windowLength int64, periodic int32, beta float64, ...)
func AtgKlDiv(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64, logTarget int32)
func AtgKlDivBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, ...)
func AtgKthvalue(ptr *Ctensor, self Ctensor, k int64, dim int64, keepdim int32)
func AtgKthvalueOut(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 AtgL1LossBackwardOut(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 AtgLe(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgLe1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgLe1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgLeOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgLeOut1(ptr *Ctensor, out 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 AtgLeakyReluOut(ptr *Ctensor, out Ctensor, self Ctensor)
func AtgLeakyRelu_(ptr *Ctensor, self Ctensor)
func AtgLerp(ptr *Ctensor, self Ctensor, end Ctensor, weight Cscalar)
func AtgLerp1(ptr *Ctensor, self Ctensor, end Ctensor, weight Ctensor)
func AtgLerp1_(ptr *Ctensor, self Ctensor, end Ctensor, weight Ctensor)
func AtgLerpOut(ptr *Ctensor, out Ctensor, self Ctensor, end Ctensor, weight Cscalar)
func AtgLerpOut1(ptr *Ctensor, out 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 AtgLess1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgLess1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgLessEqual(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgLessEqual1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgLessEqual1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgLessEqualOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgLessEqualOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgLessEqual_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgLessOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgLessOut1(ptr *Ctensor, out 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 AtgLinalgDet(ptr *Ctensor, self Ctensor)
func AtgLinalgNorm(ptr *Ctensor, self Ctensor, ord Cscalar, dimData []int64, dimLen int, ...)
func AtgLinalgNorm1(ptr *Ctensor, self Ctensor, ord string, dimData []int64, dimLen int, ...)
func AtgLinalgNormOut(ptr *Ctensor, out Ctensor, self Ctensor, ord Cscalar, dimData []int64, ...)
func AtgLinalgNormOut1(ptr *Ctensor, out Ctensor, self Ctensor, ord string, dimData []int64, ...)
func AtgLinear(ptr *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 AtgLogSigmoidBackwardOut(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 AtgLogitBackwardOut(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 AtgLstm1(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hxData []Ctensor, hxLen int, ...)
func AtgLstmCell(ptr *Ctensor, input Ctensor, hxData []Ctensor, hxLen int, wIh Ctensor, ...)
func AtgLstsq(ptr *Ctensor, self Ctensor, a Ctensor)
func AtgLstsqOut(ptr *Ctensor, x Ctensor, qr Ctensor, self Ctensor, a Ctensor)
func AtgLt(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgLt1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgLt1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgLtOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgLtOut1(ptr *Ctensor, out 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 AtgMarginRankingLoss(ptr *Ctensor, input1 Ctensor, input2 Ctensor, target Ctensor, margin float64, ...)
func AtgMaskedFill(ptr *Ctensor, self Ctensor, mask Ctensor, value Cscalar)
func AtgMaskedFill1(ptr *Ctensor, self Ctensor, mask Ctensor, value Ctensor)
func AtgMaskedFill1_(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 AtgMatrixRank(ptr *Ctensor, self Ctensor, symmetric int32)
func AtgMatrixRank1(ptr *Ctensor, self Ctensor, tol float64, symmetric int32)
func AtgMax(ptr *Ctensor, self Ctensor)
func AtgMax1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgMax2(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
func AtgMaxOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgMaxOut1(ptr *Ctensor, max Ctensor, maxValues Ctensor, self Ctensor, dim int64, ...)
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 AtgMaxPool2dWithIndicesBackwardOut(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 AtgMaxPool3dWithIndicesBackwardOut(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 AtgMaxUnpool2dBackwardOut(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 AtgMaxUnpool3dBackwardOut(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 AtgMean1(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 AtgMedian1(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
func AtgMedianOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, ...)
func AtgMin(ptr *Ctensor, self Ctensor)
func AtgMin1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgMin2(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
func AtgMinOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgMinOut1(ptr *Ctensor, min Ctensor, minIndices Ctensor, self Ctensor, dim int64, ...)
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 AtgMkldnnAdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int)
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, input Ctensor, weight Ctensor, bias Ctensor)
func AtgMkldnnMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
func AtgMkldnnMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, ...)
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 AtgModeOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, ...)
func AtgMovedim(ptr *Ctensor, self Ctensor, sourceData []int64, sourceLen int, ...)
func AtgMovedim1(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 AtgMseLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
func AtgMseLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64)
func AtgMul(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgMul1(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgMul1_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgMulOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgMul_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgMultiMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, p Cscalar, ...)
func AtgMultiMarginLossBackwardOut(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 AtgMultilabelMarginLossBackwardOut(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 AtgMultiply1(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgMultiply1_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgMultiplyOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
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 AtgMvlgamma_(ptr *Ctensor, self Ctensor, p int64)
func AtgNanquantile(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
func AtgNanquantile1(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
func AtgNanquantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
func AtgNanquantileOut1(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
func AtgNansum(ptr *Ctensor, self Ctensor, dtype int32)
func AtgNansum1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, ...)
func AtgNansumOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
func AtgNarrow(ptr *Ctensor, self Ctensor, dim int64, start int64, length int64)
func AtgNarrow1(ptr *Ctensor, self Ctensor, dim int64, start Ctensor, length int64)
func AtgNarrowCopy(ptr *Ctensor, self Ctensor, dim int64, start int64, 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, weight Ctensor, bias Ctensor, m int64, n int64, ...)
func AtgNativeNorm(ptr *Ctensor, self Ctensor)
func AtgNativeNorm1(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, ...)
func AtgNe(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgNe1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgNe1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgNeOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgNeOut1(ptr *Ctensor, out 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 AtgNewFull(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar, ...)
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 AtgNllLoss2dBackwardOut(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 AtgNllLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
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 AtgNorm1(ptr *Ctensor, self Ctensor, p Cscalar, dtype int32)
func AtgNorm2(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, ...)
func AtgNorm3(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, ...)
func AtgNormExceptDim(ptr *Ctensor, v Ctensor, pow int64, dim int64)
func AtgNormOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dimData []int64, ...)
func AtgNormOut1(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dimData []int64, ...)
func AtgNormalOut(ptr *Ctensor, out Ctensor, mean Ctensor, std float64)
func AtgNormalOut1(ptr *Ctensor, out Ctensor, mean float64, std Ctensor)
func AtgNormalOut2(ptr *Ctensor, out Ctensor, mean Ctensor, std Ctensor)
func AtgNormalOut3(ptr *Ctensor, out Ctensor, mean float64, std float64, sizeData []int64, ...)
func AtgNormal_(ptr *Ctensor, self Ctensor, mean float64, std float64)
func AtgNotEqual(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgNotEqual1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgNotEqual1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgNotEqualOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgNotEqualOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgNotEqual_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgNuclearNorm(ptr *Ctensor, self Ctensor, keepdim int32)
func AtgNuclearNorm1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32)
func AtgNuclearNormOut(ptr *Ctensor, out Ctensor, self Ctensor, keepdim int32)
func AtgNuclearNormOut1(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, ...)
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 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)
func AtgPinverse(ptr *Ctensor, self Ctensor, rcond float64)
func AtgPixelShuffle(ptr *Ctensor, self Ctensor, upscaleFactor 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 AtgPow(ptr *Ctensor, self Ctensor, exponent Cscalar)
func AtgPow1(ptr *Ctensor, self Ctensor, exponent Ctensor)
func AtgPow1_(ptr *Ctensor, self Ctensor, exponent Ctensor)
func AtgPow2(ptr *Ctensor, selfScalar Cscalar, exponent Ctensor)
func AtgPowOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Cscalar)
func AtgPowOut1(ptr *Ctensor, out Ctensor, self Ctensor, exponent Ctensor)
func AtgPowOut2(ptr *Ctensor, out Ctensor, selfScalar Cscalar, 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 AtgProd1(ptr *Ctensor, self Ctensor, dim int64, keepdim int32, dtype int32)
func AtgProdOut(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 AtgQPerChannelScales(ptr *Ctensor, self Ctensor)
func AtgQPerChannelZeroPoints(ptr *Ctensor, self Ctensor)
func AtgQr(ptr *Ctensor, self Ctensor, some int32)
func AtgQrOut(ptr *Ctensor, q Ctensor, r Ctensor, self Ctensor, some int32)
func AtgQuantile(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
func AtgQuantile1(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, ...)
func AtgQuantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, ...)
func AtgQuantileOut1(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, 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 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 AtgRandint1(ptr *Ctensor, low int64, high int64, sizeData []int64, sizeLen int, ...)
func AtgRandintLike(ptr *Ctensor, self Ctensor, high int64)
func AtgRandintLike1(ptr *Ctensor, self Ctensor, low int64, high int64)
func AtgRandintOut(ptr *Ctensor, out Ctensor, high int64, sizeData []int64, sizeLen int)
func AtgRandintOut1(ptr *Ctensor, out Ctensor, low int64, high int64, sizeData []int64, ...)
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 AtgRandom1_(ptr *Ctensor, self Ctensor, to int64)
func AtgRandom2(ptr *Ctensor, self Ctensor, from int64, toVal int64, toNull int)
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 AtgRange1(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, ...)
func AtgRangeOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar)
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 AtgReflectionPad1dBackwardOut(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 AtgReflectionPad2dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, ...)
func AtgReflectionPad2dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int)
func AtgRelu(ptr *Ctensor, self Ctensor)
func AtgRelu_(ptr *Ctensor, self Ctensor)
func AtgRemainder(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgRemainder1(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgRemainder1_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgRemainderOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar)
func AtgRemainderOut1(ptr *Ctensor, out 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)
func AtgRepeatInterleave1(ptr *Ctensor, self Ctensor, repeats Ctensor, dimVal int64, dimNull int)
func AtgRepeatInterleave2(ptr *Ctensor, self Ctensor, repeats int64, 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 AtgReplicationPad1dBackwardOut(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 AtgReplicationPad2dBackwardOut(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 AtgReplicationPad3dBackwardOut(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 AtgResizeAs_(ptr *Ctensor, self Ctensor, theTemplate Ctensor)
func AtgResize_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)
func AtgRfft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32, onesided int32)
func AtgRnnRelu(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, ...)
func AtgRnnRelu1(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, ...)
func AtgRnnReluCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, ...)
func AtgRnnTanh(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, ...)
func AtgRnnTanh1(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, ...)
func AtgRnnTanhCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh 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 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 AtgRsub1(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 AtgScatter1(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)
func AtgScatter1_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar)
func AtgScatter2(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, ...)
func AtgScatter3(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar, ...)
func AtgScatterAdd(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)
func AtgScatterAdd_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)
func AtgScatter_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor)
func AtgSearchsorted(ptr *Ctensor, sortedSequence Ctensor, self Ctensor, outInt32 int32, ...)
func AtgSearchsorted1(ptr *Ctensor, sortedSequence Ctensor, selfScalar Cscalar, outInt32 int32, ...)
func AtgSearchsortedOut(ptr *Ctensor, out Ctensor, sortedSequence Ctensor, self Ctensor, ...)
func AtgSelect(ptr *Ctensor, self Ctensor, dim int64, index int64)
func AtgSelectBackward(ptr *Ctensor, grad Ctensor, inputSizesData []int64, inputSizesLen int, ...)
func AtgSelu(ptr *Ctensor, self Ctensor)
func AtgSelu_(ptr *Ctensor, self Ctensor)
func AtgSet1_(ptr *Ctensor, self Ctensor, source Ctensor)
func AtgSetRequiresGrad(ptr *Ctensor, self Ctensor, r int32)
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 AtgSigmoidBackwardOut(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 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 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, start int64, end int64, step int64)
func AtgSliceBackward(ptr *Ctensor, grad 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 AtgSmoothL1LossBackwardOut(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 AtgSoftMarginLossBackwardOut(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 AtgSoftplusBackwardOut(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 AtgSoftshrinkBackwardOut(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 AtgSolveOut(ptr *Ctensor, solution Ctensor, lu Ctensor, self Ctensor, a Ctensor)
func AtgSort(ptr *Ctensor, self Ctensor, dim int64, descending int32)
func AtgSortOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, ...)
func AtgSparseCooTensor(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, ...)
func AtgSparseCooTensor1(ptr *Ctensor, indices Ctensor, values Ctensor, optionsKind int32, ...)
func AtgSparseCooTensor2(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, ...)
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 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 AtgSquare_(ptr *Ctensor, self Ctensor)
func AtgSqueeze(ptr *Ctensor, self Ctensor)
func AtgSqueeze1(ptr *Ctensor, self Ctensor, dim int64)
func AtgSqueeze1_(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 AtgStd1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, ...)
func AtgStdMean(ptr *Ctensor, self Ctensor, unbiased int32)
func AtgStdMean1(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 AtgSub1(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgSub1_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgSubOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgSub_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgSubtract(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgSubtract1(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgSubtract1_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgSubtractOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
func AtgSubtract_(ptr *Ctensor, self Ctensor, other Ctensor)
func AtgSum(ptr *Ctensor, self Ctensor, dtype int32)
func AtgSum1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, ...)
func AtgSumOut(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 AtgSvdOut(ptr *Ctensor, u Ctensor, s Ctensor, v Ctensor, self Ctensor, some int32, ...)
func AtgSymeig(ptr *Ctensor, self Ctensor, eigenvectors int32, upper int32)
func AtgSymeigOut(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 AtgTakeBackward(ptr *Ctensor, grad Ctensor, input Ctensor, index Ctensor)
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 AtgTanhBackwardOut(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 AtgThreshold(ptr *Ctensor, self Ctensor, threshold Cscalar, value Cscalar)
func AtgThresholdBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, threshold Cscalar)
func AtgThresholdOut(ptr *Ctensor, out Ctensor, self Ctensor, threshold Cscalar, value Cscalar)
func AtgThreshold_(ptr *Ctensor, self Ctensor, threshold Cscalar, value Cscalar)
func AtgTo(ptr *Ctensor, self Ctensor, device int32)
func AtgTo1(ptr *Ctensor, self Ctensor, optionsKind int32, optionsDevice int32, ...)
func AtgTo2(ptr *Ctensor, self Ctensor, dtype int32, nonBlocking int32, copy int32)
func AtgTo3(ptr *Ctensor, self Ctensor, other Ctensor, nonBlocking int32, copy int32)
func AtgTo4(ptr *Ctensor, self Ctensor, device int32, dtype int32, nonBlocking int32, ...)
func AtgToDense(ptr *Ctensor, self Ctensor)
func AtgToDenseBackward(ptr *Ctensor, grad Ctensor, input Ctensor)
func AtgToMkldnn(ptr *Ctensor, self Ctensor)
func AtgToMkldnnBackward(ptr *Ctensor, grad Ctensor, input Ctensor)
func AtgToSparse(ptr *Ctensor, self Ctensor)
func AtgToSparse1(ptr *Ctensor, self Ctensor, sparseDim int64)
func AtgTopk(ptr *Ctensor, self Ctensor, k int64, dim int64, largest int32, sorted int32)
func AtgTopkOut(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 AtgTrapz(ptr *Ctensor, y Ctensor, x Ctensor, dim int64)
func AtgTrapz1(ptr *Ctensor, y Ctensor, dx float64, dim int64)
func AtgTriangularSolve(ptr *Ctensor, self Ctensor, a Ctensor, upper int32, transpose int32, ...)
func AtgTriangularSolveOut(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 AtgTrueDivide1(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgTrueDivide1_(ptr *Ctensor, self Ctensor, other Cscalar)
func AtgTrueDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor)
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 AtgUpsampleBicubic2dBackwardOut(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 AtgUpsampleBilinear2dBackwardOut(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 AtgUpsampleLinear1dBackwardOut(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 AtgUpsampleNearest1dBackwardOut(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 AtgUpsampleNearest2dBackwardOut(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 AtgUpsampleNearest3dBackwardOut(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 AtgUpsampleTrilinear3dBackwardOut(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 AtgVar1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, ...)
func AtgVarMean(ptr *Ctensor, self Ctensor, unbiased int32)
func AtgVarMean1(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 AtgVstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int)
func AtgVstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int)
func AtgWhere1(ptr *Ctensor, condition Ctensor, self Ctensor, other Ctensor)
func AtgWhere2(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Ctensor)
func AtgWhere3(ptr *Ctensor, condition Ctensor, self Ctensor, other Cscalar)
func AtgWhere4(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Cscalar)
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_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_AddRelu_(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg_AddmvImpl_(ptr *Ctensor, self Ctensor, self2 Ctensor, mat Ctensor, vec Ctensor)
func Atg_Aminmax(ptr *Ctensor, self Ctensor)
func Atg_Aminmax1(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
func Atg_AmpUpdateScale(ptr *Ctensor, growthTracker Ctensor, currentScale Ctensor, foundInf Ctensor, ...)
func Atg_BaddbmmMkl_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor)
func Atg_Bmm(ptr *Ctensor, self Ctensor, mat2 Ctensor, deterministic int32)
func Atg_BmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor, deterministic int32)
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_CholeskyHelper(ptr *Ctensor, self Ctensor, upper int32)
func Atg_CholeskySolveHelper(ptr *Ctensor, self Ctensor, a Ctensor, upper int32)
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_Convolution(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, ...)
func Atg_Convolution1(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_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_Cumprod(ptr *Ctensor, self Ctensor, dim int64)
func Atg_CumprodOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64)
func Atg_Cumsum(ptr *Ctensor, self Ctensor, dim int64)
func Atg_CumsumOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64)
func Atg_DimArange(ptr *Ctensor, like Ctensor, dim 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, offsets 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_FftWithSize(ptr *Ctensor, self Ctensor, signalNdim int64, complexInput int32, ...)
func Atg_FftWithSize1(ptr *Ctensor, self Ctensor, signalNdim int64, complexInput int32, ...)
func Atg_FusedDropout(ptr *Ctensor, self Ctensor, p float64)
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_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_LogSoftmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)
func Atg_LogSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)
func Atg_Logcumsumexp(ptr *Ctensor, self Ctensor, dim int64)
func Atg_LogcumsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64)
func Atg_LuSolveHelper(ptr *Ctensor, self Ctensor, lUData Ctensor, lUPivots Ctensor)
func Atg_LuWithInfo(ptr *Ctensor, self Ctensor, pivot int32, checkErrors int32)
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_Mode(ptr *Ctensor, self Ctensor, dim int64, keepdim int32)
func Atg_ModeOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, ...)
func Atg_MultinomialAliasDraw(ptr *Ctensor, j Ctensor, q Ctensor, numSamples int64)
func Atg_MultinomialAliasSetup(ptr *Ctensor, probs Ctensor)
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_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_QrHelper(ptr *Ctensor, self Ctensor, some int32)
func Atg_RemoveBatchDim(ptr *Ctensor, self Ctensor, level int64, batchSize int64, outDim int64)
func Atg_ReshapeFromTensor(ptr *Ctensor, self Ctensor, shape Ctensor)
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_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_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_SparseLogSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
func Atg_SparseLogSoftmax1(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)
func Atg_SparseLogSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)
func Atg_SparseMm(ptr *Ctensor, sparse Ctensor, dense Ctensor)
func Atg_SparseSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32)
func Atg_SparseSoftmax1(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32)
func Atg_SparseSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor)
func Atg_SparseSum(ptr *Ctensor, self Ctensor)
func Atg_SparseSum1(ptr *Ctensor, self Ctensor, dtype int32)
func Atg_SparseSum2(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int)
func Atg_SparseSum3(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, dtype int32)
func Atg_SparseSumBackward(ptr *Ctensor, grad Ctensor, self Ctensor, dimData []int64, dimLen int)
func Atg_StandardGamma(ptr *Ctensor, self Ctensor)
func Atg_StandardGammaGrad(ptr *Ctensor, self Ctensor, output Ctensor)
func Atg_Std(ptr *Ctensor, self Ctensor, unbiased int32)
func Atg_SvdHelper(ptr *Ctensor, self Ctensor, some int32, computeUv int32)
func Atg_SymeigHelper(ptr *Ctensor, self Ctensor, eigenvectors int32, upper int32)
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_TriangularSolveHelper(ptr *Ctensor, self Ctensor, a Ctensor, upper int32, transpose 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_UnsafeView(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int)
func Atg_Values(ptr *Ctensor, self Ctensor)
func Atg_Var(ptr *Ctensor, self Ctensor, unbiased int32)
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__And1(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg__And_(ptr *Ctensor, self Ctensor, other Cscalar)
func Atg__Iand1(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg__Iand_(ptr *Ctensor, self Ctensor, other Cscalar)
func Atg__Ilshift1(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg__Ilshift_(ptr *Ctensor, self Ctensor, other Cscalar)
func Atg__Ior1(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg__Ior_(ptr *Ctensor, self Ctensor, other Cscalar)
func Atg__Irshift1(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg__Irshift_(ptr *Ctensor, self Ctensor, other Cscalar)
func Atg__Ixor1(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg__Ixor_(ptr *Ctensor, self Ctensor, other Cscalar)
func Atg__Lshift1(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg__Lshift_(ptr *Ctensor, self Ctensor, other Cscalar)
func Atg__Or1(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg__Or_(ptr *Ctensor, self Ctensor, other Cscalar)
func Atg__Rshift1(ptr *Ctensor, self Ctensor, other Ctensor)
func Atg__Rshift_(ptr *Ctensor, self Ctensor, other Cscalar)
func Atg__Xor1(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

Constants ¶

This section is empty.

Variables ¶

View Source

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, gradOutput Ctensor, self Ctensor)

func AtgAdaptiveAvgPool3dBackwardOut ¶

func AtgAdaptiveAvgPool3dBackwardOut(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 AtgAdaptiveMaxPool2dBackwardOut ¶

func AtgAdaptiveMaxPool2dBackwardOut(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 AtgAdaptiveMaxPool3dBackwardOut ¶

func AtgAdaptiveMaxPool3dBackwardOut(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 AtgAdd1 ¶

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

func AtgAdd1_ ¶

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

func AtgAddOut ¶

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

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 AtgAll1 ¶

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

func AtgAllOut ¶

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

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 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 AtgAny1 ¶

func AtgAny1(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 AtgArange1 ¶

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

func AtgArange2 ¶

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

func AtgArangeOut ¶

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

func AtgArangeOut1 ¶

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

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 AtgArgmin ¶

func AtgArgmin(ptr *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 AtgAvgPool2dBackwardOut ¶

func AtgAvgPool2dBackwardOut(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 AtgAvgPool3dBackwardOut ¶

func AtgAvgPool3dBackwardOut(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 AtgBartlettWindow1 ¶

func AtgBartlettWindow1(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)

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 AtgBernoulli1 ¶

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

func AtgBernoulli1_ ¶

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

func AtgBernoulliOut ¶

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

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 AtgBinaryCrossEntropyBackwardOut ¶

func AtgBinaryCrossEntropyBackwardOut(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 AtgBitwiseAnd1 ¶

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

func AtgBitwiseAnd1_ ¶

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

func AtgBitwiseAndOut ¶

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

func AtgBitwiseAndOut1 ¶

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

func AtgBitwiseAnd_ ¶

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

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 AtgBitwiseOr1 ¶

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

func AtgBitwiseOr1_ ¶

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

func AtgBitwiseOrOut ¶

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

func AtgBitwiseOrOut1 ¶

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

func AtgBitwiseOr_ ¶

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

func AtgBitwiseXor ¶

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

func AtgBitwiseXor1 ¶

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

func AtgBitwiseXor1_ ¶

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

func AtgBitwiseXorOut ¶

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

func AtgBitwiseXorOut1 ¶

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

func AtgBitwiseXor_ ¶

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

func AtgBlackmanWindow ¶

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

func AtgBlackmanWindow1 ¶

func AtgBlackmanWindow1(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 AtgBucketize ¶

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

func AtgBucketize1 ¶

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

func AtgBucketizeOut ¶

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

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 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 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 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 AtgClampMin_ ¶

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

func AtgClampOut ¶

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

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 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 AtgCol2imBackwardOut ¶

func AtgCol2imBackwardOut(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 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 AtgConj ¶

func AtgConj(ptr *Ctensor, self Ctensor)

func AtgConjOut ¶

func AtgConjOut(ptr *Ctensor, out 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 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 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 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 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, dimData []int64, dimLen int)

func AtgCountNonzero1 ¶

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

func AtgCross ¶

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

func AtgCrossOut ¶

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

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 AtgCtcLoss1 ¶

func AtgCtcLoss1(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)

func AtgCudnnConvolution1 ¶

func AtgCudnnConvolution1(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 AtgCudnnConvolution2 ¶

func AtgCudnnConvolution2(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 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 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)

func AtgCudnnConvolutionTranspose1 ¶

func AtgCudnnConvolutionTranspose1(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 AtgCudnnConvolutionTranspose2 ¶

func AtgCudnnConvolutionTranspose2(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 AtgCudnnGridSampler ¶

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

func AtgCudnnGridSamplerBackward ¶

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

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)

func AtgCumprodOut ¶

func AtgCumprodOut(ptr *Ctensor, out 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 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 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, grad Ctensor, inputSizesData []int64, inputSizesLen int, offset int64, dim1 int64, dim2 int64)

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 AtgDiv1 ¶

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

func AtgDiv1_ ¶

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

func AtgDivOut ¶

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

func AtgDiv_ ¶

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

func AtgDivide ¶

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

func AtgDivide1 ¶

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

func AtgDivide1_ ¶

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

func AtgDivideOut ¶

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

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 AtgEigOut ¶

func AtgEigOut(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, output Ctensor)

func AtgEluBackwardOut ¶

func AtgEluBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, alpha Cscalar, scale Cscalar, inputScale Cscalar, output 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 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 AtgEmptyMeta ¶

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

func AtgEmptyOut ¶

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

func AtgEmptyQuantized ¶

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

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 AtgEq1 ¶

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

func AtgEq1_ ¶

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

func AtgEqOut ¶

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

func AtgEqOut1 ¶

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

func AtgEq_ ¶

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

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 AtgEye1 ¶

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

func AtgEyeOut ¶

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

func AtgEyeOut1 ¶

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

func AtgFakeQuantizePerChannelAffine ¶

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

func AtgFakeQuantizePerChannelAffineBackward ¶

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

func AtgFakeQuantizePerTensorAffine ¶

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

func AtgFakeQuantizePerTensorAffineBackward ¶

func AtgFakeQuantizePerTensorAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale float64, zeroPoint int64, 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 AtgFbgemmPackQuantizedMatrix1 ¶

func AtgFbgemmPackQuantizedMatrix1(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 AtgFft ¶

func AtgFft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32)

func AtgFftFft ¶

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

func AtgFftFftn ¶

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

func AtgFftHfft ¶

func AtgFftHfft(ptr *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 AtgFftIfftn ¶

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

func AtgFftIhfft ¶

func AtgFftIhfft(ptr *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 AtgFftIrfftn ¶

func AtgFftIrfftn(ptr *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 AtgFftRfftn ¶

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

func AtgFill1_ ¶

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

func AtgFillDiagonal_ ¶

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

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 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 AtgFloor ¶

func AtgFloor(ptr *Ctensor, self Ctensor)

func AtgFloorDivide ¶

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

func AtgFloorDivide1 ¶

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

func AtgFloorDivide1_ ¶

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

func AtgFloorDivideOut ¶

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

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 AtgFmod ¶

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

func AtgFmod1 ¶

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

func AtgFmod1_ ¶

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

func AtgFmodOut ¶

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

func AtgFmodOut1 ¶

func AtgFmodOut1(ptr *Ctensor, out 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 AtgFractionalMaxPool2dBackwardOut ¶

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

func AtgFractionalMaxPool2dOut ¶

func AtgFractionalMaxPool2dOut(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 AtgFractionalMaxPool3dBackwardOut ¶

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

func AtgFractionalMaxPool3dOut ¶

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

func AtgFrobeniusNorm ¶

func AtgFrobeniusNorm(ptr *Ctensor, self Ctensor)

func AtgFrobeniusNorm1 ¶

func AtgFrobeniusNorm1(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 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 AtgGe1 ¶

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

func AtgGe1_ ¶

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

func AtgGeOut ¶

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

func AtgGeOut1 ¶

func AtgGeOut1(ptr *Ctensor, out 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 AtgGeometric_ ¶

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

func AtgGeqrf ¶

func AtgGeqrf(ptr *Ctensor, self Ctensor)

func AtgGeqrfOut ¶

func AtgGeqrfOut(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 AtgGluBackwardOut ¶

func AtgGluBackwardOut(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 AtgGreater1 ¶

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

func AtgGreater1_ ¶

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

func AtgGreaterEqual ¶

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

func AtgGreaterEqual1 ¶

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

func AtgGreaterEqual1_ ¶

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

func AtgGreaterEqualOut ¶

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

func AtgGreaterEqualOut1 ¶

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

func AtgGreaterEqual_ ¶

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

func AtgGreaterOut ¶

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

func AtgGreaterOut1 ¶

func AtgGreaterOut1(ptr *Ctensor, out 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 AtgGru1 ¶

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

func AtgGruCell ¶

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

func AtgGt ¶

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

func AtgGt1 ¶

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

func AtgGt1_ ¶

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

func AtgGtOut ¶

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

func AtgGtOut1 ¶

func AtgGtOut1(ptr *Ctensor, out 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 AtgHammingWindow1 ¶

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

func AtgHammingWindow2 ¶

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

func AtgHammingWindow3 ¶

func AtgHammingWindow3(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 AtgHannWindow1 ¶

func AtgHannWindow1(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 AtgHardsigmoid ¶

func AtgHardsigmoid(ptr *Ctensor, self Ctensor)

func AtgHardsigmoidBackward ¶

func AtgHardsigmoidBackward(ptr *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 AtgHardtanhBackwardOut ¶

func AtgHardtanhBackwardOut(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 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 AtgIfft ¶

func AtgIfft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32)

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 AtgIm2colBackwardOut ¶

func AtgIm2colBackwardOut(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 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 AtgIndexFill1 ¶

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

func AtgIndexFill1_ ¶

func AtgIndexFill1_(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 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 AtgIrfft ¶

func AtgIrfft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32, onesided int32, signalSizesData []int64, signalSizesLen int)

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 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 AtgKaiserWindow1 ¶

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

func AtgKaiserWindow2 ¶

func AtgKaiserWindow2(ptr *Ctensor, windowLength int64, periodic int32, beta float64, 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 AtgKthvalue ¶

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

func AtgKthvalueOut ¶

func AtgKthvalueOut(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 AtgL1LossBackwardOut ¶

func AtgL1LossBackwardOut(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 AtgLe ¶

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

func AtgLe1 ¶

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

func AtgLe1_ ¶

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

func AtgLeOut ¶

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

func AtgLeOut1 ¶

func AtgLeOut1(ptr *Ctensor, out 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 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 AtgLerp1 ¶

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

func AtgLerp1_ ¶

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

func AtgLerpOut ¶

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

func AtgLerpOut1 ¶

func AtgLerpOut1(ptr *Ctensor, out 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 AtgLess1 ¶

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

func AtgLess1_ ¶

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

func AtgLessEqual ¶

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

func AtgLessEqual1 ¶

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

func AtgLessEqual1_ ¶

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

func AtgLessEqualOut ¶

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

func AtgLessEqualOut1 ¶

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

func AtgLessEqual_ ¶

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

func AtgLessOut ¶

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

func AtgLessOut1 ¶

func AtgLessOut1(ptr *Ctensor, out 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 AtgLinalgDet ¶

func AtgLinalgDet(ptr *Ctensor, self Ctensor)

func AtgLinalgNorm ¶

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

func AtgLinalgNorm1 ¶

func AtgLinalgNorm1(ptr *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 AtgLinalgNormOut1 ¶

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

func AtgLinear ¶

func AtgLinear(ptr *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 AtgLogSigmoidBackwardOut ¶

func AtgLogSigmoidBackwardOut(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 AtgLogitBackwardOut ¶

func AtgLogitBackwardOut(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 AtgLstm1 ¶

func AtgLstm1(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 AtgLstmCell ¶

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

func AtgLstsq ¶

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

func AtgLstsqOut ¶

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

func AtgLt ¶

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

func AtgLt1 ¶

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

func AtgLt1_ ¶

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

func AtgLtOut ¶

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

func AtgLtOut1 ¶

func AtgLtOut1(ptr *Ctensor, out 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 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 AtgMaskedFill1 ¶

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

func AtgMaskedFill1_ ¶

func AtgMaskedFill1_(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 AtgMatrixRank ¶

func AtgMatrixRank(ptr *Ctensor, self Ctensor, symmetric int32)

func AtgMatrixRank1 ¶

func AtgMatrixRank1(ptr *Ctensor, self Ctensor, tol float64, symmetric int32)

func AtgMax ¶

func AtgMax(ptr *Ctensor, self Ctensor)

func AtgMax1 ¶

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

func AtgMax2 ¶

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

func AtgMaxOut ¶

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

func AtgMaxOut1 ¶

func AtgMaxOut1(ptr *Ctensor, max Ctensor, maxValues Ctensor, self Ctensor, dim int64, keepdim int32)

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 AtgMaxPool2dWithIndicesBackwardOut ¶

func AtgMaxPool2dWithIndicesBackwardOut(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 AtgMaxPool3dWithIndicesBackwardOut ¶

func AtgMaxPool3dWithIndicesBackwardOut(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 AtgMaxUnpool2dBackwardOut ¶

func AtgMaxUnpool2dBackwardOut(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 AtgMaxUnpool3dBackwardOut ¶

func AtgMaxUnpool3dBackwardOut(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 AtgMean1 ¶

func AtgMean1(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 AtgMedian1 ¶

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

func AtgMedianOut ¶

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

func AtgMin ¶

func AtgMin(ptr *Ctensor, self Ctensor)

func AtgMin1 ¶

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

func AtgMin2 ¶

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

func AtgMinOut ¶

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

func AtgMinOut1 ¶

func AtgMinOut1(ptr *Ctensor, min Ctensor, minIndices Ctensor, self Ctensor, dim int64, keepdim int32)

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 AtgMkldnnAdaptiveAvgPool2d ¶

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

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, input Ctensor, weight Ctensor, bias Ctensor)

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 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 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 AtgModeOut ¶

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

func AtgMovedim ¶

func AtgMovedim(ptr *Ctensor, self Ctensor, sourceData []int64, sourceLen int, destinationData []int64, destinationLen int)

func AtgMovedim1 ¶

func AtgMovedim1(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 AtgMseLossBackwardOut ¶

func AtgMseLossBackwardOut(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 AtgMul ¶

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

func AtgMul1 ¶

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

func AtgMul1_ ¶

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

func AtgMulOut ¶

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

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 AtgMultiMarginLossBackwardOut ¶

func AtgMultiMarginLossBackwardOut(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 AtgMultilabelMarginLossBackwardOut ¶

func AtgMultilabelMarginLossBackwardOut(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 AtgMultiply1 ¶

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

func AtgMultiply1_ ¶

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

func AtgMultiplyOut ¶

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

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 AtgMvlgamma_ ¶

func AtgMvlgamma_(ptr *Ctensor, self Ctensor, p int64)

func AtgNanquantile ¶

func AtgNanquantile(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32)

func AtgNanquantile1 ¶

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

func AtgNanquantileOut ¶

func AtgNanquantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32)

func AtgNanquantileOut1 ¶

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

func AtgNansum ¶

func AtgNansum(ptr *Ctensor, self Ctensor, dtype int32)

func AtgNansum1 ¶

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

func AtgNansumOut ¶

func AtgNansumOut(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 AtgNarrow1 ¶

func AtgNarrow1(ptr *Ctensor, self Ctensor, dim int64, start Ctensor, length int64)

func AtgNarrowCopy ¶

func AtgNarrowCopy(ptr *Ctensor, self Ctensor, dim int64, start int64, 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, weight Ctensor, bias Ctensor, m int64, n int64, eps float64)

func AtgNativeNorm ¶

func AtgNativeNorm(ptr *Ctensor, self Ctensor)

func AtgNativeNorm1 ¶

func AtgNativeNorm1(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 AtgNe1 ¶

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

func AtgNe1_ ¶

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

func AtgNeOut ¶

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

func AtgNeOut1 ¶

func AtgNeOut1(ptr *Ctensor, out 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 AtgNewFull ¶

func AtgNewFull(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar, 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 AtgNllLoss2dBackwardOut ¶

func AtgNllLoss2dBackwardOut(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 AtgNllLossBackwardOut ¶

func AtgNllLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, totalWeight Ctensor)

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 AtgNorm1 ¶

func AtgNorm1(ptr *Ctensor, self Ctensor, p Cscalar, dtype int32)

func AtgNorm2 ¶

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

func AtgNorm3 ¶

func AtgNorm3(ptr *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 AtgNormOut1 ¶

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

func AtgNormalOut ¶

func AtgNormalOut(ptr *Ctensor, out Ctensor, mean Ctensor, std float64)

func AtgNormalOut1 ¶

func AtgNormalOut1(ptr *Ctensor, out Ctensor, mean float64, std Ctensor)

func AtgNormalOut2 ¶

func AtgNormalOut2(ptr *Ctensor, out Ctensor, mean Ctensor, std Ctensor)

func AtgNormalOut3 ¶

func AtgNormalOut3(ptr *Ctensor, out Ctensor, mean float64, std float64, sizeData []int64, sizeLen int)

func AtgNormal_ ¶

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

func AtgNotEqual ¶

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

func AtgNotEqual1 ¶

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

func AtgNotEqual1_ ¶

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

func AtgNotEqualOut ¶

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

func AtgNotEqualOut1 ¶

func AtgNotEqualOut1(ptr *Ctensor, out 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 AtgNuclearNorm1 ¶

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

func AtgNuclearNormOut ¶

func AtgNuclearNormOut(ptr *Ctensor, out Ctensor, self Ctensor, keepdim int32)

func AtgNuclearNormOut1 ¶

func AtgNuclearNormOut1(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, 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 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)

func AtgPinverse ¶

func AtgPinverse(ptr *Ctensor, self Ctensor, rcond float64)

func AtgPixelShuffle ¶

func AtgPixelShuffle(ptr *Ctensor, self Ctensor, upscaleFactor 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 AtgPow ¶

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

func AtgPow1 ¶

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

func AtgPow1_ ¶

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

func AtgPow2 ¶

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

func AtgPowOut ¶

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

func AtgPowOut1 ¶

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

func AtgPowOut2 ¶

func AtgPowOut2(ptr *Ctensor, out Ctensor, selfScalar Cscalar, 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 AtgProd1 ¶

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

func AtgProdOut ¶

func AtgProdOut(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 AtgQPerChannelScales ¶

func AtgQPerChannelScales(ptr *Ctensor, self Ctensor)

func AtgQPerChannelZeroPoints ¶

func AtgQPerChannelZeroPoints(ptr *Ctensor, self Ctensor)

func AtgQr ¶

func AtgQr(ptr *Ctensor, self Ctensor, some int32)

func AtgQrOut ¶

func AtgQrOut(ptr *Ctensor, q Ctensor, r Ctensor, self Ctensor, some int32)

func AtgQuantile ¶

func AtgQuantile(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32)

func AtgQuantile1 ¶

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

func AtgQuantileOut ¶

func AtgQuantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32)

func AtgQuantileOut1 ¶

func AtgQuantileOut1(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, 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 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 AtgRandint1 ¶

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

func AtgRandintLike ¶

func AtgRandintLike(ptr *Ctensor, self Ctensor, high int64)

func AtgRandintLike1 ¶

func AtgRandintLike1(ptr *Ctensor, self Ctensor, low int64, high int64)

func AtgRandintOut ¶

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

func AtgRandintOut1 ¶

func AtgRandintOut1(ptr *Ctensor, out Ctensor, low int64, 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 AtgRandom1_ ¶

func AtgRandom1_(ptr *Ctensor, self Ctensor, to int64)

func AtgRandom2 ¶

func AtgRandom2(ptr *Ctensor, self Ctensor, from int64, toVal int64, toNull int)

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 AtgRange1 ¶

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

func AtgRangeOut ¶

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

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 AtgReflectionPad1dBackwardOut ¶

func AtgReflectionPad1dBackwardOut(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 AtgReflectionPad2dBackwardOut ¶

func AtgReflectionPad2dBackwardOut(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 AtgRelu ¶

func AtgRelu(ptr *Ctensor, self Ctensor)

func AtgRelu_ ¶

func AtgRelu_(ptr *Ctensor, self Ctensor)

func AtgRemainder ¶

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

func AtgRemainder1 ¶

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

func AtgRemainder1_ ¶

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

func AtgRemainderOut ¶

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

func AtgRemainderOut1 ¶

func AtgRemainderOut1(ptr *Ctensor, out 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)

func AtgRepeatInterleave1 ¶

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

func AtgRepeatInterleave2 ¶

func AtgRepeatInterleave2(ptr *Ctensor, self Ctensor, repeats int64, dimVal int64, dimNull 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 AtgReplicationPad1dBackwardOut ¶

func AtgReplicationPad1dBackwardOut(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 AtgReplicationPad2dBackwardOut ¶

func AtgReplicationPad2dBackwardOut(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 AtgReplicationPad3dBackwardOut ¶

func AtgReplicationPad3dBackwardOut(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 AtgResizeAs_ ¶

func AtgResizeAs_(ptr *Ctensor, self Ctensor, theTemplate Ctensor)

func AtgResize_ ¶

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

func AtgRfft ¶

func AtgRfft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32, onesided int32)

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 AtgRnnRelu1 ¶

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

func AtgRnnReluCell ¶

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

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 AtgRnnTanh1 ¶

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

func AtgRnnTanhCell ¶

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

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 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 AtgRsub1 ¶

func AtgRsub1(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 AtgScatter1 ¶

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

func AtgScatter1_ ¶

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

func AtgScatter2 ¶

func AtgScatter2(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, reduce string)

func AtgScatter3 ¶

func AtgScatter3(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar, reduce string)

func AtgScatterAdd ¶

func AtgScatterAdd(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 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 AtgSearchsorted1 ¶

func AtgSearchsorted1(ptr *Ctensor, sortedSequence Ctensor, selfScalar Cscalar, outInt32 int32, right int32)

func AtgSearchsortedOut ¶

func AtgSearchsortedOut(ptr *Ctensor, out Ctensor, sortedSequence Ctensor, self Ctensor, outInt32 int32, right int32)

func AtgSelect ¶

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

func AtgSelectBackward ¶

func AtgSelectBackward(ptr *Ctensor, grad 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 AtgSet1_ ¶

func AtgSet1_(ptr *Ctensor, self Ctensor, source Ctensor)

func AtgSetRequiresGrad ¶

func AtgSetRequiresGrad(ptr *Ctensor, self Ctensor, r int32)

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 AtgSigmoidBackwardOut ¶

func AtgSigmoidBackwardOut(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 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 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, start int64, end int64, step int64)

func AtgSliceBackward ¶

func AtgSliceBackward(ptr *Ctensor, grad 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 AtgSmoothL1LossBackwardOut ¶

func AtgSmoothL1LossBackwardOut(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 AtgSoftMarginLossBackwardOut ¶

func AtgSoftMarginLossBackwardOut(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 AtgSoftplusBackwardOut ¶

func AtgSoftplusBackwardOut(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 AtgSoftshrinkBackwardOut ¶

func AtgSoftshrinkBackwardOut(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 AtgSolveOut ¶

func AtgSolveOut(ptr *Ctensor, solution Ctensor, lu Ctensor, self Ctensor, a Ctensor)

func AtgSort ¶

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

func AtgSortOut ¶

func AtgSortOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, descending int32)

func AtgSparseCooTensor ¶

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

func AtgSparseCooTensor1 ¶

func AtgSparseCooTensor1(ptr *Ctensor, indices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32)

func AtgSparseCooTensor2 ¶

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

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 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 AtgSquare_ ¶

func AtgSquare_(ptr *Ctensor, self Ctensor)

func AtgSqueeze ¶

func AtgSqueeze(ptr *Ctensor, self Ctensor)

func AtgSqueeze1 ¶

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

func AtgSqueeze1_ ¶

func AtgSqueeze1_(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 AtgStd1 ¶

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

func AtgStdMean ¶

func AtgStdMean(ptr *Ctensor, self Ctensor, unbiased int32)

func AtgStdMean1 ¶

func AtgStdMean1(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 AtgSub1 ¶

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

func AtgSub1_ ¶

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

func AtgSubOut ¶

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

func AtgSub_ ¶

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

func AtgSubtract ¶

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

func AtgSubtract1 ¶

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

func AtgSubtract1_ ¶

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

func AtgSubtractOut ¶

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

func AtgSubtract_ ¶

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

func AtgSum ¶

func AtgSum(ptr *Ctensor, self Ctensor, dtype int32)

func AtgSum1 ¶

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

func AtgSumOut ¶

func AtgSumOut(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 AtgSvdOut ¶

func AtgSvdOut(ptr *Ctensor, u Ctensor, s Ctensor, v Ctensor, self Ctensor, some int32, computeUv int32)

func AtgSymeig ¶

func AtgSymeig(ptr *Ctensor, self Ctensor, eigenvectors int32, upper int32)

func AtgSymeigOut ¶

func AtgSymeigOut(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 AtgTakeBackward ¶

func AtgTakeBackward(ptr *Ctensor, grad Ctensor, input Ctensor, index Ctensor)

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 AtgTanhBackwardOut ¶

func AtgTanhBackwardOut(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 AtgThreshold ¶

func AtgThreshold(ptr *Ctensor, self Ctensor, threshold Cscalar, value Cscalar)

func AtgThresholdBackward ¶

func AtgThresholdBackward(ptr *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 AtgTo ¶

func AtgTo(ptr *Ctensor, self Ctensor, device int32)

func AtgTo1 ¶

func AtgTo1(ptr *Ctensor, self Ctensor, optionsKind int32, optionsDevice int32, nonBlocking int32, copy int32)

func AtgTo2 ¶

func AtgTo2(ptr *Ctensor, self Ctensor, dtype int32, nonBlocking int32, copy int32)

func AtgTo3 ¶

func AtgTo3(ptr *Ctensor, self Ctensor, other Ctensor, nonBlocking int32, copy int32)

func AtgTo4 ¶

func AtgTo4(ptr *Ctensor, self Ctensor, device int32, dtype int32, nonBlocking int32, copy int32)

func AtgToDense ¶

func AtgToDense(ptr *Ctensor, self Ctensor)

func AtgToDenseBackward ¶

func AtgToDenseBackward(ptr *Ctensor, grad Ctensor, input Ctensor)

func AtgToMkldnn ¶

func AtgToMkldnn(ptr *Ctensor, self Ctensor)

func AtgToMkldnnBackward ¶

func AtgToMkldnnBackward(ptr *Ctensor, grad Ctensor, input Ctensor)

func AtgToSparse ¶

func AtgToSparse(ptr *Ctensor, self Ctensor)

func AtgToSparse1 ¶

func AtgToSparse1(ptr *Ctensor, self Ctensor, sparseDim int64)

func AtgTopk ¶

func AtgTopk(ptr *Ctensor, self Ctensor, k int64, dim int64, largest int32, sorted int32)

func AtgTopkOut ¶

func AtgTopkOut(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 AtgTrapz ¶

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

func AtgTrapz1 ¶

func AtgTrapz1(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 AtgTriangularSolveOut ¶

func AtgTriangularSolveOut(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 AtgTrueDivide1 ¶

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

func AtgTrueDivide1_ ¶

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

func AtgTrueDivideOut ¶

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

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 AtgUpsampleBicubic2dBackwardOut ¶

func AtgUpsampleBicubic2dBackwardOut(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 AtgUpsampleBilinear2dBackwardOut ¶

func AtgUpsampleBilinear2dBackwardOut(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 AtgUpsampleLinear1dBackwardOut ¶

func AtgUpsampleLinear1dBackwardOut(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 AtgUpsampleNearest1dBackwardOut ¶

func AtgUpsampleNearest1dBackwardOut(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 AtgUpsampleNearest2dBackwardOut ¶

func AtgUpsampleNearest2dBackwardOut(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 AtgUpsampleNearest3dBackwardOut ¶

func AtgUpsampleNearest3dBackwardOut(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 AtgUpsampleTrilinear3dBackwardOut ¶

func AtgUpsampleTrilinear3dBackwardOut(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 AtgVar1 ¶

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

func AtgVarMean ¶

func AtgVarMean(ptr *Ctensor, self Ctensor, unbiased int32)

func AtgVarMean1 ¶

func AtgVarMean1(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 AtgVstack ¶

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

func AtgVstackOut ¶

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

func AtgWhere1 ¶

func AtgWhere1(ptr *Ctensor, condition Ctensor, self Ctensor, other Ctensor)

func AtgWhere2 ¶

func AtgWhere2(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Ctensor)

func AtgWhere3 ¶

func AtgWhere3(ptr *Ctensor, condition Ctensor, self Ctensor, other Cscalar)

func AtgWhere4 ¶

func AtgWhere4(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Cscalar)

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_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_AddRelu_ ¶

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

func Atg_AddmvImpl_ ¶

func Atg_AddmvImpl_(ptr *Ctensor, self Ctensor, self2 Ctensor, mat Ctensor, vec Ctensor)

func Atg_Aminmax ¶

func Atg_Aminmax(ptr *Ctensor, self Ctensor)

func Atg_Aminmax1 ¶

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

func Atg_AmpUpdateScale ¶

func Atg_AmpUpdateScale(ptr *Ctensor, growthTracker Ctensor, currentScale 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_Bmm ¶

func Atg_Bmm(ptr *Ctensor, self Ctensor, mat2 Ctensor, deterministic int32)

func Atg_BmmOut ¶

func Atg_BmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor, deterministic int32)

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_CholeskyHelper ¶

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

func Atg_CholeskySolveHelper ¶

func Atg_CholeskySolveHelper(ptr *Ctensor, self Ctensor, a Ctensor, upper int32)

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_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)

func Atg_Convolution1 ¶

func Atg_Convolution1(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_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_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, 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, numLayers int64, batchFirst int32, bidirectional int32)

func Atg_Cumprod ¶

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

func Atg_CumprodOut ¶

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

func Atg_Cumsum ¶

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

func Atg_CumsumOut ¶

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

func Atg_DimArange ¶

func Atg_DimArange(ptr *Ctensor, like Ctensor, dim 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)

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)

func Atg_EmbeddingBagDenseBackward ¶

func Atg_EmbeddingBagDenseBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, offsets Ctensor, offset2bag Ctensor, bagSize Ctensor, maximumIndices Ctensor, numWeights int64, scaleGradByFreq int32, mode int64, perSampleWeights Ctensor)

func Atg_EmbeddingBagForwardOnly ¶

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

func Atg_EmbeddingBagPerSampleWeightsBackward ¶

func Atg_EmbeddingBagPerSampleWeightsBackward(ptr *Ctensor, grad Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, offset2bag Ctensor, mode 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)

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)

func Atg_FakeQuantizeLearnablePerChannelAffineBackward ¶

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

func Atg_FakeQuantizeLearnablePerTensorAffine ¶

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

func Atg_FakeQuantizeLearnablePerTensorAffineBackward ¶

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

func Atg_FftWithSize ¶

func Atg_FftWithSize(ptr *Ctensor, self Ctensor, signalNdim int64, complexInput int32, complexOutput int32, inverse int32, checkedSignalSizesData []int64, checkedSignalSizesLen int, normalized int32, onesided int32, outputSizesData []int64, outputSizesLen int)

func Atg_FftWithSize1 ¶

func Atg_FftWithSize1(ptr *Ctensor, self Ctensor, signalNdim int64, complexInput int32, complexOutput int32, inverse int32, checkedSignalSizesData []int64, checkedSignalSizesLen int, normalization int64, onesided int32, outputSizesData []int64, outputSizesLen int)

func Atg_FusedDropout ¶

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

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_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_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_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_LuSolveHelper ¶

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

func Atg_LuWithInfo ¶

func Atg_LuWithInfo(ptr *Ctensor, self Ctensor, pivot int32, checkErrors int32)

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_Mode ¶

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

func Atg_ModeOut ¶

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

func Atg_MultinomialAliasDraw ¶

func Atg_MultinomialAliasDraw(ptr *Ctensor, j Ctensor, q Ctensor, numSamples int64)

func Atg_MultinomialAliasSetup ¶

func Atg_MultinomialAliasSetup(ptr *Ctensor, probs Ctensor)

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_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_QrHelper ¶

func Atg_QrHelper(ptr *Ctensor, self Ctensor, some int32)

func Atg_RemoveBatchDim ¶

func Atg_RemoveBatchDim(ptr *Ctensor, self Ctensor, level int64, batchSize int64, outDim int64)

func Atg_ReshapeFromTensor ¶

func Atg_ReshapeFromTensor(ptr *Ctensor, self Ctensor, shape Ctensor)

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_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_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_SparseLogSoftmax ¶

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

func Atg_SparseLogSoftmax1 ¶

func Atg_SparseLogSoftmax1(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_SparseMm ¶

func Atg_SparseMm(ptr *Ctensor, sparse Ctensor, dense Ctensor)

func Atg_SparseSoftmax ¶

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

func Atg_SparseSoftmax1 ¶

func Atg_SparseSoftmax1(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_SparseSum ¶

func Atg_SparseSum(ptr *Ctensor, self Ctensor)

func Atg_SparseSum1 ¶

func Atg_SparseSum1(ptr *Ctensor, self Ctensor, dtype int32)

func Atg_SparseSum2 ¶

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

func Atg_SparseSum3 ¶

func Atg_SparseSum3(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, dtype int32)

func Atg_SparseSumBackward ¶

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

func Atg_StandardGamma ¶

func Atg_StandardGamma(ptr *Ctensor, self Ctensor)

func Atg_StandardGammaGrad ¶

func Atg_StandardGammaGrad(ptr *Ctensor, self Ctensor, output Ctensor)

func Atg_Std ¶

func Atg_Std(ptr *Ctensor, self Ctensor, unbiased int32)

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_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_TriangularSolveHelper ¶

func Atg_TriangularSolveHelper(ptr *Ctensor, self Ctensor, a Ctensor, upper int32, transpose int32, unitriangular 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_UnsafeView ¶

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

func Atg_Values ¶

func Atg_Values(ptr *Ctensor, self Ctensor)

func Atg_Var ¶

func Atg_Var(ptr *Ctensor, self Ctensor, unbiased int32)

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__And1 ¶

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

func Atg__And_ ¶

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

func Atg__Iand1 ¶

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

func Atg__Iand_ ¶

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

func Atg__Ilshift1 ¶

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

func Atg__Ilshift_ ¶

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

func Atg__Ior1 ¶

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

func Atg__Ior_ ¶

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

func Atg__Irshift1 ¶

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

func Atg__Irshift_ ¶

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

func Atg__Ixor1 ¶

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

func Atg__Ixor_ ¶

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

func Atg__Lshift1 ¶

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

func Atg__Lshift_ ¶

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

func Atg__Or1 ¶

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

func Atg__Or_ ¶

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

func Atg__Rshift1 ¶

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

func Atg__Rshift_ ¶

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

func Atg__Xor1 ¶

func Atg__Xor1(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

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

README ¶

NOTES ON WRITING WRAPPER FUNCTIONS

Function Input Arguments

tensor -> t *C_tensor

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

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

Function Return

void *CFUNC(...)

tensor -> *C_tensor

tensor *CFUNC(...)

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

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

Multiple Tensors Created In C Land Memory

Documentation ¶

Overview ¶

Index ¶

Constants ¶

Variables ¶

Functions ¶

func AtBackward ¶

func AtCopyData ¶

func AtCopy_ ¶

func AtDataPtr ¶

func AtDefined ¶

func AtDevice ¶

func AtDim ¶

func AtDoubleValueAtIndexes ¶

func AtFree ¶

func AtGradSetEnabled ¶

func AtInt64ValueAtIndexes ¶

func AtIsSparse ¶

func AtLoadCallback ¶

func AtLoadCallbackWithDevice ¶

func AtLoadMulti ¶

func AtPrint ¶

func AtRequiresGrad ¶

func AtRunBackward ¶

func AtSave ¶

func AtSaveImage ¶

func AtSaveMulti ¶

func AtSaveMultiNew ¶

func AtScalarType ¶

func AtShape ¶

func AtToString ¶

func AtcCudaDeviceCount ¶

func AtcCudaIsAvailable ¶

func AtcCudnnIsAvailable ¶

func AtcSetBenchmarkCudnn ¶

func Atc_cuda_device_count ¶

func AtgAbs ¶

func AtgAbsOut ¶

func AtgAbs_ ¶

func AtgAbsolute ¶

func AtgAbsoluteOut ¶

func AtgAbsolute_ ¶

func AtgAcos ¶

func AtgAcosOut ¶

func AtgAcos_ ¶

func AtgAcosh ¶

func AtgAcoshOut ¶

func AtgAcosh_ ¶

func AtgAdaptiveAvgPool1d ¶

func AtgAdaptiveAvgPool2d ¶

func AtgAdaptiveAvgPool2dOut ¶

func AtgAdaptiveAvgPool3d ¶

func AtgAdaptiveAvgPool3dBackward ¶

func AtgAdaptiveAvgPool3dBackwardOut ¶

func AtgAdaptiveAvgPool3dOut ¶

func AtgAdaptiveMaxPool1d ¶

func AtgAdaptiveMaxPool2d ¶

func AtgAdaptiveMaxPool2dBackward ¶

func AtgAdaptiveMaxPool2dBackwardOut ¶

func AtgAdaptiveMaxPool2dOut ¶

func AtgAdaptiveMaxPool3d ¶

func AtgAdaptiveMaxPool3dBackward ¶

func AtgAdaptiveMaxPool3dBackwardOut ¶

func AtgAdaptiveMaxPool3dOut ¶

func AtgAdd ¶

func AtgAdd1 ¶

func AtgAdd1_ ¶

`tensor` -> `t *C_tensor`

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

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

`void *CFUNC(...)`

`tensor` -> `*C_tensor`

`tensor *CFUNC(...)`

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

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