6721 lines
356 KiB
Go
6721 lines
356 KiB
Go
package libtch
|
|
|
|
// NOTE. THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND!
|
|
|
|
//#include "stdbool.h"
|
|
//#include "torch_api.h"
|
|
import "C"
|
|
|
|
import "unsafe"
|
|
|
|
func Atg__And_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___and__(ptr, self, other )
|
|
}
|
|
func Atg__And1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___and__1(ptr, self, other)
|
|
}
|
|
func Atg__Iand_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___iand__(ptr, self, other )
|
|
}
|
|
func Atg__Iand1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___iand__1(ptr, self, other)
|
|
}
|
|
func Atg__Ilshift_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___ilshift__(ptr, self, other )
|
|
}
|
|
func Atg__Ilshift1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___ilshift__1(ptr, self, other)
|
|
}
|
|
func Atg__Ior_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___ior__(ptr, self, other )
|
|
}
|
|
func Atg__Ior1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___ior__1(ptr, self, other)
|
|
}
|
|
func Atg__Irshift_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___irshift__(ptr, self, other )
|
|
}
|
|
func Atg__Irshift1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___irshift__1(ptr, self, other)
|
|
}
|
|
func Atg__Ixor_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___ixor__(ptr, self, other )
|
|
}
|
|
func Atg__Ixor1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___ixor__1(ptr, self, other)
|
|
}
|
|
func Atg__Lshift_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___lshift__(ptr, self, other )
|
|
}
|
|
func Atg__Lshift1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___lshift__1(ptr, self, other)
|
|
}
|
|
func Atg__Or_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___or__(ptr, self, other )
|
|
}
|
|
func Atg__Or1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___or__1(ptr, self, other)
|
|
}
|
|
func Atg__Rshift_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___rshift__(ptr, self, other )
|
|
}
|
|
func Atg__Rshift1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___rshift__1(ptr, self, other)
|
|
}
|
|
func Atg__Xor_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg___xor__(ptr, self, other )
|
|
}
|
|
func Atg__Xor1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg___xor__1(ptr, self, other)
|
|
}
|
|
func Atg_AdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg__adaptive_avg_pool2d(ptr, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func Atg_AdaptiveAvgPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor){
|
|
C.atg__adaptive_avg_pool2d_backward(ptr, gradOutput, self)
|
|
}
|
|
func Atg_AddBatchDim(ptr *Ctensor, self Ctensor, batchDim int64, level int64){
|
|
cbatchDim := *(*C.int64_t)(unsafe.Pointer(&batchDim))
|
|
clevel := *(*C.int64_t)(unsafe.Pointer(&level))
|
|
C.atg__add_batch_dim(ptr, self, cbatchDim, clevel)
|
|
}
|
|
func Atg_AddRelu(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg__add_relu(ptr, self, other)
|
|
}
|
|
func Atg_AddRelu_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg__add_relu_(ptr, self, other)
|
|
}
|
|
func Atg_AddReluOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg__add_relu_out(ptr, out, self, other)
|
|
}
|
|
func Atg_AddmvImpl_(ptr *Ctensor, self Ctensor, self2 Ctensor, mat Ctensor, vec Ctensor){
|
|
C.atg__addmv_impl_(ptr, self, self2, mat, vec)
|
|
}
|
|
func Atg_Aminmax(ptr *Ctensor, self Ctensor){
|
|
C.atg__aminmax(ptr, self)
|
|
}
|
|
func Atg_Aminmax1(ptr *Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg__aminmax1(ptr, self, cdim, ckeepdim)
|
|
}
|
|
func Atg_AmpUpdateScale(ptr *Ctensor, growthTracker Ctensor, currentScale Ctensor, foundInf Ctensor, scaleGrowthFactor float64, scaleBackoffFactor float64, growthInterval int64){
|
|
cscaleGrowthFactor := *(*C.double)(unsafe.Pointer(&scaleGrowthFactor))
|
|
cscaleBackoffFactor := *(*C.double)(unsafe.Pointer(&scaleBackoffFactor))
|
|
cgrowthInterval := *(*C.int64_t)(unsafe.Pointer(&growthInterval))
|
|
C.atg__amp_update_scale(ptr, growthTracker, currentScale, foundInf, cscaleGrowthFactor, cscaleBackoffFactor, cgrowthInterval)
|
|
}
|
|
func Atg_BaddbmmMkl_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor){
|
|
C.atg__baddbmm_mkl_(ptr, self, batch1, batch2)
|
|
}
|
|
func Atg_Bmm(ptr *Ctensor, self Ctensor, mat2 Ctensor, deterministic int32){
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg__bmm(ptr, self, mat2, cdeterministic)
|
|
}
|
|
func Atg_BmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor, deterministic int32){
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg__bmm_out(ptr, out, self, mat2, cdeterministic)
|
|
}
|
|
func Atg_CastByte(ptr *Ctensor, self Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg__cast_byte(ptr, self, cnonBlocking)
|
|
}
|
|
func Atg_CastChar(ptr *Ctensor, self Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg__cast_char(ptr, self, cnonBlocking)
|
|
}
|
|
func Atg_CastDouble(ptr *Ctensor, self Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg__cast_double(ptr, self, cnonBlocking)
|
|
}
|
|
func Atg_CastFloat(ptr *Ctensor, self Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg__cast_float(ptr, self, cnonBlocking)
|
|
}
|
|
func Atg_CastHalf(ptr *Ctensor, self Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg__cast_half(ptr, self, cnonBlocking)
|
|
}
|
|
func Atg_CastInt(ptr *Ctensor, self Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg__cast_int(ptr, self, cnonBlocking)
|
|
}
|
|
func Atg_CastLong(ptr *Ctensor, self Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg__cast_long(ptr, self, cnonBlocking)
|
|
}
|
|
func Atg_CastShort(ptr *Ctensor, self Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg__cast_short(ptr, self, cnonBlocking)
|
|
}
|
|
func Atg_Cat(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__cat(ptr, ctensorsDataPtr, ctensorsLen, cdim)
|
|
}
|
|
func Atg_CatOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__cat_out(ptr, out, ctensorsDataPtr, ctensorsLen, cdim)
|
|
}
|
|
func Atg_CdistBackward(ptr *Ctensor, grad Ctensor, x1 Ctensor, x2 Ctensor, p float64, cdist Ctensor){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
C.atg__cdist_backward(ptr, grad, x1, x2, cp, cdist)
|
|
}
|
|
func Atg_CholeskyHelper(ptr *Ctensor, self Ctensor, upper int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg__cholesky_helper(ptr, self, cupper)
|
|
}
|
|
func Atg_CholeskySolveHelper(ptr *Ctensor, self Ctensor, a Ctensor, upper int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg__cholesky_solve_helper(ptr, self, a, cupper)
|
|
}
|
|
func Atg_Coalesced_(ptr *Ctensor, self Ctensor, coalesced int32){
|
|
ccoalesced := *(*C.int)(unsafe.Pointer(&coalesced))
|
|
C.atg__coalesced_(ptr, self, ccoalesced)
|
|
}
|
|
func Atg_ComputeLinearCombination(ptr *Ctensor, input Ctensor, coefficients Ctensor){
|
|
C.atg__compute_linear_combination(ptr, input, coefficients)
|
|
}
|
|
func Atg_ComputeLinearCombinationOut(ptr *Ctensor, out Ctensor, input Ctensor, coefficients Ctensor){
|
|
C.atg__compute_linear_combination_out(ptr, out, input, coefficients)
|
|
}
|
|
func Atg_Conj(ptr *Ctensor, self Ctensor){
|
|
C.atg__conj(ptr, self)
|
|
}
|
|
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){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
ctransposed := *(*C.int)(unsafe.Pointer(&transposed))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
ccudnnEnabled := *(*C.int)(unsafe.Pointer(&cudnnEnabled))
|
|
C.atg__convolution(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, ctransposed, coutputPaddingDataPtr, coutputPaddingLen, cgroups, cbenchmark, cdeterministic, ccudnnEnabled)
|
|
}
|
|
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){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
ctransposed := *(*C.int)(unsafe.Pointer(&transposed))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
ccudnnEnabled := *(*C.int)(unsafe.Pointer(&cudnnEnabled))
|
|
callowTf32 := *(*C.int)(unsafe.Pointer(&allowTf32))
|
|
C.atg__convolution1(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, ctransposed, coutputPaddingDataPtr, coutputPaddingLen, cgroups, cbenchmark, cdeterministic, ccudnnEnabled, callowTf32)
|
|
}
|
|
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){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
ctransposed := *(*C.int)(unsafe.Pointer(&transposed))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
C.atg__convolution_nogroup(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, ctransposed, coutputPaddingDataPtr, coutputPaddingLen)
|
|
}
|
|
func Atg_CopyFrom(ptr *Ctensor, self Ctensor, dst Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg__copy_from(ptr, self, dst, cnonBlocking)
|
|
}
|
|
func Atg_CtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, inputLengthsLen int, targetLengthsData []int64, targetLengthsLen int, blank int64, zeroInfinity int32){
|
|
cinputLengthsDataPtr := (*C.int64_t)(unsafe.Pointer(&inputLengthsData[0]))
|
|
cinputLengthsLen := *(*C.int)(unsafe.Pointer(&inputLengthsLen))
|
|
ctargetLengthsDataPtr := (*C.int64_t)(unsafe.Pointer(&targetLengthsData[0]))
|
|
ctargetLengthsLen := *(*C.int)(unsafe.Pointer(&targetLengthsLen))
|
|
cblank := *(*C.int64_t)(unsafe.Pointer(&blank))
|
|
czeroInfinity := *(*C.int)(unsafe.Pointer(&zeroInfinity))
|
|
C.atg__ctc_loss(ptr, logProbs, targets, cinputLengthsDataPtr, cinputLengthsLen, ctargetLengthsDataPtr, ctargetLengthsLen, cblank, czeroInfinity)
|
|
}
|
|
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){
|
|
cinputLengthsDataPtr := (*C.int64_t)(unsafe.Pointer(&inputLengthsData[0]))
|
|
cinputLengthsLen := *(*C.int)(unsafe.Pointer(&inputLengthsLen))
|
|
ctargetLengthsDataPtr := (*C.int64_t)(unsafe.Pointer(&targetLengthsData[0]))
|
|
ctargetLengthsLen := *(*C.int)(unsafe.Pointer(&targetLengthsLen))
|
|
cblank := *(*C.int64_t)(unsafe.Pointer(&blank))
|
|
czeroInfinity := *(*C.int)(unsafe.Pointer(&zeroInfinity))
|
|
C.atg__ctc_loss_backward(ptr, grad, logProbs, targets, cinputLengthsDataPtr, cinputLengthsLen, ctargetLengthsDataPtr, ctargetLengthsLen, negLogLikelihood, logAlpha, cblank, czeroInfinity)
|
|
}
|
|
func Atg_CudnnCtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, inputLengthsLen int, targetLengthsData []int64, targetLengthsLen int, blank int64, deterministic int32, zeroInfinity int32){
|
|
cinputLengthsDataPtr := (*C.int64_t)(unsafe.Pointer(&inputLengthsData[0]))
|
|
cinputLengthsLen := *(*C.int)(unsafe.Pointer(&inputLengthsLen))
|
|
ctargetLengthsDataPtr := (*C.int64_t)(unsafe.Pointer(&targetLengthsData[0]))
|
|
ctargetLengthsLen := *(*C.int)(unsafe.Pointer(&targetLengthsLen))
|
|
cblank := *(*C.int64_t)(unsafe.Pointer(&blank))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
czeroInfinity := *(*C.int)(unsafe.Pointer(&zeroInfinity))
|
|
C.atg__cudnn_ctc_loss(ptr, logProbs, targets, cinputLengthsDataPtr, cinputLengthsLen, ctargetLengthsDataPtr, ctargetLengthsLen, cblank, cdeterministic, czeroInfinity)
|
|
}
|
|
func Atg_CudnnInitDropoutState(ptr *Ctensor, dropout float64, train int32, dropoutSeed int64, optionsKind int32, optionsDevice int32){
|
|
cdropout := *(*C.double)(unsafe.Pointer(&dropout))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
cdropoutSeed := *(*C.int64_t)(unsafe.Pointer(&dropoutSeed))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg__cudnn_init_dropout_state(ptr, cdropout, ctrain, cdropoutSeed, coptionsKind, coptionsDevice)
|
|
}
|
|
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){
|
|
cweightDataPtr := (*Ctensor)(unsafe.Pointer(&weightData[0]))
|
|
cweightLen := *(*C.int)(unsafe.Pointer(&weightLen))
|
|
cweightStride0 := *(*C.int64_t)(unsafe.Pointer(&weightStride0))
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
chiddenSize := *(*C.int64_t)(unsafe.Pointer(&hiddenSize))
|
|
cnumLayers := *(*C.int64_t)(unsafe.Pointer(&numLayers))
|
|
cbatchFirst := *(*C.int)(unsafe.Pointer(&batchFirst))
|
|
cdropout := *(*C.double)(unsafe.Pointer(&dropout))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
cbidirectional := *(*C.int)(unsafe.Pointer(&bidirectional))
|
|
cbatchSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&batchSizesData[0]))
|
|
cbatchSizesLen := *(*C.int)(unsafe.Pointer(&batchSizesLen))
|
|
C.atg__cudnn_rnn(ptr, input, cweightDataPtr, cweightLen, cweightStride0, weightBuf, hx, cx, cmode, chiddenSize, cnumLayers, cbatchFirst, cdropout, ctrain, cbidirectional, cbatchSizesDataPtr, cbatchSizesLen, dropoutState)
|
|
}
|
|
func Atg_CudnnRnnFlattenWeight(ptr *Ctensor, weightArrData []Ctensor, weightArrLen int, weightStride0 int64, inputSize int64, mode int64, hiddenSize int64, numLayers int64, batchFirst int32, bidirectional int32){
|
|
cweightArrDataPtr := (*Ctensor)(unsafe.Pointer(&weightArrData[0]))
|
|
cweightArrLen := *(*C.int)(unsafe.Pointer(&weightArrLen))
|
|
cweightStride0 := *(*C.int64_t)(unsafe.Pointer(&weightStride0))
|
|
cinputSize := *(*C.int64_t)(unsafe.Pointer(&inputSize))
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
chiddenSize := *(*C.int64_t)(unsafe.Pointer(&hiddenSize))
|
|
cnumLayers := *(*C.int64_t)(unsafe.Pointer(&numLayers))
|
|
cbatchFirst := *(*C.int)(unsafe.Pointer(&batchFirst))
|
|
cbidirectional := *(*C.int)(unsafe.Pointer(&bidirectional))
|
|
C.atg__cudnn_rnn_flatten_weight(ptr, cweightArrDataPtr, cweightArrLen, cweightStride0, cinputSize, cmode, chiddenSize, cnumLayers, cbatchFirst, cbidirectional)
|
|
}
|
|
func Atg_Cumprod(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__cumprod(ptr, self, cdim)
|
|
}
|
|
func Atg_CumprodOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__cumprod_out(ptr, out, self, cdim)
|
|
}
|
|
func Atg_Cumsum(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__cumsum(ptr, self, cdim)
|
|
}
|
|
func Atg_CumsumOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__cumsum_out(ptr, out, self, cdim)
|
|
}
|
|
func Atg_DimArange(ptr *Ctensor, like Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__dim_arange(ptr, like, cdim)
|
|
}
|
|
func Atg_DirichletGrad(ptr *Ctensor, x Ctensor, alpha Ctensor, total Ctensor){
|
|
C.atg__dirichlet_grad(ptr, x, alpha, total)
|
|
}
|
|
func Atg_EmbeddingBag(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, scaleGradByFreq int32, mode int64, sparse int32, perSampleWeights Ctensor, includeLastOffset int32){
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
csparse := *(*C.int)(unsafe.Pointer(&sparse))
|
|
cincludeLastOffset := *(*C.int)(unsafe.Pointer(&includeLastOffset))
|
|
C.atg__embedding_bag(ptr, weight, indices, offsets, cscaleGradByFreq, cmode, csparse, perSampleWeights, cincludeLastOffset)
|
|
}
|
|
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){
|
|
cnumWeights := *(*C.int64_t)(unsafe.Pointer(&numWeights))
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
csparse := *(*C.int)(unsafe.Pointer(&sparse))
|
|
C.atg__embedding_bag_backward(ptr, grad, indices, offsets, offset2bag, bagSize, maximumIndices, cnumWeights, cscaleGradByFreq, cmode, csparse, perSampleWeights)
|
|
}
|
|
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){
|
|
cnumWeights := *(*C.int64_t)(unsafe.Pointer(&numWeights))
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
C.atg__embedding_bag_dense_backward(ptr, grad, indices, offsets, offset2bag, bagSize, maximumIndices, cnumWeights, cscaleGradByFreq, cmode, perSampleWeights)
|
|
}
|
|
func Atg_EmbeddingBagForwardOnly(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, scaleGradByFreq int32, mode int64, sparse int32, perSampleWeights Ctensor, includeLastOffset int32){
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
csparse := *(*C.int)(unsafe.Pointer(&sparse))
|
|
cincludeLastOffset := *(*C.int)(unsafe.Pointer(&includeLastOffset))
|
|
C.atg__embedding_bag_forward_only(ptr, weight, indices, offsets, cscaleGradByFreq, cmode, csparse, perSampleWeights, cincludeLastOffset)
|
|
}
|
|
func Atg_EmbeddingBagPerSampleWeightsBackward(ptr *Ctensor, grad Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, offset2bag Ctensor, mode int64){
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
C.atg__embedding_bag_per_sample_weights_backward(ptr, grad, weight, indices, offsets, offset2bag, cmode)
|
|
}
|
|
func Atg_EmbeddingBagSparseBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, offsets Ctensor, offset2bag Ctensor, bagSize Ctensor, numWeights int64, scaleGradByFreq int32, mode int64, perSampleWeights Ctensor){
|
|
cnumWeights := *(*C.int64_t)(unsafe.Pointer(&numWeights))
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
C.atg__embedding_bag_sparse_backward(ptr, grad, indices, offsets, offset2bag, bagSize, cnumWeights, cscaleGradByFreq, cmode, perSampleWeights)
|
|
}
|
|
func Atg_EmptyAffineQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32, scale float64, zeroPoint int64){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
cscale := *(*C.double)(unsafe.Pointer(&scale))
|
|
czeroPoint := *(*C.int64_t)(unsafe.Pointer(&zeroPoint))
|
|
C.atg__empty_affine_quantized(ptr, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice, cscale, czeroPoint)
|
|
}
|
|
func Atg_EmptyPerChannelAffineQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, scales Ctensor, zeroPoints Ctensor, axis int64, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
caxis := *(*C.int64_t)(unsafe.Pointer(&axis))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg__empty_per_channel_affine_quantized(ptr, csizeDataPtr, csizeLen, scales, zeroPoints, caxis, coptionsKind, coptionsDevice)
|
|
}
|
|
func Atg_EuclideanDist(ptr *Ctensor, x1 Ctensor, x2 Ctensor){
|
|
C.atg__euclidean_dist(ptr, x1, x2)
|
|
}
|
|
func Atg_FakeQuantizeLearnablePerChannelAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, quantMin int64, quantMax int64){
|
|
caxis := *(*C.int64_t)(unsafe.Pointer(&axis))
|
|
cquantMin := *(*C.int64_t)(unsafe.Pointer(&quantMin))
|
|
cquantMax := *(*C.int64_t)(unsafe.Pointer(&quantMax))
|
|
C.atg__fake_quantize_learnable_per_channel_affine(ptr, self, scale, zeroPoint, caxis, cquantMin, cquantMax)
|
|
}
|
|
func Atg_FakeQuantizeLearnablePerChannelAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, quantMin int64, quantMax int64){
|
|
caxis := *(*C.int64_t)(unsafe.Pointer(&axis))
|
|
cquantMin := *(*C.int64_t)(unsafe.Pointer(&quantMin))
|
|
cquantMax := *(*C.int64_t)(unsafe.Pointer(&quantMax))
|
|
C.atg__fake_quantize_learnable_per_channel_affine_backward(ptr, grad, self, scale, zeroPoint, caxis, cquantMin, cquantMax)
|
|
}
|
|
func Atg_FakeQuantizeLearnablePerTensorAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, quantMin int64, quantMax int64){
|
|
cquantMin := *(*C.int64_t)(unsafe.Pointer(&quantMin))
|
|
cquantMax := *(*C.int64_t)(unsafe.Pointer(&quantMax))
|
|
C.atg__fake_quantize_learnable_per_tensor_affine(ptr, self, scale, zeroPoint, cquantMin, cquantMax)
|
|
}
|
|
func Atg_FakeQuantizeLearnablePerTensorAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, quantMin int64, quantMax int64){
|
|
cquantMin := *(*C.int64_t)(unsafe.Pointer(&quantMin))
|
|
cquantMax := *(*C.int64_t)(unsafe.Pointer(&quantMax))
|
|
C.atg__fake_quantize_learnable_per_tensor_affine_backward(ptr, grad, self, scale, zeroPoint, cquantMin, cquantMax)
|
|
}
|
|
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){
|
|
csignalNdim := *(*C.int64_t)(unsafe.Pointer(&signalNdim))
|
|
ccomplexInput := *(*C.int)(unsafe.Pointer(&complexInput))
|
|
ccomplexOutput := *(*C.int)(unsafe.Pointer(&complexOutput))
|
|
cinverse := *(*C.int)(unsafe.Pointer(&inverse))
|
|
ccheckedSignalSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&checkedSignalSizesData[0]))
|
|
ccheckedSignalSizesLen := *(*C.int)(unsafe.Pointer(&checkedSignalSizesLen))
|
|
cnormalized := *(*C.int)(unsafe.Pointer(&normalized))
|
|
conesided := *(*C.int)(unsafe.Pointer(&onesided))
|
|
coutputSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizesData[0]))
|
|
coutputSizesLen := *(*C.int)(unsafe.Pointer(&outputSizesLen))
|
|
C.atg__fft_with_size(ptr, self, csignalNdim, ccomplexInput, ccomplexOutput, cinverse, ccheckedSignalSizesDataPtr, ccheckedSignalSizesLen, cnormalized, conesided, coutputSizesDataPtr, coutputSizesLen)
|
|
}
|
|
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){
|
|
csignalNdim := *(*C.int64_t)(unsafe.Pointer(&signalNdim))
|
|
ccomplexInput := *(*C.int)(unsafe.Pointer(&complexInput))
|
|
ccomplexOutput := *(*C.int)(unsafe.Pointer(&complexOutput))
|
|
cinverse := *(*C.int)(unsafe.Pointer(&inverse))
|
|
ccheckedSignalSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&checkedSignalSizesData[0]))
|
|
ccheckedSignalSizesLen := *(*C.int)(unsafe.Pointer(&checkedSignalSizesLen))
|
|
cnormalization := *(*C.int64_t)(unsafe.Pointer(&normalization))
|
|
conesided := *(*C.int)(unsafe.Pointer(&onesided))
|
|
coutputSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizesData[0]))
|
|
coutputSizesLen := *(*C.int)(unsafe.Pointer(&outputSizesLen))
|
|
C.atg__fft_with_size1(ptr, self, csignalNdim, ccomplexInput, ccomplexOutput, cinverse, ccheckedSignalSizesDataPtr, ccheckedSignalSizesLen, cnormalization, conesided, coutputSizesDataPtr, coutputSizesLen)
|
|
}
|
|
func Atg_FusedDropout(ptr *Ctensor, self Ctensor, p float64){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
C.atg__fused_dropout(ptr, self, cp)
|
|
}
|
|
func Atg_GatherSparseBackward(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, grad Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__gather_sparse_backward(ptr, self, cdim, index, grad)
|
|
}
|
|
func Atg_GridSampler2dCpuFallback(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32){
|
|
cinterpolationMode := *(*C.int64_t)(unsafe.Pointer(&interpolationMode))
|
|
cpaddingMode := *(*C.int64_t)(unsafe.Pointer(&paddingMode))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
C.atg__grid_sampler_2d_cpu_fallback(ptr, input, grid, cinterpolationMode, cpaddingMode, calignCorners)
|
|
}
|
|
func Atg_GridSampler2dCpuFallbackBackward(ptr *Ctensor, gradOutput Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32){
|
|
cinterpolationMode := *(*C.int64_t)(unsafe.Pointer(&interpolationMode))
|
|
cpaddingMode := *(*C.int64_t)(unsafe.Pointer(&paddingMode))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
C.atg__grid_sampler_2d_cpu_fallback_backward(ptr, gradOutput, input, grid, cinterpolationMode, cpaddingMode, calignCorners)
|
|
}
|
|
func Atg_IndexCopy_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__index_copy_(ptr, self, cdim, index, source)
|
|
}
|
|
func Atg_IndexPutImpl_(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, values Ctensor, accumulate int32, unsafety int32){
|
|
cindicesDataPtr := (*Ctensor)(unsafe.Pointer(&indicesData[0]))
|
|
cindicesLen := *(*C.int)(unsafe.Pointer(&indicesLen))
|
|
caccumulate := *(*C.int)(unsafe.Pointer(&accumulate))
|
|
cunsafety := *(*C.int)(unsafe.Pointer(&unsafety))
|
|
C.atg__index_put_impl_(ptr, self, cindicesDataPtr, cindicesLen, values, caccumulate, cunsafety)
|
|
}
|
|
func Atg_Indices(ptr *Ctensor, self Ctensor){
|
|
C.atg__indices(ptr, self)
|
|
}
|
|
func Atg_InverseHelper(ptr *Ctensor, self Ctensor){
|
|
C.atg__inverse_helper(ptr, self)
|
|
}
|
|
func Atg_LogSoftmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
chalfToFloat := *(*C.int)(unsafe.Pointer(&halfToFloat))
|
|
C.atg__log_softmax(ptr, self, cdim, chalfToFloat)
|
|
}
|
|
func Atg_LogSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__log_softmax_backward_data(ptr, gradOutput, output, cdim, self)
|
|
}
|
|
func Atg_Logcumsumexp(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__logcumsumexp(ptr, self, cdim)
|
|
}
|
|
func Atg_LogcumsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__logcumsumexp_out(ptr, out, self, cdim)
|
|
}
|
|
func Atg_LuSolveHelper(ptr *Ctensor, self Ctensor, lUData Ctensor, lUPivots Ctensor){
|
|
C.atg__lu_solve_helper(ptr, self, lUData, lUPivots)
|
|
}
|
|
func Atg_LuWithInfo(ptr *Ctensor, self Ctensor, pivot int32, checkErrors int32){
|
|
cpivot := *(*C.int)(unsafe.Pointer(&pivot))
|
|
ccheckErrors := *(*C.int)(unsafe.Pointer(&checkErrors))
|
|
C.atg__lu_with_info(ptr, self, cpivot, ccheckErrors)
|
|
}
|
|
func Atg_MakePerChannelQuantizedTensor(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64){
|
|
caxis := *(*C.int64_t)(unsafe.Pointer(&axis))
|
|
C.atg__make_per_channel_quantized_tensor(ptr, self, scale, zeroPoint, caxis)
|
|
}
|
|
func Atg_MakePerTensorQuantizedTensor(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64){
|
|
cscale := *(*C.double)(unsafe.Pointer(&scale))
|
|
czeroPoint := *(*C.int64_t)(unsafe.Pointer(&zeroPoint))
|
|
C.atg__make_per_tensor_quantized_tensor(ptr, self, cscale, czeroPoint)
|
|
}
|
|
func Atg_MaskedScale(ptr *Ctensor, self Ctensor, mask Ctensor, scale float64){
|
|
cscale := *(*C.double)(unsafe.Pointer(&scale))
|
|
C.atg__masked_scale(ptr, self, mask, cscale)
|
|
}
|
|
func Atg_MkldnnReshape(ptr *Ctensor, self Ctensor, shapeData []int64, shapeLen int){
|
|
cshapeDataPtr := (*C.int64_t)(unsafe.Pointer(&shapeData[0]))
|
|
cshapeLen := *(*C.int)(unsafe.Pointer(&shapeLen))
|
|
C.atg__mkldnn_reshape(ptr, self, cshapeDataPtr, cshapeLen)
|
|
}
|
|
func Atg_MkldnnTranspose(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64){
|
|
cdim0 := *(*C.int64_t)(unsafe.Pointer(&dim0))
|
|
cdim1 := *(*C.int64_t)(unsafe.Pointer(&dim1))
|
|
C.atg__mkldnn_transpose(ptr, self, cdim0, cdim1)
|
|
}
|
|
func Atg_MkldnnTranspose_(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64){
|
|
cdim0 := *(*C.int64_t)(unsafe.Pointer(&dim0))
|
|
cdim1 := *(*C.int64_t)(unsafe.Pointer(&dim1))
|
|
C.atg__mkldnn_transpose_(ptr, self, cdim0, cdim1)
|
|
}
|
|
func Atg_Mode(ptr *Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg__mode(ptr, self, cdim, ckeepdim)
|
|
}
|
|
func Atg_ModeOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg__mode_out(ptr, values, indices, self, cdim, ckeepdim)
|
|
}
|
|
func Atg_MultinomialAliasDraw(ptr *Ctensor, j Ctensor, q Ctensor, numSamples int64){
|
|
cnumSamples := *(*C.int64_t)(unsafe.Pointer(&numSamples))
|
|
C.atg__multinomial_alias_draw(ptr, j, q, cnumSamples)
|
|
}
|
|
func Atg_MultinomialAliasSetup(ptr *Ctensor, probs Ctensor){
|
|
C.atg__multinomial_alias_setup(ptr, probs)
|
|
}
|
|
func Atg_NnpackSpatialConvolution(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
C.atg__nnpack_spatial_convolution(ptr, input, weight, bias, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen)
|
|
}
|
|
func Atg_NnpackSpatialConvolutionBackwardInput(ptr *Ctensor, input Ctensor, gradOutput Ctensor, weight Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg__nnpack_spatial_convolution_backward_input(ptr, input, gradOutput, weight, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func Atg_NnpackSpatialConvolutionBackwardWeight(ptr *Ctensor, input Ctensor, weightsizeData []int64, weightsizeLen int, gradOutput Ctensor, paddingData []int64, paddingLen int){
|
|
cweightsizeDataPtr := (*C.int64_t)(unsafe.Pointer(&weightsizeData[0]))
|
|
cweightsizeLen := *(*C.int)(unsafe.Pointer(&weightsizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg__nnpack_spatial_convolution_backward_weight(ptr, input, cweightsizeDataPtr, cweightsizeLen, gradOutput, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func Atg_PackPaddedSequence(ptr *Ctensor, input Ctensor, lengths Ctensor, batchFirst int32){
|
|
cbatchFirst := *(*C.int)(unsafe.Pointer(&batchFirst))
|
|
C.atg__pack_padded_sequence(ptr, input, lengths, cbatchFirst)
|
|
}
|
|
func Atg_PackPaddedSequenceBackward(ptr *Ctensor, grad Ctensor, inputSizeData []int64, inputSizeLen int, batchSizes Ctensor, batchFirst int32){
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
cbatchFirst := *(*C.int)(unsafe.Pointer(&batchFirst))
|
|
C.atg__pack_padded_sequence_backward(ptr, grad, cinputSizeDataPtr, cinputSizeLen, batchSizes, cbatchFirst)
|
|
}
|
|
func Atg_PadPackedSequence(ptr *Ctensor, data Ctensor, batchSizes Ctensor, batchFirst int32, paddingValue Cscalar, totalLength int64){
|
|
cbatchFirst := *(*C.int)(unsafe.Pointer(&batchFirst))
|
|
ctotalLength := *(*C.int64_t)(unsafe.Pointer(&totalLength))
|
|
C.atg__pad_packed_sequence(ptr, data, batchSizes, cbatchFirst, paddingValue , ctotalLength)
|
|
}
|
|
func Atg_PdistBackward(ptr *Ctensor, grad Ctensor, self Ctensor, p float64, pdist Ctensor){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
C.atg__pdist_backward(ptr, grad, self, cp, pdist)
|
|
}
|
|
func Atg_QrHelper(ptr *Ctensor, self Ctensor, some int32){
|
|
csome := *(*C.int)(unsafe.Pointer(&some))
|
|
C.atg__qr_helper(ptr, self, csome)
|
|
}
|
|
func Atg_RemoveBatchDim(ptr *Ctensor, self Ctensor, level int64, batchSize int64, outDim int64){
|
|
clevel := *(*C.int64_t)(unsafe.Pointer(&level))
|
|
cbatchSize := *(*C.int64_t)(unsafe.Pointer(&batchSize))
|
|
coutDim := *(*C.int64_t)(unsafe.Pointer(&outDim))
|
|
C.atg__remove_batch_dim(ptr, self, clevel, cbatchSize, coutDim)
|
|
}
|
|
func Atg_ReshapeFromTensor(ptr *Ctensor, self Ctensor, shape Ctensor){
|
|
C.atg__reshape_from_tensor(ptr, self, shape)
|
|
}
|
|
func Atg_SWhere(ptr *Ctensor, condition Ctensor, self Ctensor, other Ctensor){
|
|
C.atg__s_where(ptr, condition, self, other)
|
|
}
|
|
func Atg_SampleDirichlet(ptr *Ctensor, self Ctensor){
|
|
C.atg__sample_dirichlet(ptr, self)
|
|
}
|
|
func Atg_SaturateWeightToFp16(ptr *Ctensor, weight Ctensor){
|
|
C.atg__saturate_weight_to_fp16(ptr, weight)
|
|
}
|
|
func Atg_ShapeAsTensor(ptr *Ctensor, self Ctensor){
|
|
C.atg__shape_as_tensor(ptr, self)
|
|
}
|
|
func Atg_SobolEngineDraw(ptr *Ctensor, quasi Ctensor, n int64, sobolstate Ctensor, dimension int64, numGenerated int64, dtype int32){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
cdimension := *(*C.int64_t)(unsafe.Pointer(&dimension))
|
|
cnumGenerated := *(*C.int64_t)(unsafe.Pointer(&numGenerated))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg__sobol_engine_draw(ptr, quasi, cn, sobolstate, cdimension, cnumGenerated, cdtype)
|
|
}
|
|
func Atg_SobolEngineFf_(ptr *Ctensor, self Ctensor, n int64, sobolstate Ctensor, dimension int64, numGenerated int64){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
cdimension := *(*C.int64_t)(unsafe.Pointer(&dimension))
|
|
cnumGenerated := *(*C.int64_t)(unsafe.Pointer(&numGenerated))
|
|
C.atg__sobol_engine_ff_(ptr, self, cn, sobolstate, cdimension, cnumGenerated)
|
|
}
|
|
func Atg_SobolEngineInitializeState_(ptr *Ctensor, self Ctensor, dimension int64){
|
|
cdimension := *(*C.int64_t)(unsafe.Pointer(&dimension))
|
|
C.atg__sobol_engine_initialize_state_(ptr, self, cdimension)
|
|
}
|
|
func Atg_SobolEngineScramble_(ptr *Ctensor, self Ctensor, ltm Ctensor, dimension int64){
|
|
cdimension := *(*C.int64_t)(unsafe.Pointer(&dimension))
|
|
C.atg__sobol_engine_scramble_(ptr, self, ltm, cdimension)
|
|
}
|
|
func Atg_Softmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
chalfToFloat := *(*C.int)(unsafe.Pointer(&halfToFloat))
|
|
C.atg__softmax(ptr, self, cdim, chalfToFloat)
|
|
}
|
|
func Atg_SoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__softmax_backward_data(ptr, gradOutput, output, cdim, self)
|
|
}
|
|
func Atg_SolveHelper(ptr *Ctensor, self Ctensor, a Ctensor){
|
|
C.atg__solve_helper(ptr, self, a)
|
|
}
|
|
func Atg_SparseAddmm(ptr *Ctensor, self Ctensor, sparse Ctensor, dense Ctensor){
|
|
C.atg__sparse_addmm(ptr, self, sparse, dense)
|
|
}
|
|
func Atg_SparseCooTensorUnsafe(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg__sparse_coo_tensor_unsafe(ptr, indices, values, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func Atg_SparseCooTensorWithDims(ptr *Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim))
|
|
cdenseDim := *(*C.int64_t)(unsafe.Pointer(&denseDim))
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg__sparse_coo_tensor_with_dims(ptr, csparseDim, cdenseDim, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func Atg_SparseCooTensorWithDimsAndTensors(ptr *Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, indices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32){
|
|
csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim))
|
|
cdenseDim := *(*C.int64_t)(unsafe.Pointer(&denseDim))
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg__sparse_coo_tensor_with_dims_and_tensors(ptr, csparseDim, cdenseDim, csizeDataPtr, csizeLen, indices, values, coptionsKind, coptionsDevice)
|
|
}
|
|
func Atg_SparseLogSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg__sparse_log_softmax(ptr, self, cdim, cdtype)
|
|
}
|
|
func Atg_SparseLogSoftmax1(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
chalfToFloat := *(*C.int)(unsafe.Pointer(&halfToFloat))
|
|
C.atg__sparse_log_softmax1(ptr, self, cdim, chalfToFloat)
|
|
}
|
|
func Atg_SparseLogSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__sparse_log_softmax_backward_data(ptr, gradOutput, output, cdim, self)
|
|
}
|
|
func Atg_SparseMm(ptr *Ctensor, sparse Ctensor, dense Ctensor){
|
|
C.atg__sparse_mm(ptr, sparse, dense)
|
|
}
|
|
func Atg_SparseSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg__sparse_softmax(ptr, self, cdim, cdtype)
|
|
}
|
|
func Atg_SparseSoftmax1(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
chalfToFloat := *(*C.int)(unsafe.Pointer(&halfToFloat))
|
|
C.atg__sparse_softmax1(ptr, self, cdim, chalfToFloat)
|
|
}
|
|
func Atg_SparseSoftmaxBackwardData(ptr *Ctensor, gradOutput Ctensor, output Ctensor, dim int64, self Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__sparse_softmax_backward_data(ptr, gradOutput, output, cdim, self)
|
|
}
|
|
func Atg_SparseSum(ptr *Ctensor, self Ctensor){
|
|
C.atg__sparse_sum(ptr, self)
|
|
}
|
|
func Atg_SparseSum1(ptr *Ctensor, self Ctensor, dtype int32){
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg__sparse_sum1(ptr, self, cdtype)
|
|
}
|
|
func Atg_SparseSum2(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
C.atg__sparse_sum2(ptr, self, cdimDataPtr, cdimLen)
|
|
}
|
|
func Atg_SparseSum3(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg__sparse_sum3(ptr, self, cdimDataPtr, cdimLen, cdtype)
|
|
}
|
|
func Atg_SparseSumBackward(ptr *Ctensor, grad Ctensor, self Ctensor, dimData []int64, dimLen int){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
C.atg__sparse_sum_backward(ptr, grad, self, cdimDataPtr, cdimLen)
|
|
}
|
|
func Atg_StandardGamma(ptr *Ctensor, self Ctensor){
|
|
C.atg__standard_gamma(ptr, self)
|
|
}
|
|
func Atg_StandardGammaGrad(ptr *Ctensor, self Ctensor, output Ctensor){
|
|
C.atg__standard_gamma_grad(ptr, self, output)
|
|
}
|
|
func Atg_Std(ptr *Ctensor, self Ctensor, unbiased int32){
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
C.atg__std(ptr, self, cunbiased)
|
|
}
|
|
func Atg_SvdHelper(ptr *Ctensor, self Ctensor, some int32, computeUv int32){
|
|
csome := *(*C.int)(unsafe.Pointer(&some))
|
|
ccomputeUv := *(*C.int)(unsafe.Pointer(&computeUv))
|
|
C.atg__svd_helper(ptr, self, csome, ccomputeUv)
|
|
}
|
|
func Atg_SymeigHelper(ptr *Ctensor, self Ctensor, eigenvectors int32, upper int32){
|
|
ceigenvectors := *(*C.int)(unsafe.Pointer(&eigenvectors))
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg__symeig_helper(ptr, self, ceigenvectors, cupper)
|
|
}
|
|
func Atg_TestOptionalFilledIntlist(ptr *Ctensor, values Ctensor, addendsData []int64, addendsLen int){
|
|
caddendsDataPtr := (*C.int64_t)(unsafe.Pointer(&addendsData[0]))
|
|
caddendsLen := *(*C.int)(unsafe.Pointer(&addendsLen))
|
|
C.atg__test_optional_filled_intlist(ptr, values, caddendsDataPtr, caddendsLen)
|
|
}
|
|
func Atg_TestOptionalIntlist(ptr *Ctensor, values Ctensor, addendsData []int64, addendsLen int){
|
|
caddendsDataPtr := (*C.int64_t)(unsafe.Pointer(&addendsData[0]))
|
|
caddendsLen := *(*C.int)(unsafe.Pointer(&addendsLen))
|
|
C.atg__test_optional_intlist(ptr, values, caddendsDataPtr, caddendsLen)
|
|
}
|
|
func Atg_TestSerializationSubcmul(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg__test_serialization_subcmul(ptr, self, other)
|
|
}
|
|
func Atg_TriangularSolveHelper(ptr *Ctensor, self Ctensor, a Ctensor, upper int32, transpose int32, unitriangular int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
ctranspose := *(*C.int)(unsafe.Pointer(&transpose))
|
|
cunitriangular := *(*C.int)(unsafe.Pointer(&unitriangular))
|
|
C.atg__triangular_solve_helper(ptr, self, a, cupper, ctranspose, cunitriangular)
|
|
}
|
|
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){
|
|
cexpand1DataPtr := (*C.int64_t)(unsafe.Pointer(&expand1Data[0]))
|
|
cexpand1Len := *(*C.int)(unsafe.Pointer(&expand1Len))
|
|
cexpand2DataPtr := (*C.int64_t)(unsafe.Pointer(&expand2Data[0]))
|
|
cexpand2Len := *(*C.int)(unsafe.Pointer(&expand2Len))
|
|
cexpand3DataPtr := (*C.int64_t)(unsafe.Pointer(&expand3Data[0]))
|
|
cexpand3Len := *(*C.int)(unsafe.Pointer(&expand3Len))
|
|
csumdimDataPtr := (*C.int64_t)(unsafe.Pointer(&sumdimData[0]))
|
|
csumdimLen := *(*C.int)(unsafe.Pointer(&sumdimLen))
|
|
cunrollDim := *(*C.int64_t)(unsafe.Pointer(&unrollDim))
|
|
C.atg__trilinear(ptr, i1, i2, i3, cexpand1DataPtr, cexpand1Len, cexpand2DataPtr, cexpand2Len, cexpand3DataPtr, cexpand3Len, csumdimDataPtr, csumdimLen, cunrollDim)
|
|
}
|
|
func Atg_Unique(ptr *Ctensor, self Ctensor, sorted int32, returnInverse int32){
|
|
csorted := *(*C.int)(unsafe.Pointer(&sorted))
|
|
creturnInverse := *(*C.int)(unsafe.Pointer(&returnInverse))
|
|
C.atg__unique(ptr, self, csorted, creturnInverse)
|
|
}
|
|
func Atg_Unique2(ptr *Ctensor, self Ctensor, sorted int32, returnInverse int32, returnCounts int32){
|
|
csorted := *(*C.int)(unsafe.Pointer(&sorted))
|
|
creturnInverse := *(*C.int)(unsafe.Pointer(&returnInverse))
|
|
creturnCounts := *(*C.int)(unsafe.Pointer(&returnCounts))
|
|
C.atg__unique2(ptr, self, csorted, creturnInverse, creturnCounts)
|
|
}
|
|
func Atg_UnsafeView(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg__unsafe_view(ptr, self, csizeDataPtr, csizeLen)
|
|
}
|
|
func Atg_Values(ptr *Ctensor, self Ctensor){
|
|
C.atg__values(ptr, self)
|
|
}
|
|
func Atg_Var(ptr *Ctensor, self Ctensor, unbiased int32){
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
C.atg__var(ptr, self, cunbiased)
|
|
}
|
|
func Atg_WeightNorm(ptr *Ctensor, v Ctensor, g Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__weight_norm(ptr, v, g, cdim)
|
|
}
|
|
func Atg_WeightNormCudaInterface(ptr *Ctensor, v Ctensor, g Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__weight_norm_cuda_interface(ptr, v, g, cdim)
|
|
}
|
|
func Atg_WeightNormCudaInterfaceBackward(ptr *Ctensor, gradW Ctensor, savedV Ctensor, savedG Ctensor, savedNorms Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__weight_norm_cuda_interface_backward(ptr, gradW, savedV, savedG, savedNorms, cdim)
|
|
}
|
|
func Atg_WeightNormDifferentiableBackward(ptr *Ctensor, gradW Ctensor, savedV Ctensor, savedG Ctensor, savedNorms Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg__weight_norm_differentiable_backward(ptr, gradW, savedV, savedG, savedNorms, cdim)
|
|
}
|
|
func AtgAbs(ptr *Ctensor, self Ctensor){
|
|
C.atg_abs(ptr, self)
|
|
}
|
|
func AtgAbs_(ptr *Ctensor, self Ctensor){
|
|
C.atg_abs_(ptr, self)
|
|
}
|
|
func AtgAbsOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_abs_out(ptr, out, self)
|
|
}
|
|
func AtgAbsolute(ptr *Ctensor, self Ctensor){
|
|
C.atg_absolute(ptr, self)
|
|
}
|
|
func AtgAbsolute_(ptr *Ctensor, self Ctensor){
|
|
C.atg_absolute_(ptr, self)
|
|
}
|
|
func AtgAbsoluteOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_absolute_out(ptr, out, self)
|
|
}
|
|
func AtgAcos(ptr *Ctensor, self Ctensor){
|
|
C.atg_acos(ptr, self)
|
|
}
|
|
func AtgAcos_(ptr *Ctensor, self Ctensor){
|
|
C.atg_acos_(ptr, self)
|
|
}
|
|
func AtgAcosOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_acos_out(ptr, out, self)
|
|
}
|
|
func AtgAcosh(ptr *Ctensor, self Ctensor){
|
|
C.atg_acosh(ptr, self)
|
|
}
|
|
func AtgAcosh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_acosh_(ptr, self)
|
|
}
|
|
func AtgAcoshOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_acosh_out(ptr, out, self)
|
|
}
|
|
func AtgAdaptiveAvgPool1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_avg_pool1d(ptr, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_avg_pool2d(ptr, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdaptiveAvgPool2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_avg_pool2d_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdaptiveAvgPool3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_avg_pool3d(ptr, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdaptiveAvgPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor){
|
|
C.atg_adaptive_avg_pool3d_backward(ptr, gradOutput, self)
|
|
}
|
|
func AtgAdaptiveAvgPool3dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor){
|
|
C.atg_adaptive_avg_pool3d_backward_out(ptr, gradInput, gradOutput, self)
|
|
}
|
|
func AtgAdaptiveAvgPool3dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_avg_pool3d_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdaptiveMaxPool1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_max_pool1d(ptr, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdaptiveMaxPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_max_pool2d(ptr, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdaptiveMaxPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor){
|
|
C.atg_adaptive_max_pool2d_backward(ptr, gradOutput, self, indices)
|
|
}
|
|
func AtgAdaptiveMaxPool2dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor){
|
|
C.atg_adaptive_max_pool2d_backward_out(ptr, gradInput, gradOutput, self, indices)
|
|
}
|
|
func AtgAdaptiveMaxPool2dOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_max_pool2d_out(ptr, out, indices, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdaptiveMaxPool3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_max_pool3d(ptr, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdaptiveMaxPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor){
|
|
C.atg_adaptive_max_pool3d_backward(ptr, gradOutput, self, indices)
|
|
}
|
|
func AtgAdaptiveMaxPool3dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor){
|
|
C.atg_adaptive_max_pool3d_backward_out(ptr, gradInput, gradOutput, self, indices)
|
|
}
|
|
func AtgAdaptiveMaxPool3dOut(ptr *Ctensor, out Ctensor, indices Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_adaptive_max_pool3d_out(ptr, out, indices, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgAdd(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_add(ptr, self, other)
|
|
}
|
|
func AtgAdd1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_add1(ptr, self, other )
|
|
}
|
|
func AtgAdd_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_add_(ptr, self, other)
|
|
}
|
|
func AtgAdd1_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_add_1(ptr, self, other )
|
|
}
|
|
func AtgAddOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_add_out(ptr, out, self, other)
|
|
}
|
|
func AtgAddbmm(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor){
|
|
C.atg_addbmm(ptr, self, batch1, batch2)
|
|
}
|
|
func AtgAddbmm_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor){
|
|
C.atg_addbmm_(ptr, self, batch1, batch2)
|
|
}
|
|
func AtgAddbmmOut(ptr *Ctensor, out Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor){
|
|
C.atg_addbmm_out(ptr, out, self, batch1, batch2)
|
|
}
|
|
func AtgAddcdiv(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor){
|
|
C.atg_addcdiv(ptr, self, tensor1, tensor2)
|
|
}
|
|
func AtgAddcdiv_(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor){
|
|
C.atg_addcdiv_(ptr, self, tensor1, tensor2)
|
|
}
|
|
func AtgAddcdivOut(ptr *Ctensor, out Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor){
|
|
C.atg_addcdiv_out(ptr, out, self, tensor1, tensor2)
|
|
}
|
|
func AtgAddcmul(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor){
|
|
C.atg_addcmul(ptr, self, tensor1, tensor2)
|
|
}
|
|
func AtgAddcmul_(ptr *Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor){
|
|
C.atg_addcmul_(ptr, self, tensor1, tensor2)
|
|
}
|
|
func AtgAddcmulOut(ptr *Ctensor, out Ctensor, self Ctensor, tensor1 Ctensor, tensor2 Ctensor){
|
|
C.atg_addcmul_out(ptr, out, self, tensor1, tensor2)
|
|
}
|
|
func AtgAddmm(ptr *Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor){
|
|
C.atg_addmm(ptr, self, mat1, mat2)
|
|
}
|
|
func AtgAddmm_(ptr *Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor){
|
|
C.atg_addmm_(ptr, self, mat1, mat2)
|
|
}
|
|
func AtgAddmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor){
|
|
C.atg_addmm_out(ptr, out, self, mat1, mat2)
|
|
}
|
|
func AtgAddmv(ptr *Ctensor, self Ctensor, mat Ctensor, vec Ctensor){
|
|
C.atg_addmv(ptr, self, mat, vec)
|
|
}
|
|
func AtgAddmv_(ptr *Ctensor, self Ctensor, mat Ctensor, vec Ctensor){
|
|
C.atg_addmv_(ptr, self, mat, vec)
|
|
}
|
|
func AtgAddmvOut(ptr *Ctensor, out Ctensor, self Ctensor, mat Ctensor, vec Ctensor){
|
|
C.atg_addmv_out(ptr, out, self, mat, vec)
|
|
}
|
|
func AtgAddr(ptr *Ctensor, self Ctensor, vec1 Ctensor, vec2 Ctensor){
|
|
C.atg_addr(ptr, self, vec1, vec2)
|
|
}
|
|
func AtgAddr_(ptr *Ctensor, self Ctensor, vec1 Ctensor, vec2 Ctensor){
|
|
C.atg_addr_(ptr, self, vec1, vec2)
|
|
}
|
|
func AtgAddrOut(ptr *Ctensor, out Ctensor, self Ctensor, vec1 Ctensor, vec2 Ctensor){
|
|
C.atg_addr_out(ptr, out, self, vec1, vec2)
|
|
}
|
|
func AtgAffineGridGenerator(ptr *Ctensor, theta Ctensor, sizeData []int64, sizeLen int, alignCorners int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
C.atg_affine_grid_generator(ptr, theta, csizeDataPtr, csizeLen, calignCorners)
|
|
}
|
|
func AtgAffineGridGeneratorBackward(ptr *Ctensor, grad Ctensor, sizeData []int64, sizeLen int, alignCorners int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
C.atg_affine_grid_generator_backward(ptr, grad, csizeDataPtr, csizeLen, calignCorners)
|
|
}
|
|
func AtgAlias(ptr *Ctensor, self Ctensor){
|
|
C.atg_alias(ptr, self)
|
|
}
|
|
func AtgAlignAs(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_align_as(ptr, self, other)
|
|
}
|
|
|
|
func AtgAll(ptr *Ctensor, self Ctensor){
|
|
C.atg_all(ptr, self)
|
|
}
|
|
func AtgAll1(ptr *Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_all1(ptr, self, cdim, ckeepdim)
|
|
}
|
|
func AtgAllOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_all_out(ptr, out, self, cdim, ckeepdim)
|
|
}
|
|
func AtgAlphaDropout(ptr *Ctensor, input Ctensor, p float64, train int32){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
C.atg_alpha_dropout(ptr, input, cp, ctrain)
|
|
}
|
|
func AtgAlphaDropout_(ptr *Ctensor, self Ctensor, p float64, train int32){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
C.atg_alpha_dropout_(ptr, self, cp, ctrain)
|
|
}
|
|
func AtgAmax(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_amax(ptr, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgAmaxOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_amax_out(ptr, out, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgAmin(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_amin(ptr, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgAminOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_amin_out(ptr, out, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgAngle(ptr *Ctensor, self Ctensor){
|
|
C.atg_angle(ptr, self)
|
|
}
|
|
func AtgAngleOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_angle_out(ptr, out, self)
|
|
}
|
|
func AtgAny(ptr *Ctensor, self Ctensor){
|
|
C.atg_any(ptr, self)
|
|
}
|
|
func AtgAny1(ptr *Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_any1(ptr, self, cdim, ckeepdim)
|
|
}
|
|
func AtgAnyOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_any_out(ptr, out, self, cdim, ckeepdim)
|
|
}
|
|
func AtgArange(ptr *Ctensor, end Cscalar, optionsKind int32, optionsDevice int32){
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_arange(ptr, end , coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgArange1(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, optionsDevice int32){
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_arange1(ptr, start , end , coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgArange2(ptr *Ctensor, start Cscalar, end Cscalar, step Cscalar, optionsKind int32, optionsDevice int32){
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_arange2(ptr, start , end , step , coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgArangeOut(ptr *Ctensor, out Ctensor, end Cscalar){
|
|
C.atg_arange_out(ptr, out, end )
|
|
}
|
|
func AtgArangeOut1(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar){
|
|
C.atg_arange_out1(ptr, out, start , end )
|
|
}
|
|
func AtgArccos(ptr *Ctensor, self Ctensor){
|
|
C.atg_arccos(ptr, self)
|
|
}
|
|
func AtgArccos_(ptr *Ctensor, self Ctensor){
|
|
C.atg_arccos_(ptr, self)
|
|
}
|
|
func AtgArccosOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_arccos_out(ptr, out, self)
|
|
}
|
|
func AtgArccosh(ptr *Ctensor, self Ctensor){
|
|
C.atg_arccosh(ptr, self)
|
|
}
|
|
func AtgArccosh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_arccosh_(ptr, self)
|
|
}
|
|
func AtgArccoshOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_arccosh_out(ptr, out, self)
|
|
}
|
|
func AtgArcsin(ptr *Ctensor, self Ctensor){
|
|
C.atg_arcsin(ptr, self)
|
|
}
|
|
func AtgArcsin_(ptr *Ctensor, self Ctensor){
|
|
C.atg_arcsin_(ptr, self)
|
|
}
|
|
func AtgArcsinOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_arcsin_out(ptr, out, self)
|
|
}
|
|
func AtgArcsinh(ptr *Ctensor, self Ctensor){
|
|
C.atg_arcsinh(ptr, self)
|
|
}
|
|
func AtgArcsinh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_arcsinh_(ptr, self)
|
|
}
|
|
func AtgArcsinhOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_arcsinh_out(ptr, out, self)
|
|
}
|
|
func AtgArctan(ptr *Ctensor, self Ctensor){
|
|
C.atg_arctan(ptr, self)
|
|
}
|
|
func AtgArctan_(ptr *Ctensor, self Ctensor){
|
|
C.atg_arctan_(ptr, self)
|
|
}
|
|
func AtgArctanOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_arctan_out(ptr, out, self)
|
|
}
|
|
func AtgArctanh(ptr *Ctensor, self Ctensor){
|
|
C.atg_arctanh(ptr, self)
|
|
}
|
|
func AtgArctanh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_arctanh_(ptr, self)
|
|
}
|
|
func AtgArctanhOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_arctanh_out(ptr, out, self)
|
|
}
|
|
func AtgArgmax(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_argmax(ptr, self, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgArgmin(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int, keepdim int32){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_argmin(ptr, self, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgArgsort(ptr *Ctensor, self Ctensor, dim int64, descending int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdescending := *(*C.int)(unsafe.Pointer(&descending))
|
|
C.atg_argsort(ptr, self, cdim, cdescending)
|
|
}
|
|
func AtgAsStrided(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, strideLen int, storageOffsetVal int64, storageOffsetNull int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cstorageOffsetVal := *(*C.int64_t)(unsafe.Pointer(&storageOffsetVal))
|
|
cstorageOffsetNull := *(*C.uint8_t)(unsafe.Pointer(&storageOffsetNull))
|
|
C.atg_as_strided(ptr, self, csizeDataPtr, csizeLen, cstrideDataPtr, cstrideLen, cstorageOffsetVal, cstorageOffsetNull)
|
|
}
|
|
func AtgAsStrided_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, strideData []int64, strideLen int, storageOffsetVal int64, storageOffsetNull int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cstorageOffsetVal := *(*C.int64_t)(unsafe.Pointer(&storageOffsetVal))
|
|
cstorageOffsetNull := *(*C.uint8_t)(unsafe.Pointer(&storageOffsetNull))
|
|
C.atg_as_strided_(ptr, self, csizeDataPtr, csizeLen, cstrideDataPtr, cstrideLen, cstorageOffsetVal, cstorageOffsetNull)
|
|
}
|
|
func AtgAsin(ptr *Ctensor, self Ctensor){
|
|
C.atg_asin(ptr, self)
|
|
}
|
|
func AtgAsin_(ptr *Ctensor, self Ctensor){
|
|
C.atg_asin_(ptr, self)
|
|
}
|
|
func AtgAsinOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_asin_out(ptr, out, self)
|
|
}
|
|
func AtgAsinh(ptr *Ctensor, self Ctensor){
|
|
C.atg_asinh(ptr, self)
|
|
}
|
|
func AtgAsinh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_asinh_(ptr, self)
|
|
}
|
|
func AtgAsinhOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_asinh_out(ptr, out, self)
|
|
}
|
|
func AtgAtan(ptr *Ctensor, self Ctensor){
|
|
C.atg_atan(ptr, self)
|
|
}
|
|
func AtgAtan2(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_atan2(ptr, self, other)
|
|
}
|
|
func AtgAtan2_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_atan2_(ptr, self, other)
|
|
}
|
|
func AtgAtan2Out(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_atan2_out(ptr, out, self, other)
|
|
}
|
|
func AtgAtan_(ptr *Ctensor, self Ctensor){
|
|
C.atg_atan_(ptr, self)
|
|
}
|
|
func AtgAtanOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_atan_out(ptr, out, self)
|
|
}
|
|
func AtgAtanh(ptr *Ctensor, self Ctensor){
|
|
C.atg_atanh(ptr, self)
|
|
}
|
|
func AtgAtanh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_atanh_(ptr, self)
|
|
}
|
|
func AtgAtanhOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_atanh_out(ptr, out, self)
|
|
}
|
|
func AtgAtleast1d(ptr *Ctensor, self Ctensor){
|
|
C.atg_atleast_1d(ptr, self)
|
|
}
|
|
|
|
func AtgAtleast2d(ptr *Ctensor, self Ctensor){
|
|
C.atg_atleast_2d(ptr, self)
|
|
}
|
|
|
|
func AtgAtleast3d(ptr *Ctensor, self Ctensor){
|
|
C.atg_atleast_3d(ptr, self)
|
|
}
|
|
|
|
func AtgAvgPool1d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, ceilMode int32, countIncludePad int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
ccountIncludePad := *(*C.int)(unsafe.Pointer(&countIncludePad))
|
|
C.atg_avg_pool1d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cceilMode, ccountIncludePad)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
ccountIncludePad := *(*C.int)(unsafe.Pointer(&countIncludePad))
|
|
cdivisorOverrideVal := *(*C.int64_t)(unsafe.Pointer(&divisorOverrideVal))
|
|
cdivisorOverrideNull := *(*C.uint8_t)(unsafe.Pointer(&divisorOverrideNull))
|
|
C.atg_avg_pool2d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cceilMode, ccountIncludePad, cdivisorOverrideVal, cdivisorOverrideNull)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
ccountIncludePad := *(*C.int)(unsafe.Pointer(&countIncludePad))
|
|
cdivisorOverrideVal := *(*C.int64_t)(unsafe.Pointer(&divisorOverrideVal))
|
|
cdivisorOverrideNull := *(*C.uint8_t)(unsafe.Pointer(&divisorOverrideNull))
|
|
C.atg_avg_pool2d_backward(ptr, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cceilMode, ccountIncludePad, cdivisorOverrideVal, cdivisorOverrideNull)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
ccountIncludePad := *(*C.int)(unsafe.Pointer(&countIncludePad))
|
|
cdivisorOverrideVal := *(*C.int64_t)(unsafe.Pointer(&divisorOverrideVal))
|
|
cdivisorOverrideNull := *(*C.uint8_t)(unsafe.Pointer(&divisorOverrideNull))
|
|
C.atg_avg_pool2d_backward_out(ptr, gradInput, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cceilMode, ccountIncludePad, cdivisorOverrideVal, cdivisorOverrideNull)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
ccountIncludePad := *(*C.int)(unsafe.Pointer(&countIncludePad))
|
|
cdivisorOverrideVal := *(*C.int64_t)(unsafe.Pointer(&divisorOverrideVal))
|
|
cdivisorOverrideNull := *(*C.uint8_t)(unsafe.Pointer(&divisorOverrideNull))
|
|
C.atg_avg_pool2d_out(ptr, out, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cceilMode, ccountIncludePad, cdivisorOverrideVal, cdivisorOverrideNull)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
ccountIncludePad := *(*C.int)(unsafe.Pointer(&countIncludePad))
|
|
cdivisorOverrideVal := *(*C.int64_t)(unsafe.Pointer(&divisorOverrideVal))
|
|
cdivisorOverrideNull := *(*C.uint8_t)(unsafe.Pointer(&divisorOverrideNull))
|
|
C.atg_avg_pool3d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cceilMode, ccountIncludePad, cdivisorOverrideVal, cdivisorOverrideNull)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
ccountIncludePad := *(*C.int)(unsafe.Pointer(&countIncludePad))
|
|
cdivisorOverrideVal := *(*C.int64_t)(unsafe.Pointer(&divisorOverrideVal))
|
|
cdivisorOverrideNull := *(*C.uint8_t)(unsafe.Pointer(&divisorOverrideNull))
|
|
C.atg_avg_pool3d_backward(ptr, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cceilMode, ccountIncludePad, cdivisorOverrideVal, cdivisorOverrideNull)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
ccountIncludePad := *(*C.int)(unsafe.Pointer(&countIncludePad))
|
|
cdivisorOverrideVal := *(*C.int64_t)(unsafe.Pointer(&divisorOverrideVal))
|
|
cdivisorOverrideNull := *(*C.uint8_t)(unsafe.Pointer(&divisorOverrideNull))
|
|
C.atg_avg_pool3d_backward_out(ptr, gradInput, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cceilMode, ccountIncludePad, cdivisorOverrideVal, cdivisorOverrideNull)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
ccountIncludePad := *(*C.int)(unsafe.Pointer(&countIncludePad))
|
|
cdivisorOverrideVal := *(*C.int64_t)(unsafe.Pointer(&divisorOverrideVal))
|
|
cdivisorOverrideNull := *(*C.uint8_t)(unsafe.Pointer(&divisorOverrideNull))
|
|
C.atg_avg_pool3d_out(ptr, out, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cceilMode, ccountIncludePad, cdivisorOverrideVal, cdivisorOverrideNull)
|
|
}
|
|
func AtgBaddbmm(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor){
|
|
C.atg_baddbmm(ptr, self, batch1, batch2)
|
|
}
|
|
func AtgBaddbmm_(ptr *Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor){
|
|
C.atg_baddbmm_(ptr, self, batch1, batch2)
|
|
}
|
|
func AtgBaddbmmOut(ptr *Ctensor, out Ctensor, self Ctensor, batch1 Ctensor, batch2 Ctensor){
|
|
C.atg_baddbmm_out(ptr, out, self, batch1, batch2)
|
|
}
|
|
func AtgBartlettWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_bartlett_window(ptr, cwindowLength, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgBartlettWindow1(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
cperiodic := *(*C.int)(unsafe.Pointer(&periodic))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_bartlett_window1(ptr, cwindowLength, cperiodic, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, momentum float64, eps float64, cudnnEnabled int32){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
cmomentum := *(*C.double)(unsafe.Pointer(&momentum))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
ccudnnEnabled := *(*C.int)(unsafe.Pointer(&cudnnEnabled))
|
|
C.atg_batch_norm(ptr, input, weight, bias, runningMean, runningVar, ctraining, cmomentum, ceps, ccudnnEnabled)
|
|
}
|
|
func AtgBatchNormBackwardElemt(ptr *Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, weight Ctensor, meanDy Ctensor, meanDyXmu Ctensor){
|
|
C.atg_batch_norm_backward_elemt(ptr, gradOut, input, mean, invstd, weight, meanDy, meanDyXmu)
|
|
}
|
|
func AtgBatchNormBackwardReduce(ptr *Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, weight Ctensor, inputG int32, weightG int32, biasG int32){
|
|
cinputG := *(*C.int)(unsafe.Pointer(&inputG))
|
|
cweightG := *(*C.int)(unsafe.Pointer(&weightG))
|
|
cbiasG := *(*C.int)(unsafe.Pointer(&biasG))
|
|
C.atg_batch_norm_backward_reduce(ptr, gradOut, input, mean, invstd, weight, cinputG, cweightG, cbiasG)
|
|
}
|
|
func AtgBatchNormElemt(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, mean Ctensor, invstd Ctensor, eps float64){
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
C.atg_batch_norm_elemt(ptr, input, weight, bias, mean, invstd, ceps)
|
|
}
|
|
func AtgBatchNormElemtOut(ptr *Ctensor, out Ctensor, input Ctensor, weight Ctensor, bias Ctensor, mean Ctensor, invstd Ctensor, eps float64){
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
C.atg_batch_norm_elemt_out(ptr, out, input, weight, bias, mean, invstd, ceps)
|
|
}
|
|
func AtgBatchNormGatherStats(ptr *Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, runningMean Ctensor, runningVar Ctensor, momentum float64, eps float64, count int64){
|
|
cmomentum := *(*C.double)(unsafe.Pointer(&momentum))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
ccount := *(*C.int64_t)(unsafe.Pointer(&count))
|
|
C.atg_batch_norm_gather_stats(ptr, input, mean, invstd, runningMean, runningVar, cmomentum, ceps, ccount)
|
|
}
|
|
func AtgBatchNormGatherStatsWithCounts(ptr *Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, runningMean Ctensor, runningVar Ctensor, momentum float64, eps float64, counts Ctensor){
|
|
cmomentum := *(*C.double)(unsafe.Pointer(&momentum))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
C.atg_batch_norm_gather_stats_with_counts(ptr, input, mean, invstd, runningMean, runningVar, cmomentum, ceps, counts)
|
|
}
|
|
func AtgBatchNormStats(ptr *Ctensor, input Ctensor, eps float64){
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
C.atg_batch_norm_stats(ptr, input, ceps)
|
|
}
|
|
func AtgBatchNormUpdateStats(ptr *Ctensor, input Ctensor, runningMean Ctensor, runningVar Ctensor, momentum float64){
|
|
cmomentum := *(*C.double)(unsafe.Pointer(&momentum))
|
|
C.atg_batch_norm_update_stats(ptr, input, runningMean, runningVar, cmomentum)
|
|
}
|
|
func AtgBernoulli(ptr *Ctensor, self Ctensor){
|
|
C.atg_bernoulli(ptr, self)
|
|
}
|
|
func AtgBernoulli1(ptr *Ctensor, self Ctensor, p float64){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
C.atg_bernoulli1(ptr, self, cp)
|
|
}
|
|
func AtgBernoulli_(ptr *Ctensor, self Ctensor, p Ctensor){
|
|
C.atg_bernoulli_(ptr, self, p)
|
|
}
|
|
func AtgBernoulli1_(ptr *Ctensor, self Ctensor, p float64){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
C.atg_bernoulli_1(ptr, self, cp)
|
|
}
|
|
func AtgBernoulliOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_bernoulli_out(ptr, out, self)
|
|
}
|
|
func AtgBilinear(ptr *Ctensor, input1 Ctensor, input2 Ctensor, weight Ctensor, bias Ctensor){
|
|
C.atg_bilinear(ptr, input1, input2, weight, bias)
|
|
}
|
|
func AtgBinaryCrossEntropy(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_binary_cross_entropy(ptr, self, target, weight, creduction)
|
|
}
|
|
func AtgBinaryCrossEntropyBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_binary_cross_entropy_backward(ptr, gradOutput, self, target, weight, creduction)
|
|
}
|
|
func AtgBinaryCrossEntropyBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_binary_cross_entropy_backward_out(ptr, gradInput, gradOutput, self, target, weight, creduction)
|
|
}
|
|
func AtgBinaryCrossEntropyOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_binary_cross_entropy_out(ptr, out, self, target, weight, creduction)
|
|
}
|
|
func AtgBinaryCrossEntropyWithLogits(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, posWeight Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_binary_cross_entropy_with_logits(ptr, self, target, weight, posWeight, creduction)
|
|
}
|
|
func AtgBinaryCrossEntropyWithLogitsBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, posWeight Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_binary_cross_entropy_with_logits_backward(ptr, gradOutput, self, target, weight, posWeight, creduction)
|
|
}
|
|
func AtgBincount(ptr *Ctensor, self Ctensor, weights Ctensor, minlength int64){
|
|
cminlength := *(*C.int64_t)(unsafe.Pointer(&minlength))
|
|
C.atg_bincount(ptr, self, weights, cminlength)
|
|
}
|
|
func AtgBinomial(ptr *Ctensor, count Ctensor, prob Ctensor){
|
|
C.atg_binomial(ptr, count, prob)
|
|
}
|
|
func AtgBitwiseAnd(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_bitwise_and(ptr, self, other )
|
|
}
|
|
func AtgBitwiseAnd1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_bitwise_and1(ptr, self, other)
|
|
}
|
|
func AtgBitwiseAnd_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_bitwise_and_(ptr, self, other )
|
|
}
|
|
func AtgBitwiseAnd1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_bitwise_and_1(ptr, self, other)
|
|
}
|
|
func AtgBitwiseAndOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_bitwise_and_out(ptr, out, self, other)
|
|
}
|
|
func AtgBitwiseAndOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_bitwise_and_out1(ptr, out, self, other )
|
|
}
|
|
func AtgBitwiseNot(ptr *Ctensor, self Ctensor){
|
|
C.atg_bitwise_not(ptr, self)
|
|
}
|
|
func AtgBitwiseNot_(ptr *Ctensor, self Ctensor){
|
|
C.atg_bitwise_not_(ptr, self)
|
|
}
|
|
func AtgBitwiseNotOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_bitwise_not_out(ptr, out, self)
|
|
}
|
|
func AtgBitwiseOr(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_bitwise_or(ptr, self, other )
|
|
}
|
|
func AtgBitwiseOr1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_bitwise_or1(ptr, self, other)
|
|
}
|
|
func AtgBitwiseOr_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_bitwise_or_(ptr, self, other )
|
|
}
|
|
func AtgBitwiseOr1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_bitwise_or_1(ptr, self, other)
|
|
}
|
|
func AtgBitwiseOrOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_bitwise_or_out(ptr, out, self, other)
|
|
}
|
|
func AtgBitwiseOrOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_bitwise_or_out1(ptr, out, self, other )
|
|
}
|
|
func AtgBitwiseXor(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_bitwise_xor(ptr, self, other )
|
|
}
|
|
func AtgBitwiseXor1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_bitwise_xor1(ptr, self, other)
|
|
}
|
|
func AtgBitwiseXor_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_bitwise_xor_(ptr, self, other )
|
|
}
|
|
func AtgBitwiseXor1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_bitwise_xor_1(ptr, self, other)
|
|
}
|
|
func AtgBitwiseXorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_bitwise_xor_out(ptr, out, self, other)
|
|
}
|
|
func AtgBitwiseXorOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_bitwise_xor_out1(ptr, out, self, other )
|
|
}
|
|
func AtgBlackmanWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_blackman_window(ptr, cwindowLength, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgBlackmanWindow1(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
cperiodic := *(*C.int)(unsafe.Pointer(&periodic))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_blackman_window1(ptr, cwindowLength, cperiodic, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgBlockDiag(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
C.atg_block_diag(ptr, ctensorsDataPtr, ctensorsLen)
|
|
}
|
|
func AtgBmm(ptr *Ctensor, self Ctensor, mat2 Ctensor){
|
|
C.atg_bmm(ptr, self, mat2)
|
|
}
|
|
func AtgBmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor){
|
|
C.atg_bmm_out(ptr, out, self, mat2)
|
|
}
|
|
|
|
func AtgBucketize(ptr *Ctensor, self Ctensor, boundaries Ctensor, outInt32 int32, right int32){
|
|
coutInt32 := *(*C.int)(unsafe.Pointer(&outInt32))
|
|
cright := *(*C.int)(unsafe.Pointer(&right))
|
|
C.atg_bucketize(ptr, self, boundaries, coutInt32, cright)
|
|
}
|
|
func AtgBucketize1(ptr *Ctensor, selfScalar Cscalar, boundaries Ctensor, outInt32 int32, right int32){
|
|
coutInt32 := *(*C.int)(unsafe.Pointer(&outInt32))
|
|
cright := *(*C.int)(unsafe.Pointer(&right))
|
|
C.atg_bucketize1(ptr, selfScalar , boundaries, coutInt32, cright)
|
|
}
|
|
func AtgBucketizeOut(ptr *Ctensor, out Ctensor, self Ctensor, boundaries Ctensor, outInt32 int32, right int32){
|
|
coutInt32 := *(*C.int)(unsafe.Pointer(&outInt32))
|
|
cright := *(*C.int)(unsafe.Pointer(&right))
|
|
C.atg_bucketize_out(ptr, out, self, boundaries, coutInt32, cright)
|
|
}
|
|
func AtgCartesianProd(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
C.atg_cartesian_prod(ptr, ctensorsDataPtr, ctensorsLen)
|
|
}
|
|
func AtgCat(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_cat(ptr, ctensorsDataPtr, ctensorsLen, cdim)
|
|
}
|
|
func AtgCatOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_cat_out(ptr, out, ctensorsDataPtr, ctensorsLen, cdim)
|
|
}
|
|
func AtgCauchy_(ptr *Ctensor, self Ctensor, median float64, sigma float64){
|
|
cmedian := *(*C.double)(unsafe.Pointer(&median))
|
|
csigma := *(*C.double)(unsafe.Pointer(&sigma))
|
|
C.atg_cauchy_(ptr, self, cmedian, csigma)
|
|
}
|
|
func AtgCdist(ptr *Ctensor, x1 Ctensor, x2 Ctensor, p float64, computeModeVal int64, computeModeNull int){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ccomputeModeVal := *(*C.int64_t)(unsafe.Pointer(&computeModeVal))
|
|
ccomputeModeNull := *(*C.uint8_t)(unsafe.Pointer(&computeModeNull))
|
|
C.atg_cdist(ptr, x1, x2, cp, ccomputeModeVal, ccomputeModeNull)
|
|
}
|
|
func AtgCeil(ptr *Ctensor, self Ctensor){
|
|
C.atg_ceil(ptr, self)
|
|
}
|
|
func AtgCeil_(ptr *Ctensor, self Ctensor){
|
|
C.atg_ceil_(ptr, self)
|
|
}
|
|
func AtgCeilOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_ceil_out(ptr, out, self)
|
|
}
|
|
func AtgCelu(ptr *Ctensor, self Ctensor){
|
|
C.atg_celu(ptr, self)
|
|
}
|
|
func AtgCelu_(ptr *Ctensor, self Ctensor){
|
|
C.atg_celu_(ptr, self)
|
|
}
|
|
func AtgChainMatmul(ptr *Ctensor, matricesData []Ctensor, matricesLen int){
|
|
cmatricesDataPtr := (*Ctensor)(unsafe.Pointer(&matricesData[0]))
|
|
cmatricesLen := *(*C.int)(unsafe.Pointer(&matricesLen))
|
|
C.atg_chain_matmul(ptr, cmatricesDataPtr, cmatricesLen)
|
|
}
|
|
func AtgChannelShuffle(ptr *Ctensor, self Ctensor, groups int64){
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
C.atg_channel_shuffle(ptr, self, cgroups)
|
|
}
|
|
func AtgCholesky(ptr *Ctensor, self Ctensor, upper int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg_cholesky(ptr, self, cupper)
|
|
}
|
|
func AtgCholeskyInverse(ptr *Ctensor, self Ctensor, upper int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg_cholesky_inverse(ptr, self, cupper)
|
|
}
|
|
func AtgCholeskyInverseOut(ptr *Ctensor, out Ctensor, self Ctensor, upper int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg_cholesky_inverse_out(ptr, out, self, cupper)
|
|
}
|
|
func AtgCholeskyOut(ptr *Ctensor, out Ctensor, self Ctensor, upper int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg_cholesky_out(ptr, out, self, cupper)
|
|
}
|
|
func AtgCholeskySolve(ptr *Ctensor, self Ctensor, input2 Ctensor, upper int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg_cholesky_solve(ptr, self, input2, cupper)
|
|
}
|
|
func AtgCholeskySolveOut(ptr *Ctensor, out Ctensor, self Ctensor, input2 Ctensor, upper int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg_cholesky_solve_out(ptr, out, self, input2, cupper)
|
|
}
|
|
|
|
func AtgClamp(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar){
|
|
C.atg_clamp(ptr, self, min , max )
|
|
}
|
|
func AtgClamp_(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar){
|
|
C.atg_clamp_(ptr, self, min , max )
|
|
}
|
|
func AtgClampMax(ptr *Ctensor, self Ctensor, max Cscalar){
|
|
C.atg_clamp_max(ptr, self, max )
|
|
}
|
|
func AtgClampMax_(ptr *Ctensor, self Ctensor, max Cscalar){
|
|
C.atg_clamp_max_(ptr, self, max )
|
|
}
|
|
func AtgClampMaxOut(ptr *Ctensor, out Ctensor, self Ctensor, max Cscalar){
|
|
C.atg_clamp_max_out(ptr, out, self, max )
|
|
}
|
|
func AtgClampMin(ptr *Ctensor, self Ctensor, min Cscalar){
|
|
C.atg_clamp_min(ptr, self, min )
|
|
}
|
|
func AtgClampMin_(ptr *Ctensor, self Ctensor, min Cscalar){
|
|
C.atg_clamp_min_(ptr, self, min )
|
|
}
|
|
func AtgClampMinOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar){
|
|
C.atg_clamp_min_out(ptr, out, self, min )
|
|
}
|
|
func AtgClampOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar, max Cscalar){
|
|
C.atg_clamp_out(ptr, out, self, min , max )
|
|
}
|
|
func AtgClip(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar){
|
|
C.atg_clip(ptr, self, min , max )
|
|
}
|
|
func AtgClip_(ptr *Ctensor, self Ctensor, min Cscalar, max Cscalar){
|
|
C.atg_clip_(ptr, self, min , max )
|
|
}
|
|
func AtgClipOut(ptr *Ctensor, out Ctensor, self Ctensor, min Cscalar, max Cscalar){
|
|
C.atg_clip_out(ptr, out, self, min , max )
|
|
}
|
|
func AtgCoalesce(ptr *Ctensor, self Ctensor){
|
|
C.atg_coalesce(ptr, self)
|
|
}
|
|
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){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
C.atg_col2im(ptr, self, coutputSizeDataPtr, coutputSizeLen, ckernelSizeDataPtr, ckernelSizeLen, cdilationDataPtr, cdilationLen, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen)
|
|
}
|
|
func AtgCol2imBackward(ptr *Ctensor, gradOutput Ctensor, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
C.atg_col2im_backward(ptr, gradOutput, ckernelSizeDataPtr, ckernelSizeLen, cdilationDataPtr, cdilationLen, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen)
|
|
}
|
|
func AtgCol2imBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
C.atg_col2im_backward_out(ptr, gradInput, gradOutput, ckernelSizeDataPtr, ckernelSizeLen, cdilationDataPtr, cdilationLen, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen)
|
|
}
|
|
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){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
C.atg_col2im_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen, ckernelSizeDataPtr, ckernelSizeLen, cdilationDataPtr, cdilationLen, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen)
|
|
}
|
|
func AtgCombinations(ptr *Ctensor, self Ctensor, r int64, withReplacement int32){
|
|
cr := *(*C.int64_t)(unsafe.Pointer(&r))
|
|
cwithReplacement := *(*C.int)(unsafe.Pointer(&withReplacement))
|
|
C.atg_combinations(ptr, self, cr, cwithReplacement)
|
|
}
|
|
func AtgComplex(ptr *Ctensor, real Ctensor, imag Ctensor){
|
|
C.atg_complex(ptr, real, imag)
|
|
}
|
|
func AtgComplexOut(ptr *Ctensor, out Ctensor, real Ctensor, imag Ctensor){
|
|
C.atg_complex_out(ptr, out, real, imag)
|
|
}
|
|
func AtgConj(ptr *Ctensor, self Ctensor){
|
|
C.atg_conj(ptr, self)
|
|
}
|
|
func AtgConjOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_conj_out(ptr, out, self)
|
|
}
|
|
func AtgConstantPadNd(ptr *Ctensor, self Ctensor, padData []int64, padLen int){
|
|
cpadDataPtr := (*C.int64_t)(unsafe.Pointer(&padData[0]))
|
|
cpadLen := *(*C.int)(unsafe.Pointer(&padLen))
|
|
C.atg_constant_pad_nd(ptr, self, cpadDataPtr, cpadLen)
|
|
}
|
|
func AtgContiguous(ptr *Ctensor, self Ctensor){
|
|
C.atg_contiguous(ptr, self)
|
|
}
|
|
func AtgConv1d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, groups int64){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
C.atg_conv1d(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cgroups)
|
|
}
|
|
func AtgConv2d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, groups int64){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
C.atg_conv2d(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cgroups)
|
|
}
|
|
func AtgConv3d(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, groups int64){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
C.atg_conv3d(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cgroups)
|
|
}
|
|
func AtgConvTbc(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, pad int64){
|
|
cpad := *(*C.int64_t)(unsafe.Pointer(&pad))
|
|
C.atg_conv_tbc(ptr, self, weight, bias, cpad)
|
|
}
|
|
func AtgConvTbcBackward(ptr *Ctensor, self Ctensor, input Ctensor, weight Ctensor, bias Ctensor, pad int64){
|
|
cpad := *(*C.int64_t)(unsafe.Pointer(&pad))
|
|
C.atg_conv_tbc_backward(ptr, self, input, weight, bias, cpad)
|
|
}
|
|
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){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
C.atg_conv_transpose1d(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cgroups, cdilationDataPtr, cdilationLen)
|
|
}
|
|
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){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
C.atg_conv_transpose2d(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cgroups, cdilationDataPtr, cdilationLen)
|
|
}
|
|
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){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
C.atg_conv_transpose3d(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cgroups, cdilationDataPtr, cdilationLen)
|
|
}
|
|
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){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
ctransposed := *(*C.int)(unsafe.Pointer(&transposed))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
C.atg_convolution(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, ctransposed, coutputPaddingDataPtr, coutputPaddingLen, cgroups)
|
|
}
|
|
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){
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
ctransposed := *(*C.int)(unsafe.Pointer(&transposed))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
C.atg_convolution_overrideable(ptr, input, weight, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, ctransposed, coutputPaddingDataPtr, coutputPaddingLen, cgroups)
|
|
}
|
|
func AtgCopySparseToSparse_(ptr *Ctensor, self Ctensor, src Ctensor, nonBlocking int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
C.atg_copy_sparse_to_sparse_(ptr, self, src, cnonBlocking)
|
|
}
|
|
func AtgCos(ptr *Ctensor, self Ctensor){
|
|
C.atg_cos(ptr, self)
|
|
}
|
|
func AtgCos_(ptr *Ctensor, self Ctensor){
|
|
C.atg_cos_(ptr, self)
|
|
}
|
|
func AtgCosOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_cos_out(ptr, out, self)
|
|
}
|
|
func AtgCosh(ptr *Ctensor, self Ctensor){
|
|
C.atg_cosh(ptr, self)
|
|
}
|
|
func AtgCosh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_cosh_(ptr, self)
|
|
}
|
|
func AtgCoshOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_cosh_out(ptr, out, self)
|
|
}
|
|
func AtgCosineEmbeddingLoss(ptr *Ctensor, input1 Ctensor, input2 Ctensor, target Ctensor, margin float64, reduction int64){
|
|
cmargin := *(*C.double)(unsafe.Pointer(&margin))
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_cosine_embedding_loss(ptr, input1, input2, target, cmargin, creduction)
|
|
}
|
|
func AtgCosineSimilarity(ptr *Ctensor, x1 Ctensor, x2 Ctensor, dim int64, eps float64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
C.atg_cosine_similarity(ptr, x1, x2, cdim, ceps)
|
|
}
|
|
func AtgCountNonzero(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
C.atg_count_nonzero(ptr, self, cdimDataPtr, cdimLen)
|
|
}
|
|
func AtgCountNonzero1(ptr *Ctensor, self Ctensor, dimVal int64, dimNull int){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
C.atg_count_nonzero1(ptr, self, cdimVal, cdimNull)
|
|
}
|
|
func AtgCross(ptr *Ctensor, self Ctensor, other Ctensor, dimVal int64, dimNull int){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
C.atg_cross(ptr, self, other, cdimVal, cdimNull)
|
|
}
|
|
func AtgCrossOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor, dimVal int64, dimNull int){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
C.atg_cross_out(ptr, out, self, other, cdimVal, cdimNull)
|
|
}
|
|
func AtgCtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, inputLengthsLen int, targetLengthsData []int64, targetLengthsLen int, blank int64, reduction int64, zeroInfinity int32){
|
|
cinputLengthsDataPtr := (*C.int64_t)(unsafe.Pointer(&inputLengthsData[0]))
|
|
cinputLengthsLen := *(*C.int)(unsafe.Pointer(&inputLengthsLen))
|
|
ctargetLengthsDataPtr := (*C.int64_t)(unsafe.Pointer(&targetLengthsData[0]))
|
|
ctargetLengthsLen := *(*C.int)(unsafe.Pointer(&targetLengthsLen))
|
|
cblank := *(*C.int64_t)(unsafe.Pointer(&blank))
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
czeroInfinity := *(*C.int)(unsafe.Pointer(&zeroInfinity))
|
|
C.atg_ctc_loss(ptr, logProbs, targets, cinputLengthsDataPtr, cinputLengthsLen, ctargetLengthsDataPtr, ctargetLengthsLen, cblank, creduction, czeroInfinity)
|
|
}
|
|
func AtgCtcLoss1(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengths Ctensor, targetLengths Ctensor, blank int64, reduction int64, zeroInfinity int32){
|
|
cblank := *(*C.int64_t)(unsafe.Pointer(&blank))
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
czeroInfinity := *(*C.int)(unsafe.Pointer(&zeroInfinity))
|
|
C.atg_ctc_loss1(ptr, logProbs, targets, inputLengths, targetLengths, cblank, creduction, czeroInfinity)
|
|
}
|
|
func AtgCudnnAffineGridGenerator(ptr *Ctensor, theta Ctensor, n int64, c int64, h int64, w int64){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
cc := *(*C.int64_t)(unsafe.Pointer(&c))
|
|
ch := *(*C.int64_t)(unsafe.Pointer(&h))
|
|
cw := *(*C.int64_t)(unsafe.Pointer(&w))
|
|
C.atg_cudnn_affine_grid_generator(ptr, theta, cn, cc, ch, cw)
|
|
}
|
|
func AtgCudnnAffineGridGeneratorBackward(ptr *Ctensor, grad Ctensor, n int64, c int64, h int64, w int64){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
cc := *(*C.int64_t)(unsafe.Pointer(&c))
|
|
ch := *(*C.int64_t)(unsafe.Pointer(&h))
|
|
cw := *(*C.int64_t)(unsafe.Pointer(&w))
|
|
C.atg_cudnn_affine_grid_generator_backward(ptr, grad, cn, cc, ch, cw)
|
|
}
|
|
func AtgCudnnBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, exponentialAverageFactor float64, epsilon float64){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
cexponentialAverageFactor := *(*C.double)(unsafe.Pointer(&exponentialAverageFactor))
|
|
cepsilon := *(*C.double)(unsafe.Pointer(&epsilon))
|
|
C.atg_cudnn_batch_norm(ptr, input, weight, bias, runningMean, runningVar, ctraining, cexponentialAverageFactor, cepsilon)
|
|
}
|
|
func AtgCudnnBatchNormBackward(ptr *Ctensor, input Ctensor, gradOutput Ctensor, weight Ctensor, runningMean Ctensor, runningVar Ctensor, saveMean Ctensor, saveVar Ctensor, epsilon float64, reserveSpace Ctensor){
|
|
cepsilon := *(*C.double)(unsafe.Pointer(&epsilon))
|
|
C.atg_cudnn_batch_norm_backward(ptr, input, gradOutput, weight, runningMean, runningVar, saveMean, saveVar, cepsilon, reserveSpace)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_cudnn_convolution(ptr, self, weight, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_cudnn_convolution1(ptr, self, weight, bias, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
callowTf32 := *(*C.int)(unsafe.Pointer(&allowTf32))
|
|
C.atg_cudnn_convolution2(ptr, self, weight, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic, callowTf32)
|
|
}
|
|
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){
|
|
cselfSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&selfSizeData[0]))
|
|
cselfSizeLen := *(*C.int)(unsafe.Pointer(&selfSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
callowTf32 := *(*C.int)(unsafe.Pointer(&allowTf32))
|
|
C.atg_cudnn_convolution_backward_input(ptr, cselfSizeDataPtr, cselfSizeLen, gradOutput, weight, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic, callowTf32)
|
|
}
|
|
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){
|
|
cweightSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&weightSizeData[0]))
|
|
cweightSizeLen := *(*C.int)(unsafe.Pointer(&weightSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
callowTf32 := *(*C.int)(unsafe.Pointer(&allowTf32))
|
|
C.atg_cudnn_convolution_backward_weight(ptr, cweightSizeDataPtr, cweightSizeLen, gradOutput, self, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic, callowTf32)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_cudnn_convolution_transpose(ptr, self, weight, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_cudnn_convolution_transpose1(ptr, self, weight, bias, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
callowTf32 := *(*C.int)(unsafe.Pointer(&allowTf32))
|
|
C.atg_cudnn_convolution_transpose2(ptr, self, weight, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic, callowTf32)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
callowTf32 := *(*C.int)(unsafe.Pointer(&allowTf32))
|
|
C.atg_cudnn_convolution_transpose_backward_input(ptr, gradOutput, weight, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic, callowTf32)
|
|
}
|
|
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){
|
|
cweightSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&weightSizeData[0]))
|
|
cweightSizeLen := *(*C.int)(unsafe.Pointer(&weightSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
callowTf32 := *(*C.int)(unsafe.Pointer(&allowTf32))
|
|
C.atg_cudnn_convolution_transpose_backward_weight(ptr, cweightSizeDataPtr, cweightSizeLen, gradOutput, self, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic, callowTf32)
|
|
}
|
|
func AtgCudnnGridSampler(ptr *Ctensor, self Ctensor, grid Ctensor){
|
|
C.atg_cudnn_grid_sampler(ptr, self, grid)
|
|
}
|
|
func AtgCudnnGridSamplerBackward(ptr *Ctensor, self Ctensor, grid Ctensor, gradOutput Ctensor){
|
|
C.atg_cudnn_grid_sampler_backward(ptr, self, grid, gradOutput)
|
|
}
|
|
func AtgCummax(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_cummax(ptr, self, cdim)
|
|
}
|
|
func AtgCummaxOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_cummax_out(ptr, values, indices, self, cdim)
|
|
}
|
|
func AtgCummaxminBackward(ptr *Ctensor, grad Ctensor, input Ctensor, indices Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_cummaxmin_backward(ptr, grad, input, indices, cdim)
|
|
}
|
|
func AtgCummin(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_cummin(ptr, self, cdim)
|
|
}
|
|
func AtgCumminOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_cummin_out(ptr, values, indices, self, cdim)
|
|
}
|
|
func AtgCumprod(ptr *Ctensor, self Ctensor, dim int64, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_cumprod(ptr, self, cdim, cdtype)
|
|
}
|
|
func AtgCumprodBackward(ptr *Ctensor, grad Ctensor, input Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_cumprod_backward(ptr, grad, input, cdim)
|
|
}
|
|
func AtgCumprodOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_cumprod_out(ptr, out, self, cdim, cdtype)
|
|
}
|
|
func AtgCumsum(ptr *Ctensor, self Ctensor, dim int64, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_cumsum(ptr, self, cdim, cdtype)
|
|
}
|
|
func AtgCumsumOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_cumsum_out(ptr, out, self, cdim, cdtype)
|
|
}
|
|
func AtgData(ptr *Ctensor, self Ctensor){
|
|
C.atg_data(ptr, self)
|
|
}
|
|
func AtgDeg2rad(ptr *Ctensor, self Ctensor){
|
|
C.atg_deg2rad(ptr, self)
|
|
}
|
|
func AtgDeg2rad_(ptr *Ctensor, self Ctensor){
|
|
C.atg_deg2rad_(ptr, self)
|
|
}
|
|
func AtgDeg2radOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_deg2rad_out(ptr, out, self)
|
|
}
|
|
func AtgDequantize(ptr *Ctensor, self Ctensor){
|
|
C.atg_dequantize(ptr, self)
|
|
}
|
|
|
|
func AtgDet(ptr *Ctensor, self Ctensor){
|
|
C.atg_det(ptr, self)
|
|
}
|
|
func AtgDetach(ptr *Ctensor, self Ctensor){
|
|
C.atg_detach(ptr, self)
|
|
}
|
|
func AtgDetach_(ptr *Ctensor, self Ctensor){
|
|
C.atg_detach_(ptr, self)
|
|
}
|
|
func AtgDiag(ptr *Ctensor, self Ctensor, diagonal int64){
|
|
cdiagonal := *(*C.int64_t)(unsafe.Pointer(&diagonal))
|
|
C.atg_diag(ptr, self, cdiagonal)
|
|
}
|
|
func AtgDiagBackward(ptr *Ctensor, grad Ctensor, inputSizesData []int64, inputSizesLen int, diagonal int64){
|
|
cinputSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizesData[0]))
|
|
cinputSizesLen := *(*C.int)(unsafe.Pointer(&inputSizesLen))
|
|
cdiagonal := *(*C.int64_t)(unsafe.Pointer(&diagonal))
|
|
C.atg_diag_backward(ptr, grad, cinputSizesDataPtr, cinputSizesLen, cdiagonal)
|
|
}
|
|
func AtgDiagEmbed(ptr *Ctensor, self Ctensor, offset int64, dim1 int64, dim2 int64){
|
|
coffset := *(*C.int64_t)(unsafe.Pointer(&offset))
|
|
cdim1 := *(*C.int64_t)(unsafe.Pointer(&dim1))
|
|
cdim2 := *(*C.int64_t)(unsafe.Pointer(&dim2))
|
|
C.atg_diag_embed(ptr, self, coffset, cdim1, cdim2)
|
|
}
|
|
func AtgDiagOut(ptr *Ctensor, out Ctensor, self Ctensor, diagonal int64){
|
|
cdiagonal := *(*C.int64_t)(unsafe.Pointer(&diagonal))
|
|
C.atg_diag_out(ptr, out, self, cdiagonal)
|
|
}
|
|
func AtgDiagflat(ptr *Ctensor, self Ctensor, offset int64){
|
|
coffset := *(*C.int64_t)(unsafe.Pointer(&offset))
|
|
C.atg_diagflat(ptr, self, coffset)
|
|
}
|
|
func AtgDiagonal(ptr *Ctensor, self Ctensor, offset int64, dim1 int64, dim2 int64){
|
|
coffset := *(*C.int64_t)(unsafe.Pointer(&offset))
|
|
cdim1 := *(*C.int64_t)(unsafe.Pointer(&dim1))
|
|
cdim2 := *(*C.int64_t)(unsafe.Pointer(&dim2))
|
|
C.atg_diagonal(ptr, self, coffset, cdim1, cdim2)
|
|
}
|
|
func AtgDiagonalBackward(ptr *Ctensor, grad Ctensor, inputSizesData []int64, inputSizesLen int, offset int64, dim1 int64, dim2 int64){
|
|
cinputSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizesData[0]))
|
|
cinputSizesLen := *(*C.int)(unsafe.Pointer(&inputSizesLen))
|
|
coffset := *(*C.int64_t)(unsafe.Pointer(&offset))
|
|
cdim1 := *(*C.int64_t)(unsafe.Pointer(&dim1))
|
|
cdim2 := *(*C.int64_t)(unsafe.Pointer(&dim2))
|
|
C.atg_diagonal_backward(ptr, grad, cinputSizesDataPtr, cinputSizesLen, coffset, cdim1, cdim2)
|
|
}
|
|
func AtgDigamma(ptr *Ctensor, self Ctensor){
|
|
C.atg_digamma(ptr, self)
|
|
}
|
|
func AtgDigamma_(ptr *Ctensor, self Ctensor){
|
|
C.atg_digamma_(ptr, self)
|
|
}
|
|
func AtgDigammaOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_digamma_out(ptr, out, self)
|
|
}
|
|
func AtgDist(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_dist(ptr, self, other)
|
|
}
|
|
func AtgDiv(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_div(ptr, self, other)
|
|
}
|
|
func AtgDiv1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_div1(ptr, self, other )
|
|
}
|
|
func AtgDiv_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_div_(ptr, self, other)
|
|
}
|
|
func AtgDiv1_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_div_1(ptr, self, other )
|
|
}
|
|
func AtgDivOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_div_out(ptr, out, self, other)
|
|
}
|
|
func AtgDivide(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_divide(ptr, self, other)
|
|
}
|
|
func AtgDivide1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_divide1(ptr, self, other )
|
|
}
|
|
func AtgDivide_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_divide_(ptr, self, other)
|
|
}
|
|
func AtgDivide1_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_divide_1(ptr, self, other )
|
|
}
|
|
func AtgDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_divide_out(ptr, out, self, other)
|
|
}
|
|
func AtgDot(ptr *Ctensor, self Ctensor, tensor Ctensor){
|
|
C.atg_dot(ptr, self, tensor)
|
|
}
|
|
func AtgDotOut(ptr *Ctensor, out Ctensor, self Ctensor, tensor Ctensor){
|
|
C.atg_dot_out(ptr, out, self, tensor)
|
|
}
|
|
func AtgDropout(ptr *Ctensor, input Ctensor, p float64, train int32){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
C.atg_dropout(ptr, input, cp, ctrain)
|
|
}
|
|
func AtgDropout_(ptr *Ctensor, self Ctensor, p float64, train int32){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
C.atg_dropout_(ptr, self, cp, ctrain)
|
|
}
|
|
func AtgDstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
C.atg_dstack(ptr, ctensorsDataPtr, ctensorsLen)
|
|
}
|
|
func AtgDstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
C.atg_dstack_out(ptr, out, ctensorsDataPtr, ctensorsLen)
|
|
}
|
|
func AtgEig(ptr *Ctensor, self Ctensor, eigenvectors int32){
|
|
ceigenvectors := *(*C.int)(unsafe.Pointer(&eigenvectors))
|
|
C.atg_eig(ptr, self, ceigenvectors)
|
|
}
|
|
func AtgEigOut(ptr *Ctensor, e Ctensor, v Ctensor, self Ctensor, eigenvectors int32){
|
|
ceigenvectors := *(*C.int)(unsafe.Pointer(&eigenvectors))
|
|
C.atg_eig_out(ptr, e, v, self, ceigenvectors)
|
|
}
|
|
func AtgEinsum(ptr *Ctensor, equation string, tensorsData []Ctensor, tensorsLen int){
|
|
cequation := C.CString(equation)
|
|
equationLen := len(equation)
|
|
cequationLen := *(*C.int)(unsafe.Pointer(&equationLen))
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
C.atg_einsum(ptr, cequation, cequationLen, ctensorsDataPtr, ctensorsLen)
|
|
}
|
|
func AtgElu(ptr *Ctensor, self Ctensor){
|
|
C.atg_elu(ptr, self)
|
|
}
|
|
func AtgElu_(ptr *Ctensor, self Ctensor){
|
|
C.atg_elu_(ptr, self)
|
|
}
|
|
func AtgEluBackward(ptr *Ctensor, gradOutput Ctensor, alpha Cscalar, scale Cscalar, inputScale Cscalar, output Ctensor){
|
|
C.atg_elu_backward(ptr, gradOutput, alpha , scale , inputScale , output)
|
|
}
|
|
func AtgEluBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, alpha Cscalar, scale Cscalar, inputScale Cscalar, output Ctensor){
|
|
C.atg_elu_backward_out(ptr, gradInput, gradOutput, alpha , scale , inputScale , output)
|
|
}
|
|
func AtgEluOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_elu_out(ptr, out, self)
|
|
}
|
|
func AtgEmbedding(ptr *Ctensor, weight Ctensor, indices Ctensor, paddingIdx int64, scaleGradByFreq int32, sparse int32){
|
|
cpaddingIdx := *(*C.int64_t)(unsafe.Pointer(&paddingIdx))
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
csparse := *(*C.int)(unsafe.Pointer(&sparse))
|
|
C.atg_embedding(ptr, weight, indices, cpaddingIdx, cscaleGradByFreq, csparse)
|
|
}
|
|
func AtgEmbeddingBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, numWeights int64, paddingIdx int64, scaleGradByFreq int32, sparse int32){
|
|
cnumWeights := *(*C.int64_t)(unsafe.Pointer(&numWeights))
|
|
cpaddingIdx := *(*C.int64_t)(unsafe.Pointer(&paddingIdx))
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
csparse := *(*C.int)(unsafe.Pointer(&sparse))
|
|
C.atg_embedding_backward(ptr, grad, indices, cnumWeights, cpaddingIdx, cscaleGradByFreq, csparse)
|
|
}
|
|
func AtgEmbeddingBag(ptr *Ctensor, weight Ctensor, indices Ctensor, offsets Ctensor, scaleGradByFreq int32, mode int64, sparse int32, perSampleWeights Ctensor, includeLastOffset int32){
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
csparse := *(*C.int)(unsafe.Pointer(&sparse))
|
|
cincludeLastOffset := *(*C.int)(unsafe.Pointer(&includeLastOffset))
|
|
C.atg_embedding_bag(ptr, weight, indices, offsets, cscaleGradByFreq, cmode, csparse, perSampleWeights, cincludeLastOffset)
|
|
}
|
|
func AtgEmbeddingDenseBackward(ptr *Ctensor, gradOutput Ctensor, indices Ctensor, numWeights int64, paddingIdx int64, scaleGradByFreq int32){
|
|
cnumWeights := *(*C.int64_t)(unsafe.Pointer(&numWeights))
|
|
cpaddingIdx := *(*C.int64_t)(unsafe.Pointer(&paddingIdx))
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
C.atg_embedding_dense_backward(ptr, gradOutput, indices, cnumWeights, cpaddingIdx, cscaleGradByFreq)
|
|
}
|
|
func AtgEmbeddingRenorm_(ptr *Ctensor, self Ctensor, indices Ctensor, maxNorm float64, normType float64){
|
|
cmaxNorm := *(*C.double)(unsafe.Pointer(&maxNorm))
|
|
cnormType := *(*C.double)(unsafe.Pointer(&normType))
|
|
C.atg_embedding_renorm_(ptr, self, indices, cmaxNorm, cnormType)
|
|
}
|
|
func AtgEmbeddingSparseBackward(ptr *Ctensor, grad Ctensor, indices Ctensor, numWeights int64, paddingIdx int64, scaleGradByFreq int32){
|
|
cnumWeights := *(*C.int64_t)(unsafe.Pointer(&numWeights))
|
|
cpaddingIdx := *(*C.int64_t)(unsafe.Pointer(&paddingIdx))
|
|
cscaleGradByFreq := *(*C.int)(unsafe.Pointer(&scaleGradByFreq))
|
|
C.atg_embedding_sparse_backward(ptr, grad, indices, cnumWeights, cpaddingIdx, cscaleGradByFreq)
|
|
}
|
|
func AtgEmpty(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_empty(ptr, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgEmptyLike(ptr *Ctensor, self Ctensor){
|
|
C.atg_empty_like(ptr, self)
|
|
}
|
|
func AtgEmptyMeta(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_empty_meta(ptr, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgEmptyOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_empty_out(ptr, out, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgEmptyQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, qtensor Ctensor){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_empty_quantized(ptr, csizeDataPtr, csizeLen, qtensor)
|
|
}
|
|
func AtgEmptyStrided(ptr *Ctensor, sizeData []int64, sizeLen int, strideData []int64, strideLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_empty_strided(ptr, csizeDataPtr, csizeLen, cstrideDataPtr, cstrideLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgEq(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_eq(ptr, self, other )
|
|
}
|
|
func AtgEq1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_eq1(ptr, self, other)
|
|
}
|
|
func AtgEq_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_eq_(ptr, self, other )
|
|
}
|
|
func AtgEq1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_eq_1(ptr, self, other)
|
|
}
|
|
func AtgEqOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_eq_out(ptr, out, self, other )
|
|
}
|
|
func AtgEqOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_eq_out1(ptr, out, self, other)
|
|
}
|
|
func AtgErf(ptr *Ctensor, self Ctensor){
|
|
C.atg_erf(ptr, self)
|
|
}
|
|
func AtgErf_(ptr *Ctensor, self Ctensor){
|
|
C.atg_erf_(ptr, self)
|
|
}
|
|
func AtgErfOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_erf_out(ptr, out, self)
|
|
}
|
|
func AtgErfc(ptr *Ctensor, self Ctensor){
|
|
C.atg_erfc(ptr, self)
|
|
}
|
|
func AtgErfc_(ptr *Ctensor, self Ctensor){
|
|
C.atg_erfc_(ptr, self)
|
|
}
|
|
func AtgErfcOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_erfc_out(ptr, out, self)
|
|
}
|
|
func AtgErfinv(ptr *Ctensor, self Ctensor){
|
|
C.atg_erfinv(ptr, self)
|
|
}
|
|
func AtgErfinv_(ptr *Ctensor, self Ctensor){
|
|
C.atg_erfinv_(ptr, self)
|
|
}
|
|
func AtgErfinvOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_erfinv_out(ptr, out, self)
|
|
}
|
|
func AtgExp(ptr *Ctensor, self Ctensor){
|
|
C.atg_exp(ptr, self)
|
|
}
|
|
func AtgExp2(ptr *Ctensor, self Ctensor){
|
|
C.atg_exp2(ptr, self)
|
|
}
|
|
func AtgExp2_(ptr *Ctensor, self Ctensor){
|
|
C.atg_exp2_(ptr, self)
|
|
}
|
|
func AtgExp2Out(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_exp2_out(ptr, out, self)
|
|
}
|
|
func AtgExp_(ptr *Ctensor, self Ctensor){
|
|
C.atg_exp_(ptr, self)
|
|
}
|
|
func AtgExpOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_exp_out(ptr, out, self)
|
|
}
|
|
func AtgExpand(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, implicit int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
cimplicit := *(*C.int)(unsafe.Pointer(&implicit))
|
|
C.atg_expand(ptr, self, csizeDataPtr, csizeLen, cimplicit)
|
|
}
|
|
func AtgExpandAs(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_expand_as(ptr, self, other)
|
|
}
|
|
func AtgExpm1(ptr *Ctensor, self Ctensor){
|
|
C.atg_expm1(ptr, self)
|
|
}
|
|
func AtgExpm1_(ptr *Ctensor, self Ctensor){
|
|
C.atg_expm1_(ptr, self)
|
|
}
|
|
func AtgExpm1Out(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_expm1_out(ptr, out, self)
|
|
}
|
|
func AtgExponential_(ptr *Ctensor, self Ctensor, lambd float64){
|
|
clambd := *(*C.double)(unsafe.Pointer(&lambd))
|
|
C.atg_exponential_(ptr, self, clambd)
|
|
}
|
|
func AtgEye(ptr *Ctensor, n int64, optionsKind int32, optionsDevice int32){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_eye(ptr, cn, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgEye1(ptr *Ctensor, n int64, m int64, optionsKind int32, optionsDevice int32){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
cm := *(*C.int64_t)(unsafe.Pointer(&m))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_eye1(ptr, cn, cm, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgEyeOut(ptr *Ctensor, out Ctensor, n int64){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
C.atg_eye_out(ptr, out, cn)
|
|
}
|
|
func AtgEyeOut1(ptr *Ctensor, out Ctensor, n int64, m int64){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
cm := *(*C.int64_t)(unsafe.Pointer(&m))
|
|
C.atg_eye_out1(ptr, out, cn, cm)
|
|
}
|
|
func AtgFakeQuantizePerChannelAffine(ptr *Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, quantMin int64, quantMax int64){
|
|
caxis := *(*C.int64_t)(unsafe.Pointer(&axis))
|
|
cquantMin := *(*C.int64_t)(unsafe.Pointer(&quantMin))
|
|
cquantMax := *(*C.int64_t)(unsafe.Pointer(&quantMax))
|
|
C.atg_fake_quantize_per_channel_affine(ptr, self, scale, zeroPoint, caxis, cquantMin, cquantMax)
|
|
}
|
|
func AtgFakeQuantizePerChannelAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale Ctensor, zeroPoint Ctensor, axis int64, quantMin int64, quantMax int64){
|
|
caxis := *(*C.int64_t)(unsafe.Pointer(&axis))
|
|
cquantMin := *(*C.int64_t)(unsafe.Pointer(&quantMin))
|
|
cquantMax := *(*C.int64_t)(unsafe.Pointer(&quantMax))
|
|
C.atg_fake_quantize_per_channel_affine_backward(ptr, grad, self, scale, zeroPoint, caxis, cquantMin, cquantMax)
|
|
}
|
|
func AtgFakeQuantizePerTensorAffine(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64, quantMin int64, quantMax int64){
|
|
cscale := *(*C.double)(unsafe.Pointer(&scale))
|
|
czeroPoint := *(*C.int64_t)(unsafe.Pointer(&zeroPoint))
|
|
cquantMin := *(*C.int64_t)(unsafe.Pointer(&quantMin))
|
|
cquantMax := *(*C.int64_t)(unsafe.Pointer(&quantMax))
|
|
C.atg_fake_quantize_per_tensor_affine(ptr, self, cscale, czeroPoint, cquantMin, cquantMax)
|
|
}
|
|
func AtgFakeQuantizePerTensorAffineBackward(ptr *Ctensor, grad Ctensor, self Ctensor, scale float64, zeroPoint int64, quantMin int64, quantMax int64){
|
|
cscale := *(*C.double)(unsafe.Pointer(&scale))
|
|
czeroPoint := *(*C.int64_t)(unsafe.Pointer(&zeroPoint))
|
|
cquantMin := *(*C.int64_t)(unsafe.Pointer(&quantMin))
|
|
cquantMax := *(*C.int64_t)(unsafe.Pointer(&quantMax))
|
|
C.atg_fake_quantize_per_tensor_affine_backward(ptr, grad, self, cscale, czeroPoint, cquantMin, cquantMax)
|
|
}
|
|
func AtgFbgemmLinearFp16Weight(ptr *Ctensor, input Ctensor, packedWeight Ctensor, bias Ctensor){
|
|
C.atg_fbgemm_linear_fp16_weight(ptr, input, packedWeight, bias)
|
|
}
|
|
func AtgFbgemmLinearFp16WeightFp32Activation(ptr *Ctensor, input Ctensor, packedWeight Ctensor, bias Ctensor){
|
|
C.atg_fbgemm_linear_fp16_weight_fp32_activation(ptr, input, packedWeight, bias)
|
|
}
|
|
func AtgFbgemmLinearInt8Weight(ptr *Ctensor, input Ctensor, weight Ctensor, packed Ctensor, colOffsets Ctensor, weightScale Cscalar, weightZeroPoint Cscalar, bias Ctensor){
|
|
C.atg_fbgemm_linear_int8_weight(ptr, input, weight, packed, colOffsets, weightScale , weightZeroPoint , bias)
|
|
}
|
|
func AtgFbgemmLinearInt8WeightFp32Activation(ptr *Ctensor, input Ctensor, weight Ctensor, packed Ctensor, colOffsets Ctensor, weightScale Cscalar, weightZeroPoint Cscalar, bias Ctensor){
|
|
C.atg_fbgemm_linear_int8_weight_fp32_activation(ptr, input, weight, packed, colOffsets, weightScale , weightZeroPoint , bias)
|
|
}
|
|
func AtgFbgemmPackGemmMatrixFp16(ptr *Ctensor, input Ctensor){
|
|
C.atg_fbgemm_pack_gemm_matrix_fp16(ptr, input)
|
|
}
|
|
func AtgFbgemmPackQuantizedMatrix(ptr *Ctensor, input Ctensor){
|
|
C.atg_fbgemm_pack_quantized_matrix(ptr, input)
|
|
}
|
|
func AtgFbgemmPackQuantizedMatrix1(ptr *Ctensor, input Ctensor, k int64, n int64){
|
|
ck := *(*C.int64_t)(unsafe.Pointer(&k))
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
C.atg_fbgemm_pack_quantized_matrix1(ptr, input, ck, cn)
|
|
}
|
|
func AtgFeatureAlphaDropout(ptr *Ctensor, input Ctensor, p float64, train int32){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
C.atg_feature_alpha_dropout(ptr, input, cp, ctrain)
|
|
}
|
|
func AtgFeatureAlphaDropout_(ptr *Ctensor, self Ctensor, p float64, train int32){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
C.atg_feature_alpha_dropout_(ptr, self, cp, ctrain)
|
|
}
|
|
func AtgFeatureDropout(ptr *Ctensor, input Ctensor, p float64, train int32){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
C.atg_feature_dropout(ptr, input, cp, ctrain)
|
|
}
|
|
func AtgFeatureDropout_(ptr *Ctensor, self Ctensor, p float64, train int32){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
C.atg_feature_dropout_(ptr, self, cp, ctrain)
|
|
}
|
|
func AtgFft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32){
|
|
csignalNdim := *(*C.int64_t)(unsafe.Pointer(&signalNdim))
|
|
cnormalized := *(*C.int)(unsafe.Pointer(&normalized))
|
|
C.atg_fft(ptr, self, csignalNdim, cnormalized)
|
|
}
|
|
func AtgFftFft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string){
|
|
cnVal := *(*C.int64_t)(unsafe.Pointer(&nVal))
|
|
cnNull := *(*C.uint8_t)(unsafe.Pointer(&nNull))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_fft(ptr, self, cnVal, cnNull, cdim, cnorm, cnormLen)
|
|
}
|
|
func AtgFftFftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string){
|
|
csDataPtr := (*C.int64_t)(unsafe.Pointer(&sData[0]))
|
|
csLen := *(*C.int)(unsafe.Pointer(&sLen))
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_fftn(ptr, self, csDataPtr, csLen, cdimDataPtr, cdimLen, cnorm, cnormLen)
|
|
}
|
|
func AtgFftHfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string){
|
|
cnVal := *(*C.int64_t)(unsafe.Pointer(&nVal))
|
|
cnNull := *(*C.uint8_t)(unsafe.Pointer(&nNull))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_hfft(ptr, self, cnVal, cnNull, cdim, cnorm, cnormLen)
|
|
}
|
|
func AtgFftIfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string){
|
|
cnVal := *(*C.int64_t)(unsafe.Pointer(&nVal))
|
|
cnNull := *(*C.uint8_t)(unsafe.Pointer(&nNull))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_ifft(ptr, self, cnVal, cnNull, cdim, cnorm, cnormLen)
|
|
}
|
|
func AtgFftIfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string){
|
|
csDataPtr := (*C.int64_t)(unsafe.Pointer(&sData[0]))
|
|
csLen := *(*C.int)(unsafe.Pointer(&sLen))
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_ifftn(ptr, self, csDataPtr, csLen, cdimDataPtr, cdimLen, cnorm, cnormLen)
|
|
}
|
|
func AtgFftIhfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string){
|
|
cnVal := *(*C.int64_t)(unsafe.Pointer(&nVal))
|
|
cnNull := *(*C.uint8_t)(unsafe.Pointer(&nNull))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_ihfft(ptr, self, cnVal, cnNull, cdim, cnorm, cnormLen)
|
|
}
|
|
func AtgFftIrfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string){
|
|
cnVal := *(*C.int64_t)(unsafe.Pointer(&nVal))
|
|
cnNull := *(*C.uint8_t)(unsafe.Pointer(&nNull))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_irfft(ptr, self, cnVal, cnNull, cdim, cnorm, cnormLen)
|
|
}
|
|
func AtgFftIrfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string){
|
|
csDataPtr := (*C.int64_t)(unsafe.Pointer(&sData[0]))
|
|
csLen := *(*C.int)(unsafe.Pointer(&sLen))
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_irfftn(ptr, self, csDataPtr, csLen, cdimDataPtr, cdimLen, cnorm, cnormLen)
|
|
}
|
|
func AtgFftRfft(ptr *Ctensor, self Ctensor, nVal int64, nNull int, dim int64, norm string){
|
|
cnVal := *(*C.int64_t)(unsafe.Pointer(&nVal))
|
|
cnNull := *(*C.uint8_t)(unsafe.Pointer(&nNull))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_rfft(ptr, self, cnVal, cnNull, cdim, cnorm, cnormLen)
|
|
}
|
|
func AtgFftRfftn(ptr *Ctensor, self Ctensor, sData []int64, sLen int, dimData []int64, dimLen int, norm string){
|
|
csDataPtr := (*C.int64_t)(unsafe.Pointer(&sData[0]))
|
|
csLen := *(*C.int)(unsafe.Pointer(&sLen))
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cnorm := C.CString(norm)
|
|
normLen := len(norm)
|
|
cnormLen := *(*C.int)(unsafe.Pointer(&normLen))
|
|
C.atg_fft_rfftn(ptr, self, csDataPtr, csLen, cdimDataPtr, cdimLen, cnorm, cnormLen)
|
|
}
|
|
func AtgFill_(ptr *Ctensor, self Ctensor, value Cscalar){
|
|
C.atg_fill_(ptr, self, value )
|
|
}
|
|
func AtgFill1_(ptr *Ctensor, self Ctensor, value Ctensor){
|
|
C.atg_fill_1(ptr, self, value)
|
|
}
|
|
func AtgFillDiagonal_(ptr *Ctensor, self Ctensor, fillValue Cscalar, wrap int32){
|
|
cwrap := *(*C.int)(unsafe.Pointer(&wrap))
|
|
C.atg_fill_diagonal_(ptr, self, fillValue , cwrap)
|
|
}
|
|
func AtgFix(ptr *Ctensor, self Ctensor){
|
|
C.atg_fix(ptr, self)
|
|
}
|
|
func AtgFix_(ptr *Ctensor, self Ctensor){
|
|
C.atg_fix_(ptr, self)
|
|
}
|
|
func AtgFixOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_fix_out(ptr, out, self)
|
|
}
|
|
func AtgFlatten(ptr *Ctensor, self Ctensor, startDim int64, endDim int64){
|
|
cstartDim := *(*C.int64_t)(unsafe.Pointer(&startDim))
|
|
cendDim := *(*C.int64_t)(unsafe.Pointer(&endDim))
|
|
C.atg_flatten(ptr, self, cstartDim, cendDim)
|
|
}
|
|
func AtgFlip(ptr *Ctensor, self Ctensor, dimsData []int64, dimsLen int){
|
|
cdimsDataPtr := (*C.int64_t)(unsafe.Pointer(&dimsData[0]))
|
|
cdimsLen := *(*C.int)(unsafe.Pointer(&dimsLen))
|
|
C.atg_flip(ptr, self, cdimsDataPtr, cdimsLen)
|
|
}
|
|
func AtgFliplr(ptr *Ctensor, self Ctensor){
|
|
C.atg_fliplr(ptr, self)
|
|
}
|
|
func AtgFlipud(ptr *Ctensor, self Ctensor){
|
|
C.atg_flipud(ptr, self)
|
|
}
|
|
func AtgFloor(ptr *Ctensor, self Ctensor){
|
|
C.atg_floor(ptr, self)
|
|
}
|
|
func AtgFloor_(ptr *Ctensor, self Ctensor){
|
|
C.atg_floor_(ptr, self)
|
|
}
|
|
func AtgFloorDivide(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_floor_divide(ptr, self, other)
|
|
}
|
|
func AtgFloorDivide1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_floor_divide1(ptr, self, other )
|
|
}
|
|
func AtgFloorDivide_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_floor_divide_(ptr, self, other)
|
|
}
|
|
func AtgFloorDivide1_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_floor_divide_1(ptr, self, other )
|
|
}
|
|
func AtgFloorDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_floor_divide_out(ptr, out, self, other)
|
|
}
|
|
func AtgFloorOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_floor_out(ptr, out, self)
|
|
}
|
|
func AtgFmod(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_fmod(ptr, self, other )
|
|
}
|
|
func AtgFmod1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_fmod1(ptr, self, other)
|
|
}
|
|
func AtgFmod_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_fmod_(ptr, self, other )
|
|
}
|
|
func AtgFmod1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_fmod_1(ptr, self, other)
|
|
}
|
|
func AtgFmodOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_fmod_out(ptr, out, self, other )
|
|
}
|
|
func AtgFmodOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_fmod_out1(ptr, out, self, other)
|
|
}
|
|
func AtgFrac(ptr *Ctensor, self Ctensor){
|
|
C.atg_frac(ptr, self)
|
|
}
|
|
func AtgFrac_(ptr *Ctensor, self Ctensor){
|
|
C.atg_frac_(ptr, self)
|
|
}
|
|
func AtgFracOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_frac_out(ptr, out, self)
|
|
}
|
|
func AtgFractionalMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, randomSamples Ctensor){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_fractional_max_pool2d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, coutputSizeDataPtr, coutputSizeLen, randomSamples)
|
|
}
|
|
func AtgFractionalMaxPool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, indices Ctensor){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_fractional_max_pool2d_backward(ptr, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, coutputSizeDataPtr, coutputSizeLen, indices)
|
|
}
|
|
func AtgFractionalMaxPool2dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, indices Ctensor){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_fractional_max_pool2d_backward_out(ptr, gradInput, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, coutputSizeDataPtr, coutputSizeLen, indices)
|
|
}
|
|
func AtgFractionalMaxPool2dOut(ptr *Ctensor, output Ctensor, indices Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, randomSamples Ctensor){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_fractional_max_pool2d_out(ptr, output, indices, self, ckernelSizeDataPtr, ckernelSizeLen, coutputSizeDataPtr, coutputSizeLen, randomSamples)
|
|
}
|
|
func AtgFractionalMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, randomSamples Ctensor){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_fractional_max_pool3d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, coutputSizeDataPtr, coutputSizeLen, randomSamples)
|
|
}
|
|
func AtgFractionalMaxPool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, indices Ctensor){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_fractional_max_pool3d_backward(ptr, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, coutputSizeDataPtr, coutputSizeLen, indices)
|
|
}
|
|
func AtgFractionalMaxPool3dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, indices Ctensor){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_fractional_max_pool3d_backward_out(ptr, gradInput, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, coutputSizeDataPtr, coutputSizeLen, indices)
|
|
}
|
|
func AtgFractionalMaxPool3dOut(ptr *Ctensor, output Ctensor, indices Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, outputSizeData []int64, outputSizeLen int, randomSamples Ctensor){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_fractional_max_pool3d_out(ptr, output, indices, self, ckernelSizeDataPtr, ckernelSizeLen, coutputSizeDataPtr, coutputSizeLen, randomSamples)
|
|
}
|
|
func AtgFrobeniusNorm(ptr *Ctensor, self Ctensor){
|
|
C.atg_frobenius_norm(ptr, self)
|
|
}
|
|
func AtgFrobeniusNorm1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_frobenius_norm1(ptr, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgFrobeniusNormOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_frobenius_norm_out(ptr, out, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgFromFile(ptr *Ctensor, filename string, shared int32, sizeVal int64, sizeNull int, optionsKind int32, optionsDevice int32){
|
|
cfilename := C.CString(filename)
|
|
filenameLen := len(filename)
|
|
cfilenameLen := *(*C.int)(unsafe.Pointer(&filenameLen))
|
|
cshared := *(*C.int)(unsafe.Pointer(&shared))
|
|
csizeVal := *(*C.int64_t)(unsafe.Pointer(&sizeVal))
|
|
csizeNull := *(*C.uint8_t)(unsafe.Pointer(&sizeNull))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_from_file(ptr, cfilename, cfilenameLen, cshared, csizeVal, csizeNull, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgFull(ptr *Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_full(ptr, csizeDataPtr, csizeLen, fillValue , coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgFullLike(ptr *Ctensor, self Ctensor, fillValue Cscalar){
|
|
C.atg_full_like(ptr, self, fillValue )
|
|
}
|
|
func AtgFullOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_full_out(ptr, out, csizeDataPtr, csizeLen, fillValue )
|
|
}
|
|
func AtgGather(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, sparseGrad int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
csparseGrad := *(*C.int)(unsafe.Pointer(&sparseGrad))
|
|
C.atg_gather(ptr, self, cdim, index, csparseGrad)
|
|
}
|
|
func AtgGatherBackward(ptr *Ctensor, grad Ctensor, self Ctensor, dim int64, index Ctensor, sparseGrad int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
csparseGrad := *(*C.int)(unsafe.Pointer(&sparseGrad))
|
|
C.atg_gather_backward(ptr, grad, self, cdim, index, csparseGrad)
|
|
}
|
|
func AtgGatherOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, sparseGrad int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
csparseGrad := *(*C.int)(unsafe.Pointer(&sparseGrad))
|
|
C.atg_gather_out(ptr, out, self, cdim, index, csparseGrad)
|
|
}
|
|
func AtgGcd(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_gcd(ptr, self, other)
|
|
}
|
|
func AtgGcd_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_gcd_(ptr, self, other)
|
|
}
|
|
func AtgGcdOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_gcd_out(ptr, out, self, other)
|
|
}
|
|
func AtgGe(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_ge(ptr, self, other )
|
|
}
|
|
func AtgGe1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_ge1(ptr, self, other)
|
|
}
|
|
func AtgGe_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_ge_(ptr, self, other )
|
|
}
|
|
func AtgGe1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_ge_1(ptr, self, other)
|
|
}
|
|
func AtgGeOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_ge_out(ptr, out, self, other )
|
|
}
|
|
func AtgGeOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_ge_out1(ptr, out, self, other)
|
|
}
|
|
func AtgGelu(ptr *Ctensor, self Ctensor){
|
|
C.atg_gelu(ptr, self)
|
|
}
|
|
func AtgGeluBackward(ptr *Ctensor, grad Ctensor, self Ctensor){
|
|
C.atg_gelu_backward(ptr, grad, self)
|
|
}
|
|
func AtgGeometric_(ptr *Ctensor, self Ctensor, p float64){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
C.atg_geometric_(ptr, self, cp)
|
|
}
|
|
func AtgGeqrf(ptr *Ctensor, self Ctensor){
|
|
C.atg_geqrf(ptr, self)
|
|
}
|
|
func AtgGeqrfOut(ptr *Ctensor, a Ctensor, tau Ctensor, self Ctensor){
|
|
C.atg_geqrf_out(ptr, a, tau, self)
|
|
}
|
|
func AtgGer(ptr *Ctensor, self Ctensor, vec2 Ctensor){
|
|
C.atg_ger(ptr, self, vec2)
|
|
}
|
|
func AtgGerOut(ptr *Ctensor, out Ctensor, self Ctensor, vec2 Ctensor){
|
|
C.atg_ger_out(ptr, out, self, vec2)
|
|
}
|
|
func AtgGlu(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_glu(ptr, self, cdim)
|
|
}
|
|
func AtgGluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_glu_backward(ptr, gradOutput, self, cdim)
|
|
}
|
|
func AtgGluBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_glu_backward_out(ptr, gradInput, gradOutput, self, cdim)
|
|
}
|
|
func AtgGluOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_glu_out(ptr, out, self, cdim)
|
|
}
|
|
func AtgGrad(ptr *Ctensor, self Ctensor){
|
|
C.atg_grad(ptr, self)
|
|
}
|
|
func AtgGreater(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_greater(ptr, self, other )
|
|
}
|
|
func AtgGreater1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_greater1(ptr, self, other)
|
|
}
|
|
func AtgGreater_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_greater_(ptr, self, other )
|
|
}
|
|
func AtgGreater1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_greater_1(ptr, self, other)
|
|
}
|
|
func AtgGreaterEqual(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_greater_equal(ptr, self, other )
|
|
}
|
|
func AtgGreaterEqual1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_greater_equal1(ptr, self, other)
|
|
}
|
|
func AtgGreaterEqual_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_greater_equal_(ptr, self, other )
|
|
}
|
|
func AtgGreaterEqual1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_greater_equal_1(ptr, self, other)
|
|
}
|
|
func AtgGreaterEqualOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_greater_equal_out(ptr, out, self, other )
|
|
}
|
|
func AtgGreaterEqualOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_greater_equal_out1(ptr, out, self, other)
|
|
}
|
|
func AtgGreaterOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_greater_out(ptr, out, self, other )
|
|
}
|
|
func AtgGreaterOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_greater_out1(ptr, out, self, other)
|
|
}
|
|
func AtgGridSampler(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32){
|
|
cinterpolationMode := *(*C.int64_t)(unsafe.Pointer(&interpolationMode))
|
|
cpaddingMode := *(*C.int64_t)(unsafe.Pointer(&paddingMode))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
C.atg_grid_sampler(ptr, input, grid, cinterpolationMode, cpaddingMode, calignCorners)
|
|
}
|
|
func AtgGridSampler2d(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32){
|
|
cinterpolationMode := *(*C.int64_t)(unsafe.Pointer(&interpolationMode))
|
|
cpaddingMode := *(*C.int64_t)(unsafe.Pointer(&paddingMode))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
C.atg_grid_sampler_2d(ptr, input, grid, cinterpolationMode, cpaddingMode, calignCorners)
|
|
}
|
|
func AtgGridSampler2dBackward(ptr *Ctensor, gradOutput Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32){
|
|
cinterpolationMode := *(*C.int64_t)(unsafe.Pointer(&interpolationMode))
|
|
cpaddingMode := *(*C.int64_t)(unsafe.Pointer(&paddingMode))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
C.atg_grid_sampler_2d_backward(ptr, gradOutput, input, grid, cinterpolationMode, cpaddingMode, calignCorners)
|
|
}
|
|
func AtgGridSampler3d(ptr *Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32){
|
|
cinterpolationMode := *(*C.int64_t)(unsafe.Pointer(&interpolationMode))
|
|
cpaddingMode := *(*C.int64_t)(unsafe.Pointer(&paddingMode))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
C.atg_grid_sampler_3d(ptr, input, grid, cinterpolationMode, cpaddingMode, calignCorners)
|
|
}
|
|
func AtgGridSampler3dBackward(ptr *Ctensor, gradOutput Ctensor, input Ctensor, grid Ctensor, interpolationMode int64, paddingMode int64, alignCorners int32){
|
|
cinterpolationMode := *(*C.int64_t)(unsafe.Pointer(&interpolationMode))
|
|
cpaddingMode := *(*C.int64_t)(unsafe.Pointer(&paddingMode))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
C.atg_grid_sampler_3d_backward(ptr, gradOutput, input, grid, cinterpolationMode, cpaddingMode, calignCorners)
|
|
}
|
|
func AtgGroupNorm(ptr *Ctensor, input Ctensor, numGroups int64, weight Ctensor, bias Ctensor, eps float64, cudnnEnabled int32){
|
|
cnumGroups := *(*C.int64_t)(unsafe.Pointer(&numGroups))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
ccudnnEnabled := *(*C.int)(unsafe.Pointer(&cudnnEnabled))
|
|
C.atg_group_norm(ptr, input, cnumGroups, weight, bias, ceps, ccudnnEnabled)
|
|
}
|
|
func AtgGru(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32, batchFirst int32){
|
|
cparamsDataPtr := (*Ctensor)(unsafe.Pointer(¶msData[0]))
|
|
cparamsLen := *(*C.int)(unsafe.Pointer(¶msLen))
|
|
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_gru(ptr, input, hx, cparamsDataPtr, cparamsLen, chasBiases, cnumLayers, cdropout, ctrain, cbidirectional, cbatchFirst)
|
|
}
|
|
func AtgGru1(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32){
|
|
cparamsDataPtr := (*Ctensor)(unsafe.Pointer(¶msData[0]))
|
|
cparamsLen := *(*C.int)(unsafe.Pointer(¶msLen))
|
|
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))
|
|
C.atg_gru1(ptr, data, batchSizes, hx, cparamsDataPtr, cparamsLen, chasBiases, cnumLayers, cdropout, ctrain, cbidirectional)
|
|
}
|
|
func AtgGruCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor){
|
|
C.atg_gru_cell(ptr, input, hx, wIh, wHh, bIh, bHh)
|
|
}
|
|
func AtgGt(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_gt(ptr, self, other )
|
|
}
|
|
func AtgGt1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_gt1(ptr, self, other)
|
|
}
|
|
func AtgGt_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_gt_(ptr, self, other )
|
|
}
|
|
func AtgGt1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_gt_1(ptr, self, other)
|
|
}
|
|
func AtgGtOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_gt_out(ptr, out, self, other )
|
|
}
|
|
func AtgGtOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_gt_out1(ptr, out, self, other)
|
|
}
|
|
func AtgHammingWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_hamming_window(ptr, cwindowLength, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgHammingWindow1(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
cperiodic := *(*C.int)(unsafe.Pointer(&periodic))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_hamming_window1(ptr, cwindowLength, cperiodic, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgHammingWindow2(ptr *Ctensor, windowLength int64, periodic int32, alpha float64, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
cperiodic := *(*C.int)(unsafe.Pointer(&periodic))
|
|
calpha := *(*C.double)(unsafe.Pointer(&alpha))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_hamming_window2(ptr, cwindowLength, cperiodic, calpha, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgHammingWindow3(ptr *Ctensor, windowLength int64, periodic int32, alpha float64, beta float64, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
cperiodic := *(*C.int)(unsafe.Pointer(&periodic))
|
|
calpha := *(*C.double)(unsafe.Pointer(&alpha))
|
|
cbeta := *(*C.double)(unsafe.Pointer(&beta))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_hamming_window3(ptr, cwindowLength, cperiodic, calpha, cbeta, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgHannWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_hann_window(ptr, cwindowLength, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgHannWindow1(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
cperiodic := *(*C.int)(unsafe.Pointer(&periodic))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_hann_window1(ptr, cwindowLength, cperiodic, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgHardshrink(ptr *Ctensor, self Ctensor){
|
|
C.atg_hardshrink(ptr, self)
|
|
}
|
|
func AtgHardshrinkBackward(ptr *Ctensor, gradOut Ctensor, self Ctensor, lambd Cscalar){
|
|
C.atg_hardshrink_backward(ptr, gradOut, self, lambd )
|
|
}
|
|
func AtgHardsigmoid(ptr *Ctensor, self Ctensor){
|
|
C.atg_hardsigmoid(ptr, self)
|
|
}
|
|
func AtgHardsigmoid_(ptr *Ctensor, self Ctensor){
|
|
C.atg_hardsigmoid_(ptr, self)
|
|
}
|
|
func AtgHardsigmoidBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor){
|
|
C.atg_hardsigmoid_backward(ptr, gradOutput, self)
|
|
}
|
|
func AtgHardsigmoidOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_hardsigmoid_out(ptr, out, self)
|
|
}
|
|
func AtgHardswish(ptr *Ctensor, self Ctensor){
|
|
C.atg_hardswish(ptr, self)
|
|
}
|
|
func AtgHardswish_(ptr *Ctensor, self Ctensor){
|
|
C.atg_hardswish_(ptr, self)
|
|
}
|
|
func AtgHardswishBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor){
|
|
C.atg_hardswish_backward(ptr, gradOutput, self)
|
|
}
|
|
func AtgHardswishOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_hardswish_out(ptr, out, self)
|
|
}
|
|
func AtgHardtanh(ptr *Ctensor, self Ctensor){
|
|
C.atg_hardtanh(ptr, self)
|
|
}
|
|
func AtgHardtanh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_hardtanh_(ptr, self)
|
|
}
|
|
func AtgHardtanhBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, minVal Cscalar, maxVal Cscalar){
|
|
C.atg_hardtanh_backward(ptr, gradOutput, self, minVal , maxVal )
|
|
}
|
|
func AtgHardtanhBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, minVal Cscalar, maxVal Cscalar){
|
|
C.atg_hardtanh_backward_out(ptr, gradInput, gradOutput, self, minVal , maxVal )
|
|
}
|
|
func AtgHardtanhOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_hardtanh_out(ptr, out, self)
|
|
}
|
|
func AtgHeaviside(ptr *Ctensor, self Ctensor, values Ctensor){
|
|
C.atg_heaviside(ptr, self, values)
|
|
}
|
|
func AtgHeaviside_(ptr *Ctensor, self Ctensor, values Ctensor){
|
|
C.atg_heaviside_(ptr, self, values)
|
|
}
|
|
func AtgHeavisideOut(ptr *Ctensor, out Ctensor, self Ctensor, values Ctensor){
|
|
C.atg_heaviside_out(ptr, out, self, values)
|
|
}
|
|
func AtgHingeEmbeddingLoss(ptr *Ctensor, self Ctensor, target Ctensor, margin float64, reduction int64){
|
|
cmargin := *(*C.double)(unsafe.Pointer(&margin))
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_hinge_embedding_loss(ptr, self, target, cmargin, creduction)
|
|
}
|
|
func AtgHistc(ptr *Ctensor, self Ctensor, bins int64){
|
|
cbins := *(*C.int64_t)(unsafe.Pointer(&bins))
|
|
C.atg_histc(ptr, self, cbins)
|
|
}
|
|
func AtgHistcOut(ptr *Ctensor, out Ctensor, self Ctensor, bins int64){
|
|
cbins := *(*C.int64_t)(unsafe.Pointer(&bins))
|
|
C.atg_histc_out(ptr, out, self, cbins)
|
|
}
|
|
func AtgHspmm(ptr *Ctensor, mat1 Ctensor, mat2 Ctensor){
|
|
C.atg_hspmm(ptr, mat1, mat2)
|
|
}
|
|
func AtgHspmmOut(ptr *Ctensor, out Ctensor, mat1 Ctensor, mat2 Ctensor){
|
|
C.atg_hspmm_out(ptr, out, mat1, mat2)
|
|
}
|
|
func AtgHstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
C.atg_hstack(ptr, ctensorsDataPtr, ctensorsLen)
|
|
}
|
|
func AtgHstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
C.atg_hstack_out(ptr, out, ctensorsDataPtr, ctensorsLen)
|
|
}
|
|
func AtgHypot(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_hypot(ptr, self, other)
|
|
}
|
|
func AtgHypot_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_hypot_(ptr, self, other)
|
|
}
|
|
func AtgHypotOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_hypot_out(ptr, out, self, other)
|
|
}
|
|
func AtgI0(ptr *Ctensor, self Ctensor){
|
|
C.atg_i0(ptr, self)
|
|
}
|
|
func AtgI0_(ptr *Ctensor, self Ctensor){
|
|
C.atg_i0_(ptr, self)
|
|
}
|
|
func AtgI0Out(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_i0_out(ptr, out, self)
|
|
}
|
|
func AtgIfft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32){
|
|
csignalNdim := *(*C.int64_t)(unsafe.Pointer(&signalNdim))
|
|
cnormalized := *(*C.int)(unsafe.Pointer(&normalized))
|
|
C.atg_ifft(ptr, self, csignalNdim, cnormalized)
|
|
}
|
|
func AtgIm2col(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
C.atg_im2col(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cdilationDataPtr, cdilationLen, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen)
|
|
}
|
|
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){
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
C.atg_im2col_backward(ptr, gradOutput, cinputSizeDataPtr, cinputSizeLen, ckernelSizeDataPtr, ckernelSizeLen, cdilationDataPtr, cdilationLen, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen)
|
|
}
|
|
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){
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
C.atg_im2col_backward_out(ptr, gradInput, gradOutput, cinputSizeDataPtr, cinputSizeLen, ckernelSizeDataPtr, ckernelSizeLen, cdilationDataPtr, cdilationLen, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen)
|
|
}
|
|
func AtgIm2colOut(ptr *Ctensor, out Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, dilationData []int64, dilationLen int, paddingData []int64, paddingLen int, strideData []int64, strideLen int){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
C.atg_im2col_out(ptr, out, self, ckernelSizeDataPtr, ckernelSizeLen, cdilationDataPtr, cdilationLen, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen)
|
|
}
|
|
func AtgImag(ptr *Ctensor, self Ctensor){
|
|
C.atg_imag(ptr, self)
|
|
}
|
|
func AtgIndex(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int){
|
|
cindicesDataPtr := (*Ctensor)(unsafe.Pointer(&indicesData[0]))
|
|
cindicesLen := *(*C.int)(unsafe.Pointer(&indicesLen))
|
|
C.atg_index(ptr, self, cindicesDataPtr, cindicesLen)
|
|
}
|
|
func AtgIndexAdd(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_add(ptr, self, cdim, index, source)
|
|
}
|
|
func AtgIndexAdd_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_add_(ptr, self, cdim, index, source)
|
|
}
|
|
func AtgIndexCopy(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_copy(ptr, self, cdim, index, source)
|
|
}
|
|
func AtgIndexCopy_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, source Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_copy_(ptr, self, cdim, index, source)
|
|
}
|
|
func AtgIndexFill(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_fill(ptr, self, cdim, index, value )
|
|
}
|
|
func AtgIndexFill1(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_fill1(ptr, self, cdim, index, value)
|
|
}
|
|
func AtgIndexFill_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_fill_(ptr, self, cdim, index, value )
|
|
}
|
|
func AtgIndexFill1_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_fill_1(ptr, self, cdim, index, value)
|
|
}
|
|
func AtgIndexPut(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, values Ctensor, accumulate int32){
|
|
cindicesDataPtr := (*Ctensor)(unsafe.Pointer(&indicesData[0]))
|
|
cindicesLen := *(*C.int)(unsafe.Pointer(&indicesLen))
|
|
caccumulate := *(*C.int)(unsafe.Pointer(&accumulate))
|
|
C.atg_index_put(ptr, self, cindicesDataPtr, cindicesLen, values, caccumulate)
|
|
}
|
|
func AtgIndexPut_(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, values Ctensor, accumulate int32){
|
|
cindicesDataPtr := (*Ctensor)(unsafe.Pointer(&indicesData[0]))
|
|
cindicesLen := *(*C.int)(unsafe.Pointer(&indicesLen))
|
|
caccumulate := *(*C.int)(unsafe.Pointer(&accumulate))
|
|
C.atg_index_put_(ptr, self, cindicesDataPtr, cindicesLen, values, caccumulate)
|
|
}
|
|
func AtgIndexSelect(ptr *Ctensor, self Ctensor, dim int64, index Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_select(ptr, self, cdim, index)
|
|
}
|
|
func AtgIndexSelectBackward(ptr *Ctensor, grad Ctensor, selfSizesData []int64, selfSizesLen int, dim int64, index Ctensor){
|
|
cselfSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&selfSizesData[0]))
|
|
cselfSizesLen := *(*C.int)(unsafe.Pointer(&selfSizesLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_select_backward(ptr, grad, cselfSizesDataPtr, cselfSizesLen, cdim, index)
|
|
}
|
|
func AtgIndexSelectOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_index_select_out(ptr, out, self, cdim, index)
|
|
}
|
|
func AtgIndices(ptr *Ctensor, self Ctensor){
|
|
C.atg_indices(ptr, self)
|
|
}
|
|
func AtgInfinitelyDifferentiableGeluBackward(ptr *Ctensor, grad Ctensor, self Ctensor){
|
|
C.atg_infinitely_differentiable_gelu_backward(ptr, grad, self)
|
|
}
|
|
func AtgInstanceNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, useInputStats int32, momentum float64, eps float64, cudnnEnabled int32){
|
|
cuseInputStats := *(*C.int)(unsafe.Pointer(&useInputStats))
|
|
cmomentum := *(*C.double)(unsafe.Pointer(&momentum))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
ccudnnEnabled := *(*C.int)(unsafe.Pointer(&cudnnEnabled))
|
|
C.atg_instance_norm(ptr, input, weight, bias, runningMean, runningVar, cuseInputStats, cmomentum, ceps, ccudnnEnabled)
|
|
}
|
|
func AtgIntRepr(ptr *Ctensor, self Ctensor){
|
|
C.atg_int_repr(ptr, self)
|
|
}
|
|
func AtgInverse(ptr *Ctensor, self Ctensor){
|
|
C.atg_inverse(ptr, self)
|
|
}
|
|
func AtgInverseOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_inverse_out(ptr, out, self)
|
|
}
|
|
func AtgIrfft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32, onesided int32, signalSizesData []int64, signalSizesLen int){
|
|
csignalNdim := *(*C.int64_t)(unsafe.Pointer(&signalNdim))
|
|
cnormalized := *(*C.int)(unsafe.Pointer(&normalized))
|
|
conesided := *(*C.int)(unsafe.Pointer(&onesided))
|
|
csignalSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&signalSizesData[0]))
|
|
csignalSizesLen := *(*C.int)(unsafe.Pointer(&signalSizesLen))
|
|
C.atg_irfft(ptr, self, csignalNdim, cnormalized, conesided, csignalSizesDataPtr, csignalSizesLen)
|
|
}
|
|
func AtgIsclose(ptr *Ctensor, self Ctensor, other Ctensor, rtol float64, atol float64, equalNan int32){
|
|
crtol := *(*C.double)(unsafe.Pointer(&rtol))
|
|
catol := *(*C.double)(unsafe.Pointer(&atol))
|
|
cequalNan := *(*C.int)(unsafe.Pointer(&equalNan))
|
|
C.atg_isclose(ptr, self, other, crtol, catol, cequalNan)
|
|
}
|
|
func AtgIsfinite(ptr *Ctensor, self Ctensor){
|
|
C.atg_isfinite(ptr, self)
|
|
}
|
|
func AtgIsinf(ptr *Ctensor, self Ctensor){
|
|
C.atg_isinf(ptr, self)
|
|
}
|
|
func AtgIsnan(ptr *Ctensor, self Ctensor){
|
|
C.atg_isnan(ptr, self)
|
|
}
|
|
func AtgIsneginf(ptr *Ctensor, self Ctensor){
|
|
C.atg_isneginf(ptr, self)
|
|
}
|
|
func AtgIsneginfOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_isneginf_out(ptr, out, self)
|
|
}
|
|
func AtgIsposinf(ptr *Ctensor, self Ctensor){
|
|
C.atg_isposinf(ptr, self)
|
|
}
|
|
func AtgIsposinfOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_isposinf_out(ptr, out, self)
|
|
}
|
|
func AtgIsreal(ptr *Ctensor, self Ctensor){
|
|
C.atg_isreal(ptr, self)
|
|
}
|
|
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){
|
|
cnFft := *(*C.int64_t)(unsafe.Pointer(&nFft))
|
|
chopLengthVal := *(*C.int64_t)(unsafe.Pointer(&hopLengthVal))
|
|
chopLengthNull := *(*C.uint8_t)(unsafe.Pointer(&hopLengthNull))
|
|
cwinLengthVal := *(*C.int64_t)(unsafe.Pointer(&winLengthVal))
|
|
cwinLengthNull := *(*C.uint8_t)(unsafe.Pointer(&winLengthNull))
|
|
ccenter := *(*C.int)(unsafe.Pointer(¢er))
|
|
cnormalized := *(*C.int)(unsafe.Pointer(&normalized))
|
|
conesided := *(*C.int)(unsafe.Pointer(&onesided))
|
|
clengthVal := *(*C.int64_t)(unsafe.Pointer(&lengthVal))
|
|
clengthNull := *(*C.uint8_t)(unsafe.Pointer(&lengthNull))
|
|
creturnComplex := *(*C.int)(unsafe.Pointer(&returnComplex))
|
|
C.atg_istft(ptr, self, cnFft, chopLengthVal, chopLengthNull, cwinLengthVal, cwinLengthNull, window, ccenter, cnormalized, conesided, clengthVal, clengthNull, creturnComplex)
|
|
}
|
|
func AtgKaiserWindow(ptr *Ctensor, windowLength int64, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_kaiser_window(ptr, cwindowLength, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgKaiserWindow1(ptr *Ctensor, windowLength int64, periodic int32, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
cperiodic := *(*C.int)(unsafe.Pointer(&periodic))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_kaiser_window1(ptr, cwindowLength, cperiodic, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgKaiserWindow2(ptr *Ctensor, windowLength int64, periodic int32, beta float64, optionsKind int32, optionsDevice int32){
|
|
cwindowLength := *(*C.int64_t)(unsafe.Pointer(&windowLength))
|
|
cperiodic := *(*C.int)(unsafe.Pointer(&periodic))
|
|
cbeta := *(*C.double)(unsafe.Pointer(&beta))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_kaiser_window2(ptr, cwindowLength, cperiodic, cbeta, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgKlDiv(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64, logTarget int32){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
clogTarget := *(*C.int)(unsafe.Pointer(&logTarget))
|
|
C.atg_kl_div(ptr, self, target, creduction, clogTarget)
|
|
}
|
|
func AtgKlDivBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, logTarget int32){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
clogTarget := *(*C.int)(unsafe.Pointer(&logTarget))
|
|
C.atg_kl_div_backward(ptr, gradOutput, self, target, creduction, clogTarget)
|
|
}
|
|
func AtgKthvalue(ptr *Ctensor, self Ctensor, k int64, dim int64, keepdim int32){
|
|
ck := *(*C.int64_t)(unsafe.Pointer(&k))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_kthvalue(ptr, self, ck, cdim, ckeepdim)
|
|
}
|
|
func AtgKthvalueOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, k int64, dim int64, keepdim int32){
|
|
ck := *(*C.int64_t)(unsafe.Pointer(&k))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_kthvalue_out(ptr, values, indices, self, ck, cdim, ckeepdim)
|
|
}
|
|
func AtgL1Loss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_l1_loss(ptr, self, target, creduction)
|
|
}
|
|
func AtgL1LossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_l1_loss_backward(ptr, gradOutput, self, target, creduction)
|
|
}
|
|
func AtgL1LossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_l1_loss_backward_out(ptr, gradInput, gradOutput, self, target, creduction)
|
|
}
|
|
func AtgL1LossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_l1_loss_out(ptr, out, self, target, creduction)
|
|
}
|
|
func AtgLayerNorm(ptr *Ctensor, input Ctensor, normalizedShapeData []int64, normalizedShapeLen int, weight Ctensor, bias Ctensor, eps float64, cudnnEnable int32){
|
|
cnormalizedShapeDataPtr := (*C.int64_t)(unsafe.Pointer(&normalizedShapeData[0]))
|
|
cnormalizedShapeLen := *(*C.int)(unsafe.Pointer(&normalizedShapeLen))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
ccudnnEnable := *(*C.int)(unsafe.Pointer(&cudnnEnable))
|
|
C.atg_layer_norm(ptr, input, cnormalizedShapeDataPtr, cnormalizedShapeLen, weight, bias, ceps, ccudnnEnable)
|
|
}
|
|
func AtgLcm(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_lcm(ptr, self, other)
|
|
}
|
|
func AtgLcm_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_lcm_(ptr, self, other)
|
|
}
|
|
func AtgLcmOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_lcm_out(ptr, out, self, other)
|
|
}
|
|
func AtgLe(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_le(ptr, self, other )
|
|
}
|
|
func AtgLe1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_le1(ptr, self, other)
|
|
}
|
|
func AtgLe_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_le_(ptr, self, other )
|
|
}
|
|
func AtgLe1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_le_1(ptr, self, other)
|
|
}
|
|
func AtgLeOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_le_out(ptr, out, self, other )
|
|
}
|
|
func AtgLeOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_le_out1(ptr, out, self, other)
|
|
}
|
|
func AtgLeakyRelu(ptr *Ctensor, self Ctensor){
|
|
C.atg_leaky_relu(ptr, self)
|
|
}
|
|
func AtgLeakyRelu_(ptr *Ctensor, self Ctensor){
|
|
C.atg_leaky_relu_(ptr, self)
|
|
}
|
|
func AtgLeakyReluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, negativeSlope Cscalar, selfIsResult int32){
|
|
cselfIsResult := *(*C.int)(unsafe.Pointer(&selfIsResult))
|
|
C.atg_leaky_relu_backward(ptr, gradOutput, self, negativeSlope , cselfIsResult)
|
|
}
|
|
func AtgLeakyReluOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_leaky_relu_out(ptr, out, self)
|
|
}
|
|
func AtgLerp(ptr *Ctensor, self Ctensor, end Ctensor, weight Cscalar){
|
|
C.atg_lerp(ptr, self, end, weight )
|
|
}
|
|
func AtgLerp1(ptr *Ctensor, self Ctensor, end Ctensor, weight Ctensor){
|
|
C.atg_lerp1(ptr, self, end, weight)
|
|
}
|
|
func AtgLerp_(ptr *Ctensor, self Ctensor, end Ctensor, weight Cscalar){
|
|
C.atg_lerp_(ptr, self, end, weight )
|
|
}
|
|
func AtgLerp1_(ptr *Ctensor, self Ctensor, end Ctensor, weight Ctensor){
|
|
C.atg_lerp_1(ptr, self, end, weight)
|
|
}
|
|
func AtgLerpOut(ptr *Ctensor, out Ctensor, self Ctensor, end Ctensor, weight Cscalar){
|
|
C.atg_lerp_out(ptr, out, self, end, weight )
|
|
}
|
|
func AtgLerpOut1(ptr *Ctensor, out Ctensor, self Ctensor, end Ctensor, weight Ctensor){
|
|
C.atg_lerp_out1(ptr, out, self, end, weight)
|
|
}
|
|
func AtgLess(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_less(ptr, self, other )
|
|
}
|
|
func AtgLess1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_less1(ptr, self, other)
|
|
}
|
|
func AtgLess_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_less_(ptr, self, other )
|
|
}
|
|
func AtgLess1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_less_1(ptr, self, other)
|
|
}
|
|
func AtgLessEqual(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_less_equal(ptr, self, other )
|
|
}
|
|
func AtgLessEqual1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_less_equal1(ptr, self, other)
|
|
}
|
|
func AtgLessEqual_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_less_equal_(ptr, self, other )
|
|
}
|
|
func AtgLessEqual1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_less_equal_1(ptr, self, other)
|
|
}
|
|
func AtgLessEqualOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_less_equal_out(ptr, out, self, other )
|
|
}
|
|
func AtgLessEqualOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_less_equal_out1(ptr, out, self, other)
|
|
}
|
|
func AtgLessOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_less_out(ptr, out, self, other )
|
|
}
|
|
func AtgLessOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_less_out1(ptr, out, self, other)
|
|
}
|
|
func AtgLgamma(ptr *Ctensor, self Ctensor){
|
|
C.atg_lgamma(ptr, self)
|
|
}
|
|
func AtgLgamma_(ptr *Ctensor, self Ctensor){
|
|
C.atg_lgamma_(ptr, self)
|
|
}
|
|
func AtgLgammaOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_lgamma_out(ptr, out, self)
|
|
}
|
|
func AtgLinalgDet(ptr *Ctensor, self Ctensor){
|
|
C.atg_linalg_det(ptr, self)
|
|
}
|
|
func AtgLinalgNorm(ptr *Ctensor, self Ctensor, ord Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_linalg_norm(ptr, self, ord , cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgLinalgNorm1(ptr *Ctensor, self Ctensor, ord string, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cord := C.CString(ord)
|
|
ordLen := len(ord)
|
|
cordLen := *(*C.int)(unsafe.Pointer(&ordLen))
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_linalg_norm1(ptr, self, cord, cordLen, cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgLinalgNormOut(ptr *Ctensor, out Ctensor, self Ctensor, ord Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_linalg_norm_out(ptr, out, self, ord , cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgLinalgNormOut1(ptr *Ctensor, out Ctensor, self Ctensor, ord string, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cord := C.CString(ord)
|
|
ordLen := len(ord)
|
|
cordLen := *(*C.int)(unsafe.Pointer(&ordLen))
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_linalg_norm_out1(ptr, out, self, cord, cordLen, cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgLinear(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor){
|
|
C.atg_linear(ptr, input, weight, bias)
|
|
}
|
|
func AtgLinspace(ptr *Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int, optionsKind int32, optionsDevice int32){
|
|
cstepsVal := *(*C.int64_t)(unsafe.Pointer(&stepsVal))
|
|
cstepsNull := *(*C.uint8_t)(unsafe.Pointer(&stepsNull))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_linspace(ptr, start , end , cstepsVal, cstepsNull, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgLinspaceOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int){
|
|
cstepsVal := *(*C.int64_t)(unsafe.Pointer(&stepsVal))
|
|
cstepsNull := *(*C.uint8_t)(unsafe.Pointer(&stepsNull))
|
|
C.atg_linspace_out(ptr, out, start , end , cstepsVal, cstepsNull)
|
|
}
|
|
func AtgLog(ptr *Ctensor, self Ctensor){
|
|
C.atg_log(ptr, self)
|
|
}
|
|
func AtgLog10(ptr *Ctensor, self Ctensor){
|
|
C.atg_log10(ptr, self)
|
|
}
|
|
func AtgLog10_(ptr *Ctensor, self Ctensor){
|
|
C.atg_log10_(ptr, self)
|
|
}
|
|
func AtgLog10Out(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_log10_out(ptr, out, self)
|
|
}
|
|
func AtgLog1p(ptr *Ctensor, self Ctensor){
|
|
C.atg_log1p(ptr, self)
|
|
}
|
|
func AtgLog1p_(ptr *Ctensor, self Ctensor){
|
|
C.atg_log1p_(ptr, self)
|
|
}
|
|
func AtgLog1pOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_log1p_out(ptr, out, self)
|
|
}
|
|
func AtgLog2(ptr *Ctensor, self Ctensor){
|
|
C.atg_log2(ptr, self)
|
|
}
|
|
func AtgLog2_(ptr *Ctensor, self Ctensor){
|
|
C.atg_log2_(ptr, self)
|
|
}
|
|
func AtgLog2Out(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_log2_out(ptr, out, self)
|
|
}
|
|
func AtgLog_(ptr *Ctensor, self Ctensor){
|
|
C.atg_log_(ptr, self)
|
|
}
|
|
func AtgLogNormal_(ptr *Ctensor, self Ctensor, mean float64, std float64){
|
|
cmean := *(*C.double)(unsafe.Pointer(&mean))
|
|
cstd := *(*C.double)(unsafe.Pointer(&std))
|
|
C.atg_log_normal_(ptr, self, cmean, cstd)
|
|
}
|
|
func AtgLogOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_log_out(ptr, out, self)
|
|
}
|
|
func AtgLogSigmoid(ptr *Ctensor, self Ctensor){
|
|
C.atg_log_sigmoid(ptr, self)
|
|
}
|
|
func AtgLogSigmoidBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, buffer Ctensor){
|
|
C.atg_log_sigmoid_backward(ptr, gradOutput, self, buffer)
|
|
}
|
|
func AtgLogSigmoidBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, buffer Ctensor){
|
|
C.atg_log_sigmoid_backward_out(ptr, gradInput, gradOutput, self, buffer)
|
|
}
|
|
func AtgLogSigmoidOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_log_sigmoid_out(ptr, out, self)
|
|
}
|
|
func AtgLogSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_log_softmax(ptr, self, cdim, cdtype)
|
|
}
|
|
func AtgLogaddexp(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logaddexp(ptr, self, other)
|
|
}
|
|
func AtgLogaddexp2(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logaddexp2(ptr, self, other)
|
|
}
|
|
func AtgLogaddexp2Out(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logaddexp2_out(ptr, out, self, other)
|
|
}
|
|
func AtgLogaddexpOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logaddexp_out(ptr, out, self, other)
|
|
}
|
|
func AtgLogcumsumexp(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_logcumsumexp(ptr, self, cdim)
|
|
}
|
|
func AtgLogcumsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_logcumsumexp_out(ptr, out, self, cdim)
|
|
}
|
|
func AtgLogdet(ptr *Ctensor, self Ctensor){
|
|
C.atg_logdet(ptr, self)
|
|
}
|
|
func AtgLogicalAnd(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logical_and(ptr, self, other)
|
|
}
|
|
func AtgLogicalAnd_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logical_and_(ptr, self, other)
|
|
}
|
|
func AtgLogicalAndOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logical_and_out(ptr, out, self, other)
|
|
}
|
|
func AtgLogicalNot(ptr *Ctensor, self Ctensor){
|
|
C.atg_logical_not(ptr, self)
|
|
}
|
|
func AtgLogicalNot_(ptr *Ctensor, self Ctensor){
|
|
C.atg_logical_not_(ptr, self)
|
|
}
|
|
func AtgLogicalNotOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_logical_not_out(ptr, out, self)
|
|
}
|
|
func AtgLogicalOr(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logical_or(ptr, self, other)
|
|
}
|
|
func AtgLogicalOr_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logical_or_(ptr, self, other)
|
|
}
|
|
func AtgLogicalOrOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logical_or_out(ptr, out, self, other)
|
|
}
|
|
func AtgLogicalXor(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logical_xor(ptr, self, other)
|
|
}
|
|
func AtgLogicalXor_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logical_xor_(ptr, self, other)
|
|
}
|
|
func AtgLogicalXorOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_logical_xor_out(ptr, out, self, other)
|
|
}
|
|
func AtgLogit(ptr *Ctensor, self Ctensor, epsVal float64, epsNull int){
|
|
cepsVal := *(*C.double)(unsafe.Pointer(&epsVal))
|
|
cepsNull := *(*C.uint8_t)(unsafe.Pointer(&epsNull))
|
|
C.atg_logit(ptr, self, cepsVal, cepsNull)
|
|
}
|
|
func AtgLogit_(ptr *Ctensor, self Ctensor, epsVal float64, epsNull int){
|
|
cepsVal := *(*C.double)(unsafe.Pointer(&epsVal))
|
|
cepsNull := *(*C.uint8_t)(unsafe.Pointer(&epsNull))
|
|
C.atg_logit_(ptr, self, cepsVal, cepsNull)
|
|
}
|
|
func AtgLogitBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, epsVal float64, epsNull int){
|
|
cepsVal := *(*C.double)(unsafe.Pointer(&epsVal))
|
|
cepsNull := *(*C.uint8_t)(unsafe.Pointer(&epsNull))
|
|
C.atg_logit_backward(ptr, gradOutput, self, cepsVal, cepsNull)
|
|
}
|
|
func AtgLogitBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, epsVal float64, epsNull int){
|
|
cepsVal := *(*C.double)(unsafe.Pointer(&epsVal))
|
|
cepsNull := *(*C.uint8_t)(unsafe.Pointer(&epsNull))
|
|
C.atg_logit_backward_out(ptr, gradInput, gradOutput, self, cepsVal, cepsNull)
|
|
}
|
|
func AtgLogitOut(ptr *Ctensor, out Ctensor, self Ctensor, epsVal float64, epsNull int){
|
|
cepsVal := *(*C.double)(unsafe.Pointer(&epsVal))
|
|
cepsNull := *(*C.uint8_t)(unsafe.Pointer(&epsNull))
|
|
C.atg_logit_out(ptr, out, self, cepsVal, cepsNull)
|
|
}
|
|
func AtgLogspace(ptr *Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int, base float64, optionsKind int32, optionsDevice int32){
|
|
cstepsVal := *(*C.int64_t)(unsafe.Pointer(&stepsVal))
|
|
cstepsNull := *(*C.uint8_t)(unsafe.Pointer(&stepsNull))
|
|
cbase := *(*C.double)(unsafe.Pointer(&base))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_logspace(ptr, start , end , cstepsVal, cstepsNull, cbase, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgLogspaceOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar, stepsVal int64, stepsNull int, base float64){
|
|
cstepsVal := *(*C.int64_t)(unsafe.Pointer(&stepsVal))
|
|
cstepsNull := *(*C.uint8_t)(unsafe.Pointer(&stepsNull))
|
|
cbase := *(*C.double)(unsafe.Pointer(&base))
|
|
C.atg_logspace_out(ptr, out, start , end , cstepsVal, cstepsNull, cbase)
|
|
}
|
|
func AtgLogsumexp(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_logsumexp(ptr, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgLogsumexpOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_logsumexp_out(ptr, out, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
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){
|
|
chxDataPtr := (*Ctensor)(unsafe.Pointer(&hxData[0]))
|
|
chxLen := *(*C.int)(unsafe.Pointer(&hxLen))
|
|
cparamsDataPtr := (*Ctensor)(unsafe.Pointer(¶msData[0]))
|
|
cparamsLen := *(*C.int)(unsafe.Pointer(¶msLen))
|
|
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)
|
|
}
|
|
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){
|
|
chxDataPtr := (*Ctensor)(unsafe.Pointer(&hxData[0]))
|
|
chxLen := *(*C.int)(unsafe.Pointer(&hxLen))
|
|
cparamsDataPtr := (*Ctensor)(unsafe.Pointer(¶msData[0]))
|
|
cparamsLen := *(*C.int)(unsafe.Pointer(¶msLen))
|
|
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))
|
|
C.atg_lstm1(ptr, data, batchSizes, chxDataPtr, chxLen, cparamsDataPtr, cparamsLen, chasBiases, cnumLayers, cdropout, ctrain, cbidirectional)
|
|
}
|
|
func AtgLstmCell(ptr *Ctensor, input Ctensor, hxData []Ctensor, hxLen int, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor){
|
|
chxDataPtr := (*Ctensor)(unsafe.Pointer(&hxData[0]))
|
|
chxLen := *(*C.int)(unsafe.Pointer(&hxLen))
|
|
C.atg_lstm_cell(ptr, input, chxDataPtr, chxLen, wIh, wHh, bIh, bHh)
|
|
}
|
|
func AtgLstsq(ptr *Ctensor, self Ctensor, a Ctensor){
|
|
C.atg_lstsq(ptr, self, a)
|
|
}
|
|
func AtgLstsqOut(ptr *Ctensor, x Ctensor, qr Ctensor, self Ctensor, a Ctensor){
|
|
C.atg_lstsq_out(ptr, x, qr, self, a)
|
|
}
|
|
func AtgLt(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_lt(ptr, self, other )
|
|
}
|
|
func AtgLt1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_lt1(ptr, self, other)
|
|
}
|
|
func AtgLt_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_lt_(ptr, self, other )
|
|
}
|
|
func AtgLt1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_lt_1(ptr, self, other)
|
|
}
|
|
func AtgLtOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_lt_out(ptr, out, self, other )
|
|
}
|
|
func AtgLtOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_lt_out1(ptr, out, self, other)
|
|
}
|
|
func AtgLuSolve(ptr *Ctensor, self Ctensor, lUData Ctensor, lUPivots Ctensor){
|
|
C.atg_lu_solve(ptr, self, lUData, lUPivots)
|
|
}
|
|
func AtgLuSolveOut(ptr *Ctensor, out Ctensor, self Ctensor, lUData Ctensor, lUPivots Ctensor){
|
|
C.atg_lu_solve_out(ptr, out, self, lUData, lUPivots)
|
|
}
|
|
func AtgMarginRankingLoss(ptr *Ctensor, input1 Ctensor, input2 Ctensor, target Ctensor, margin float64, reduction int64){
|
|
cmargin := *(*C.double)(unsafe.Pointer(&margin))
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_margin_ranking_loss(ptr, input1, input2, target, cmargin, creduction)
|
|
}
|
|
func AtgMaskedFill(ptr *Ctensor, self Ctensor, mask Ctensor, value Cscalar){
|
|
C.atg_masked_fill(ptr, self, mask, value )
|
|
}
|
|
func AtgMaskedFill1(ptr *Ctensor, self Ctensor, mask Ctensor, value Ctensor){
|
|
C.atg_masked_fill1(ptr, self, mask, value)
|
|
}
|
|
func AtgMaskedFill_(ptr *Ctensor, self Ctensor, mask Ctensor, value Cscalar){
|
|
C.atg_masked_fill_(ptr, self, mask, value )
|
|
}
|
|
func AtgMaskedFill1_(ptr *Ctensor, self Ctensor, mask Ctensor, value Ctensor){
|
|
C.atg_masked_fill_1(ptr, self, mask, value)
|
|
}
|
|
func AtgMaskedScatter(ptr *Ctensor, self Ctensor, mask Ctensor, source Ctensor){
|
|
C.atg_masked_scatter(ptr, self, mask, source)
|
|
}
|
|
func AtgMaskedScatter_(ptr *Ctensor, self Ctensor, mask Ctensor, source Ctensor){
|
|
C.atg_masked_scatter_(ptr, self, mask, source)
|
|
}
|
|
func AtgMaskedSelect(ptr *Ctensor, self Ctensor, mask Ctensor){
|
|
C.atg_masked_select(ptr, self, mask)
|
|
}
|
|
func AtgMaskedSelectBackward(ptr *Ctensor, grad Ctensor, input Ctensor, mask Ctensor){
|
|
C.atg_masked_select_backward(ptr, grad, input, mask)
|
|
}
|
|
func AtgMaskedSelectOut(ptr *Ctensor, out Ctensor, self Ctensor, mask Ctensor){
|
|
C.atg_masked_select_out(ptr, out, self, mask)
|
|
}
|
|
func AtgMatmul(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_matmul(ptr, self, other)
|
|
}
|
|
func AtgMatmulOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_matmul_out(ptr, out, self, other)
|
|
}
|
|
func AtgMatrixExp(ptr *Ctensor, self Ctensor){
|
|
C.atg_matrix_exp(ptr, self)
|
|
}
|
|
func AtgMatrixExpBackward(ptr *Ctensor, self Ctensor, grad Ctensor){
|
|
C.atg_matrix_exp_backward(ptr, self, grad)
|
|
}
|
|
func AtgMatrixPower(ptr *Ctensor, self Ctensor, n int64){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
C.atg_matrix_power(ptr, self, cn)
|
|
}
|
|
func AtgMatrixRank(ptr *Ctensor, self Ctensor, symmetric int32){
|
|
csymmetric := *(*C.int)(unsafe.Pointer(&symmetric))
|
|
C.atg_matrix_rank(ptr, self, csymmetric)
|
|
}
|
|
func AtgMatrixRank1(ptr *Ctensor, self Ctensor, tol float64, symmetric int32){
|
|
ctol := *(*C.double)(unsafe.Pointer(&tol))
|
|
csymmetric := *(*C.int)(unsafe.Pointer(&symmetric))
|
|
C.atg_matrix_rank1(ptr, self, ctol, csymmetric)
|
|
}
|
|
func AtgMax(ptr *Ctensor, self Ctensor){
|
|
C.atg_max(ptr, self)
|
|
}
|
|
func AtgMax1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_max1(ptr, self, other)
|
|
}
|
|
func AtgMax2(ptr *Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_max2(ptr, self, cdim, ckeepdim)
|
|
}
|
|
func AtgMaxOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_max_out(ptr, out, self, other)
|
|
}
|
|
func AtgMaxOut1(ptr *Ctensor, max Ctensor, maxValues Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_max_out1(ptr, max, maxValues, self, cdim, ckeepdim)
|
|
}
|
|
func AtgMaxPool1d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool1d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
func AtgMaxPool1dWithIndices(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool1d_with_indices(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
func AtgMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool2d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
func AtgMaxPool2dWithIndices(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool2d_with_indices(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool2d_with_indices_backward(ptr, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode, indices)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool2d_with_indices_backward_out(ptr, gradInput, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode, indices)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool2d_with_indices_out(ptr, out, indices, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
func AtgMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool3d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
func AtgMaxPool3dWithIndices(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool3d_with_indices(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool3d_with_indices_backward(ptr, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode, indices)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool3d_with_indices_backward_out(ptr, gradInput, gradOutput, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode, indices)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_max_pool3d_with_indices_out(ptr, out, indices, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
func AtgMaxUnpool2d(ptr *Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_max_unpool2d(ptr, self, indices, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgMaxUnpool2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_max_unpool2d_backward(ptr, gradOutput, self, indices, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgMaxUnpool2dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_max_unpool2d_backward_out(ptr, gradInput, gradOutput, self, indices, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgMaxUnpool2dOut(ptr *Ctensor, out Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_max_unpool2d_out(ptr, out, self, indices, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgMaxUnpool3d(ptr *Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_max_unpool3d(ptr, self, indices, coutputSizeDataPtr, coutputSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgMaxUnpool3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_max_unpool3d_backward(ptr, gradOutput, self, indices, coutputSizeDataPtr, coutputSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgMaxUnpool3dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_max_unpool3d_backward_out(ptr, gradInput, gradOutput, self, indices, coutputSizeDataPtr, coutputSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgMaxUnpool3dOut(ptr *Ctensor, out Ctensor, self Ctensor, indices Ctensor, outputSizeData []int64, outputSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_max_unpool3d_out(ptr, out, self, indices, coutputSizeDataPtr, coutputSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgMaximum(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_maximum(ptr, self, other)
|
|
}
|
|
func AtgMaximumOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_maximum_out(ptr, out, self, other)
|
|
}
|
|
func AtgMean(ptr *Ctensor, self Ctensor, dtype int32){
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_mean(ptr, self, cdtype)
|
|
}
|
|
func AtgMean1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_mean1(ptr, self, cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgMeanOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_mean_out(ptr, out, self, cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgMedian(ptr *Ctensor, self Ctensor){
|
|
C.atg_median(ptr, self)
|
|
}
|
|
func AtgMedian1(ptr *Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_median1(ptr, self, cdim, ckeepdim)
|
|
}
|
|
func AtgMedianOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_median_out(ptr, values, indices, self, cdim, ckeepdim)
|
|
}
|
|
|
|
func AtgMin(ptr *Ctensor, self Ctensor){
|
|
C.atg_min(ptr, self)
|
|
}
|
|
func AtgMin1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_min1(ptr, self, other)
|
|
}
|
|
func AtgMin2(ptr *Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_min2(ptr, self, cdim, ckeepdim)
|
|
}
|
|
func AtgMinOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_min_out(ptr, out, self, other)
|
|
}
|
|
func AtgMinOut1(ptr *Ctensor, min Ctensor, minIndices Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_min_out1(ptr, min, minIndices, self, cdim, ckeepdim)
|
|
}
|
|
func AtgMinimum(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_minimum(ptr, self, other)
|
|
}
|
|
func AtgMinimumOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_minimum_out(ptr, out, self, other)
|
|
}
|
|
func AtgMiopenBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, exponentialAverageFactor float64, epsilon float64){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
cexponentialAverageFactor := *(*C.double)(unsafe.Pointer(&exponentialAverageFactor))
|
|
cepsilon := *(*C.double)(unsafe.Pointer(&epsilon))
|
|
C.atg_miopen_batch_norm(ptr, input, weight, bias, runningMean, runningVar, ctraining, cexponentialAverageFactor, cepsilon)
|
|
}
|
|
func AtgMiopenBatchNormBackward(ptr *Ctensor, input Ctensor, gradOutput Ctensor, weight Ctensor, runningMean Ctensor, runningVar Ctensor, saveMean Ctensor, saveVar Ctensor, epsilon float64){
|
|
cepsilon := *(*C.double)(unsafe.Pointer(&epsilon))
|
|
C.atg_miopen_batch_norm_backward(ptr, input, gradOutput, weight, runningMean, runningVar, saveMean, saveVar, cepsilon)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_miopen_convolution(ptr, self, weight, bias, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
func AtgMiopenConvolutionBackwardBias(ptr *Ctensor, gradOutput Ctensor){
|
|
C.atg_miopen_convolution_backward_bias(ptr, gradOutput)
|
|
}
|
|
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){
|
|
cselfSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&selfSizeData[0]))
|
|
cselfSizeLen := *(*C.int)(unsafe.Pointer(&selfSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_miopen_convolution_backward_input(ptr, cselfSizeDataPtr, cselfSizeLen, gradOutput, weight, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cweightSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&weightSizeData[0]))
|
|
cweightSizeLen := *(*C.int)(unsafe.Pointer(&weightSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_miopen_convolution_backward_weight(ptr, cweightSizeDataPtr, cweightSizeLen, gradOutput, self, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_miopen_convolution_transpose(ptr, self, weight, bias, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_miopen_convolution_transpose_backward_input(ptr, gradOutput, weight, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cweightSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&weightSizeData[0]))
|
|
cweightSizeLen := *(*C.int)(unsafe.Pointer(&weightSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_miopen_convolution_transpose_backward_weight(ptr, cweightSizeDataPtr, cweightSizeLen, gradOutput, self, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_miopen_depthwise_convolution(ptr, self, weight, bias, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cselfSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&selfSizeData[0]))
|
|
cselfSizeLen := *(*C.int)(unsafe.Pointer(&selfSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_miopen_depthwise_convolution_backward_input(ptr, cselfSizeDataPtr, cselfSizeLen, gradOutput, weight, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cweightSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&weightSizeData[0]))
|
|
cweightSizeLen := *(*C.int)(unsafe.Pointer(&weightSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbenchmark := *(*C.int)(unsafe.Pointer(&benchmark))
|
|
cdeterministic := *(*C.int)(unsafe.Pointer(&deterministic))
|
|
C.atg_miopen_depthwise_convolution_backward_weight(ptr, cweightSizeDataPtr, cweightSizeLen, gradOutput, self, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbenchmark, cdeterministic)
|
|
}
|
|
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){
|
|
cweightDataPtr := (*Ctensor)(unsafe.Pointer(&weightData[0]))
|
|
cweightLen := *(*C.int)(unsafe.Pointer(&weightLen))
|
|
cweightStride0 := *(*C.int64_t)(unsafe.Pointer(&weightStride0))
|
|
cmode := *(*C.int64_t)(unsafe.Pointer(&mode))
|
|
chiddenSize := *(*C.int64_t)(unsafe.Pointer(&hiddenSize))
|
|
cnumLayers := *(*C.int64_t)(unsafe.Pointer(&numLayers))
|
|
cbatchFirst := *(*C.int)(unsafe.Pointer(&batchFirst))
|
|
cdropout := *(*C.double)(unsafe.Pointer(&dropout))
|
|
ctrain := *(*C.int)(unsafe.Pointer(&train))
|
|
cbidirectional := *(*C.int)(unsafe.Pointer(&bidirectional))
|
|
cbatchSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&batchSizesData[0]))
|
|
cbatchSizesLen := *(*C.int)(unsafe.Pointer(&batchSizesLen))
|
|
C.atg_miopen_rnn(ptr, input, cweightDataPtr, cweightLen, cweightStride0, hx, cx, cmode, chiddenSize, cnumLayers, cbatchFirst, cdropout, ctrain, cbidirectional, cbatchSizesDataPtr, cbatchSizesLen, dropoutState)
|
|
}
|
|
func AtgMkldnnAdaptiveAvgPool2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
C.atg_mkldnn_adaptive_avg_pool2d(ptr, self, coutputSizeDataPtr, coutputSizeLen)
|
|
}
|
|
func AtgMkldnnConvolution(ptr *Ctensor, self Ctensor, weight Ctensor, bias Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
C.atg_mkldnn_convolution(ptr, self, weight, bias, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups)
|
|
}
|
|
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){
|
|
cselfSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&selfSizeData[0]))
|
|
cselfSizeLen := *(*C.int)(unsafe.Pointer(&selfSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbiasDefined := *(*C.int)(unsafe.Pointer(&biasDefined))
|
|
C.atg_mkldnn_convolution_backward_input(ptr, cselfSizeDataPtr, cselfSizeLen, gradOutput, weight, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbiasDefined)
|
|
}
|
|
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){
|
|
cweightSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&weightSizeData[0]))
|
|
cweightSizeLen := *(*C.int)(unsafe.Pointer(&weightSizeLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
cbiasDefined := *(*C.int)(unsafe.Pointer(&biasDefined))
|
|
C.atg_mkldnn_convolution_backward_weights(ptr, cweightSizeDataPtr, cweightSizeLen, gradOutput, self, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups, cbiasDefined)
|
|
}
|
|
func AtgMkldnnLinear(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor){
|
|
C.atg_mkldnn_linear(ptr, input, weight, bias)
|
|
}
|
|
func AtgMkldnnMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_mkldnn_max_pool2d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
func AtgMkldnnMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_mkldnn_max_pool3d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
func AtgMkldnnReorderConv2dWeight(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
C.atg_mkldnn_reorder_conv2d_weight(ptr, self, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups)
|
|
}
|
|
func AtgMkldnnReorderConv3dWeight(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int, strideData []int64, strideLen int, dilationData []int64, dilationLen int, groups int64){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cgroups := *(*C.int64_t)(unsafe.Pointer(&groups))
|
|
C.atg_mkldnn_reorder_conv3d_weight(ptr, self, cpaddingDataPtr, cpaddingLen, cstrideDataPtr, cstrideLen, cdilationDataPtr, cdilationLen, cgroups)
|
|
}
|
|
func AtgMm(ptr *Ctensor, self Ctensor, mat2 Ctensor){
|
|
C.atg_mm(ptr, self, mat2)
|
|
}
|
|
func AtgMmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor){
|
|
C.atg_mm_out(ptr, out, self, mat2)
|
|
}
|
|
func AtgMode(ptr *Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_mode(ptr, self, cdim, ckeepdim)
|
|
}
|
|
func AtgModeOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_mode_out(ptr, values, indices, self, cdim, ckeepdim)
|
|
}
|
|
func AtgMovedim(ptr *Ctensor, self Ctensor, sourceData []int64, sourceLen int, destinationData []int64, destinationLen int){
|
|
csourceDataPtr := (*C.int64_t)(unsafe.Pointer(&sourceData[0]))
|
|
csourceLen := *(*C.int)(unsafe.Pointer(&sourceLen))
|
|
cdestinationDataPtr := (*C.int64_t)(unsafe.Pointer(&destinationData[0]))
|
|
cdestinationLen := *(*C.int)(unsafe.Pointer(&destinationLen))
|
|
C.atg_movedim(ptr, self, csourceDataPtr, csourceLen, cdestinationDataPtr, cdestinationLen)
|
|
}
|
|
func AtgMovedim1(ptr *Ctensor, self Ctensor, source int64, destination int64){
|
|
csource := *(*C.int64_t)(unsafe.Pointer(&source))
|
|
cdestination := *(*C.int64_t)(unsafe.Pointer(&destination))
|
|
C.atg_movedim1(ptr, self, csource, cdestination)
|
|
}
|
|
func AtgMseLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_mse_loss(ptr, self, target, creduction)
|
|
}
|
|
func AtgMseLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_mse_loss_backward(ptr, gradOutput, self, target, creduction)
|
|
}
|
|
func AtgMseLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_mse_loss_backward_out(ptr, gradInput, gradOutput, self, target, creduction)
|
|
}
|
|
func AtgMseLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_mse_loss_out(ptr, out, self, target, creduction)
|
|
}
|
|
func AtgMul(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_mul(ptr, self, other)
|
|
}
|
|
func AtgMul1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_mul1(ptr, self, other )
|
|
}
|
|
func AtgMul_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_mul_(ptr, self, other)
|
|
}
|
|
func AtgMul1_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_mul_1(ptr, self, other )
|
|
}
|
|
func AtgMulOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_mul_out(ptr, out, self, other)
|
|
}
|
|
func AtgMultiMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, p Cscalar, margin Cscalar, weight Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_multi_margin_loss_backward(ptr, gradOutput, self, target, p , margin , weight, creduction)
|
|
}
|
|
func AtgMultiMarginLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, p Cscalar, margin Cscalar, weight Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_multi_margin_loss_backward_out(ptr, gradInput, gradOutput, self, target, p , margin , weight, creduction)
|
|
}
|
|
func AtgMultilabelMarginLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_multilabel_margin_loss(ptr, self, target, creduction)
|
|
}
|
|
func AtgMultilabelMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, isTarget Ctensor){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_multilabel_margin_loss_backward(ptr, gradOutput, self, target, creduction, isTarget)
|
|
}
|
|
func AtgMultilabelMarginLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, isTarget Ctensor){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_multilabel_margin_loss_backward_out(ptr, gradInput, gradOutput, self, target, creduction, isTarget)
|
|
}
|
|
func AtgMultilabelMarginLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_multilabel_margin_loss_out(ptr, out, self, target, creduction)
|
|
}
|
|
func AtgMultinomial(ptr *Ctensor, self Ctensor, numSamples int64, replacement int32){
|
|
cnumSamples := *(*C.int64_t)(unsafe.Pointer(&numSamples))
|
|
creplacement := *(*C.int)(unsafe.Pointer(&replacement))
|
|
C.atg_multinomial(ptr, self, cnumSamples, creplacement)
|
|
}
|
|
func AtgMultinomialOut(ptr *Ctensor, out Ctensor, self Ctensor, numSamples int64, replacement int32){
|
|
cnumSamples := *(*C.int64_t)(unsafe.Pointer(&numSamples))
|
|
creplacement := *(*C.int)(unsafe.Pointer(&replacement))
|
|
C.atg_multinomial_out(ptr, out, self, cnumSamples, creplacement)
|
|
}
|
|
func AtgMultiply(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_multiply(ptr, self, other)
|
|
}
|
|
func AtgMultiply1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_multiply1(ptr, self, other )
|
|
}
|
|
func AtgMultiply_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_multiply_(ptr, self, other)
|
|
}
|
|
func AtgMultiply1_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_multiply_1(ptr, self, other )
|
|
}
|
|
func AtgMultiplyOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_multiply_out(ptr, out, self, other)
|
|
}
|
|
func AtgMv(ptr *Ctensor, self Ctensor, vec Ctensor){
|
|
C.atg_mv(ptr, self, vec)
|
|
}
|
|
func AtgMvOut(ptr *Ctensor, out Ctensor, self Ctensor, vec Ctensor){
|
|
C.atg_mv_out(ptr, out, self, vec)
|
|
}
|
|
func AtgMvlgamma(ptr *Ctensor, self Ctensor, p int64){
|
|
cp := *(*C.int64_t)(unsafe.Pointer(&p))
|
|
C.atg_mvlgamma(ptr, self, cp)
|
|
}
|
|
func AtgMvlgamma_(ptr *Ctensor, self Ctensor, p int64){
|
|
cp := *(*C.int64_t)(unsafe.Pointer(&p))
|
|
C.atg_mvlgamma_(ptr, self, cp)
|
|
}
|
|
func AtgNanquantile(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32){
|
|
cq := *(*C.double)(unsafe.Pointer(&q))
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_nanquantile(ptr, self, cq, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgNanquantile1(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_nanquantile1(ptr, self, q, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgNanquantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32){
|
|
cq := *(*C.double)(unsafe.Pointer(&q))
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_nanquantile_out(ptr, out, self, cq, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgNanquantileOut1(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_nanquantile_out1(ptr, out, self, q, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgNansum(ptr *Ctensor, self Ctensor, dtype int32){
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_nansum(ptr, self, cdtype)
|
|
}
|
|
func AtgNansum1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_nansum1(ptr, self, cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgNansumOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_nansum_out(ptr, out, self, cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgNarrow(ptr *Ctensor, self Ctensor, dim int64, start int64, length int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cstart := *(*C.int64_t)(unsafe.Pointer(&start))
|
|
clength := *(*C.int64_t)(unsafe.Pointer(&length))
|
|
C.atg_narrow(ptr, self, cdim, cstart, clength)
|
|
}
|
|
func AtgNarrow1(ptr *Ctensor, self Ctensor, dim int64, start Ctensor, length int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
clength := *(*C.int64_t)(unsafe.Pointer(&length))
|
|
C.atg_narrow1(ptr, self, cdim, start, clength)
|
|
}
|
|
func AtgNarrowCopy(ptr *Ctensor, self Ctensor, dim int64, start int64, length int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cstart := *(*C.int64_t)(unsafe.Pointer(&start))
|
|
clength := *(*C.int64_t)(unsafe.Pointer(&length))
|
|
C.atg_narrow_copy(ptr, self, cdim, cstart, clength)
|
|
}
|
|
func AtgNativeBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, momentum float64, eps float64){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
cmomentum := *(*C.double)(unsafe.Pointer(&momentum))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
C.atg_native_batch_norm(ptr, input, weight, bias, runningMean, runningVar, ctraining, cmomentum, ceps)
|
|
}
|
|
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){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
cmomentum := *(*C.double)(unsafe.Pointer(&momentum))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
C.atg_native_batch_norm_out(ptr, out, saveMean, saveInvstd, input, weight, bias, runningMean, runningVar, ctraining, cmomentum, ceps)
|
|
}
|
|
func AtgNativeGroupNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, n int64, c int64, hxW int64, group int64, eps float64){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
cc := *(*C.int64_t)(unsafe.Pointer(&c))
|
|
chxW := *(*C.int64_t)(unsafe.Pointer(&hxW))
|
|
cgroup := *(*C.int64_t)(unsafe.Pointer(&group))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
C.atg_native_group_norm(ptr, input, weight, bias, cn, cc, chxW, cgroup, ceps)
|
|
}
|
|
func AtgNativeLayerNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, m int64, n int64, eps float64){
|
|
cm := *(*C.int64_t)(unsafe.Pointer(&m))
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
C.atg_native_layer_norm(ptr, input, weight, bias, cm, cn, ceps)
|
|
}
|
|
func AtgNativeNorm(ptr *Ctensor, self Ctensor){
|
|
C.atg_native_norm(ptr, self)
|
|
}
|
|
func AtgNativeNorm1(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_native_norm1(ptr, self, p , cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgNe(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_ne(ptr, self, other )
|
|
}
|
|
func AtgNe1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_ne1(ptr, self, other)
|
|
}
|
|
func AtgNe_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_ne_(ptr, self, other )
|
|
}
|
|
func AtgNe1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_ne_1(ptr, self, other)
|
|
}
|
|
func AtgNeOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_ne_out(ptr, out, self, other )
|
|
}
|
|
func AtgNeOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_ne_out1(ptr, out, self, other)
|
|
}
|
|
func AtgNeg(ptr *Ctensor, self Ctensor){
|
|
C.atg_neg(ptr, self)
|
|
}
|
|
func AtgNeg_(ptr *Ctensor, self Ctensor){
|
|
C.atg_neg_(ptr, self)
|
|
}
|
|
func AtgNegOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_neg_out(ptr, out, self)
|
|
}
|
|
func AtgNegative(ptr *Ctensor, self Ctensor){
|
|
C.atg_negative(ptr, self)
|
|
}
|
|
func AtgNegative_(ptr *Ctensor, self Ctensor){
|
|
C.atg_negative_(ptr, self)
|
|
}
|
|
func AtgNegativeOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_negative_out(ptr, out, self)
|
|
}
|
|
func AtgNewEmpty(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_new_empty(ptr, self, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgNewFull(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, fillValue Cscalar, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_new_full(ptr, self, csizeDataPtr, csizeLen, fillValue , coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgNewZeros(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_new_zeros(ptr, self, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgNextafter(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_nextafter(ptr, self, other)
|
|
}
|
|
func AtgNextafter_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_nextafter_(ptr, self, other)
|
|
}
|
|
func AtgNextafterOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_nextafter_out(ptr, out, self, other)
|
|
}
|
|
func AtgNllLoss(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cignoreIndex := *(*C.int64_t)(unsafe.Pointer(&ignoreIndex))
|
|
C.atg_nll_loss(ptr, self, target, weight, creduction, cignoreIndex)
|
|
}
|
|
func AtgNllLoss2d(ptr *Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cignoreIndex := *(*C.int64_t)(unsafe.Pointer(&ignoreIndex))
|
|
C.atg_nll_loss2d(ptr, self, target, weight, creduction, cignoreIndex)
|
|
}
|
|
func AtgNllLoss2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, totalWeight Ctensor){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cignoreIndex := *(*C.int64_t)(unsafe.Pointer(&ignoreIndex))
|
|
C.atg_nll_loss2d_backward(ptr, gradOutput, self, target, weight, creduction, cignoreIndex, totalWeight)
|
|
}
|
|
func AtgNllLoss2dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, totalWeight Ctensor){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cignoreIndex := *(*C.int64_t)(unsafe.Pointer(&ignoreIndex))
|
|
C.atg_nll_loss2d_backward_out(ptr, gradInput, gradOutput, self, target, weight, creduction, cignoreIndex, totalWeight)
|
|
}
|
|
func AtgNllLoss2dOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cignoreIndex := *(*C.int64_t)(unsafe.Pointer(&ignoreIndex))
|
|
C.atg_nll_loss2d_out(ptr, out, self, target, weight, creduction, cignoreIndex)
|
|
}
|
|
func AtgNllLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, totalWeight Ctensor){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cignoreIndex := *(*C.int64_t)(unsafe.Pointer(&ignoreIndex))
|
|
C.atg_nll_loss_backward(ptr, gradOutput, self, target, weight, creduction, cignoreIndex, totalWeight)
|
|
}
|
|
func AtgNllLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64, totalWeight Ctensor){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cignoreIndex := *(*C.int64_t)(unsafe.Pointer(&ignoreIndex))
|
|
C.atg_nll_loss_backward_out(ptr, gradInput, gradOutput, self, target, weight, creduction, cignoreIndex, totalWeight)
|
|
}
|
|
func AtgNllLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, weight Ctensor, reduction int64, ignoreIndex int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cignoreIndex := *(*C.int64_t)(unsafe.Pointer(&ignoreIndex))
|
|
C.atg_nll_loss_out(ptr, out, self, target, weight, creduction, cignoreIndex)
|
|
}
|
|
func AtgNonzero(ptr *Ctensor, self Ctensor){
|
|
C.atg_nonzero(ptr, self)
|
|
}
|
|
|
|
func AtgNonzeroOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_nonzero_out(ptr, out, self)
|
|
}
|
|
func AtgNorm(ptr *Ctensor, self Ctensor){
|
|
C.atg_norm(ptr, self)
|
|
}
|
|
func AtgNorm1(ptr *Ctensor, self Ctensor, p Cscalar, dtype int32){
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_norm1(ptr, self, p , cdtype)
|
|
}
|
|
func AtgNorm2(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_norm2(ptr, self, p , cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgNorm3(ptr *Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_norm3(ptr, self, p , cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgNormExceptDim(ptr *Ctensor, v Ctensor, pow int64, dim int64){
|
|
cpow := *(*C.int64_t)(unsafe.Pointer(&pow))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_norm_except_dim(ptr, v, cpow, cdim)
|
|
}
|
|
func AtgNormOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_norm_out(ptr, out, self, p , cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgNormOut1(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_norm_out1(ptr, out, self, p , cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgNormal_(ptr *Ctensor, self Ctensor, mean float64, std float64){
|
|
cmean := *(*C.double)(unsafe.Pointer(&mean))
|
|
cstd := *(*C.double)(unsafe.Pointer(&std))
|
|
C.atg_normal_(ptr, self, cmean, cstd)
|
|
}
|
|
func AtgNormalOut(ptr *Ctensor, out Ctensor, mean Ctensor, std float64){
|
|
cstd := *(*C.double)(unsafe.Pointer(&std))
|
|
C.atg_normal_out(ptr, out, mean, cstd)
|
|
}
|
|
func AtgNormalOut1(ptr *Ctensor, out Ctensor, mean float64, std Ctensor){
|
|
cmean := *(*C.double)(unsafe.Pointer(&mean))
|
|
C.atg_normal_out1(ptr, out, cmean, std)
|
|
}
|
|
func AtgNormalOut2(ptr *Ctensor, out Ctensor, mean Ctensor, std Ctensor){
|
|
C.atg_normal_out2(ptr, out, mean, std)
|
|
}
|
|
func AtgNormalOut3(ptr *Ctensor, out Ctensor, mean float64, std float64, sizeData []int64, sizeLen int){
|
|
cmean := *(*C.double)(unsafe.Pointer(&mean))
|
|
cstd := *(*C.double)(unsafe.Pointer(&std))
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_normal_out3(ptr, out, cmean, cstd, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgNotEqual(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_not_equal(ptr, self, other )
|
|
}
|
|
func AtgNotEqual1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_not_equal1(ptr, self, other)
|
|
}
|
|
func AtgNotEqual_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_not_equal_(ptr, self, other )
|
|
}
|
|
func AtgNotEqual1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_not_equal_1(ptr, self, other)
|
|
}
|
|
func AtgNotEqualOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_not_equal_out(ptr, out, self, other )
|
|
}
|
|
func AtgNotEqualOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_not_equal_out1(ptr, out, self, other)
|
|
}
|
|
func AtgNuclearNorm(ptr *Ctensor, self Ctensor, keepdim int32){
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_nuclear_norm(ptr, self, ckeepdim)
|
|
}
|
|
func AtgNuclearNorm1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_nuclear_norm1(ptr, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgNuclearNormOut(ptr *Ctensor, out Ctensor, self Ctensor, keepdim int32){
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_nuclear_norm_out(ptr, out, self, ckeepdim)
|
|
}
|
|
func AtgNuclearNormOut1(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_nuclear_norm_out1(ptr, out, self, cdimDataPtr, cdimLen, ckeepdim)
|
|
}
|
|
func AtgNumpyT(ptr *Ctensor, self Ctensor){
|
|
C.atg_numpy_t(ptr, self)
|
|
}
|
|
func AtgOneHot(ptr *Ctensor, self Ctensor, numClasses int64){
|
|
cnumClasses := *(*C.int64_t)(unsafe.Pointer(&numClasses))
|
|
C.atg_one_hot(ptr, self, cnumClasses)
|
|
}
|
|
func AtgOnes(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_ones(ptr, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgOnesLike(ptr *Ctensor, self Ctensor){
|
|
C.atg_ones_like(ptr, self)
|
|
}
|
|
func AtgOnesOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_ones_out(ptr, out, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgOrgqr(ptr *Ctensor, self Ctensor, input2 Ctensor){
|
|
C.atg_orgqr(ptr, self, input2)
|
|
}
|
|
func AtgOrgqrOut(ptr *Ctensor, out Ctensor, self Ctensor, input2 Ctensor){
|
|
C.atg_orgqr_out(ptr, out, self, input2)
|
|
}
|
|
func AtgOrmqr(ptr *Ctensor, self Ctensor, input2 Ctensor, input3 Ctensor, left int32, transpose int32){
|
|
cleft := *(*C.int)(unsafe.Pointer(&left))
|
|
ctranspose := *(*C.int)(unsafe.Pointer(&transpose))
|
|
C.atg_ormqr(ptr, self, input2, input3, cleft, ctranspose)
|
|
}
|
|
func AtgOrmqrOut(ptr *Ctensor, out Ctensor, self Ctensor, input2 Ctensor, input3 Ctensor, left int32, transpose int32){
|
|
cleft := *(*C.int)(unsafe.Pointer(&left))
|
|
ctranspose := *(*C.int)(unsafe.Pointer(&transpose))
|
|
C.atg_ormqr_out(ptr, out, self, input2, input3, cleft, ctranspose)
|
|
}
|
|
func AtgOuter(ptr *Ctensor, self Ctensor, vec2 Ctensor){
|
|
C.atg_outer(ptr, self, vec2)
|
|
}
|
|
func AtgOuterOut(ptr *Ctensor, out Ctensor, self Ctensor, vec2 Ctensor){
|
|
C.atg_outer_out(ptr, out, self, vec2)
|
|
}
|
|
func AtgPairwiseDistance(ptr *Ctensor, x1 Ctensor, x2 Ctensor, p float64, eps float64, keepdim int32){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_pairwise_distance(ptr, x1, x2, cp, ceps, ckeepdim)
|
|
}
|
|
func AtgPdist(ptr *Ctensor, self Ctensor, p float64){
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
C.atg_pdist(ptr, self, cp)
|
|
}
|
|
func AtgPermute(ptr *Ctensor, self Ctensor, dimsData []int64, dimsLen int){
|
|
cdimsDataPtr := (*C.int64_t)(unsafe.Pointer(&dimsData[0]))
|
|
cdimsLen := *(*C.int)(unsafe.Pointer(&dimsLen))
|
|
C.atg_permute(ptr, self, cdimsDataPtr, cdimsLen)
|
|
}
|
|
func AtgPinMemory(ptr *Ctensor, self Ctensor){
|
|
C.atg_pin_memory(ptr, self)
|
|
}
|
|
func AtgPinverse(ptr *Ctensor, self Ctensor, rcond float64){
|
|
crcond := *(*C.double)(unsafe.Pointer(&rcond))
|
|
C.atg_pinverse(ptr, self, crcond)
|
|
}
|
|
func AtgPixelShuffle(ptr *Ctensor, self Ctensor, upscaleFactor int64){
|
|
cupscaleFactor := *(*C.int64_t)(unsafe.Pointer(&upscaleFactor))
|
|
C.atg_pixel_shuffle(ptr, self, cupscaleFactor)
|
|
}
|
|
func AtgPoisson(ptr *Ctensor, self Ctensor){
|
|
C.atg_poisson(ptr, self)
|
|
}
|
|
func AtgPoissonNllLoss(ptr *Ctensor, input Ctensor, target Ctensor, logInput int32, full int32, eps float64, reduction int64){
|
|
clogInput := *(*C.int)(unsafe.Pointer(&logInput))
|
|
cfull := *(*C.int)(unsafe.Pointer(&full))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_poisson_nll_loss(ptr, input, target, clogInput, cfull, ceps, creduction)
|
|
}
|
|
func AtgPolar(ptr *Ctensor, abs Ctensor, angle Ctensor){
|
|
C.atg_polar(ptr, abs, angle)
|
|
}
|
|
func AtgPolarOut(ptr *Ctensor, out Ctensor, abs Ctensor, angle Ctensor){
|
|
C.atg_polar_out(ptr, out, abs, angle)
|
|
}
|
|
func AtgPolygamma(ptr *Ctensor, n int64, self Ctensor){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
C.atg_polygamma(ptr, cn, self)
|
|
}
|
|
func AtgPolygamma_(ptr *Ctensor, self Ctensor, n int64){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
C.atg_polygamma_(ptr, self, cn)
|
|
}
|
|
func AtgPolygammaOut(ptr *Ctensor, out Ctensor, n int64, self Ctensor){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
C.atg_polygamma_out(ptr, out, cn, self)
|
|
}
|
|
func AtgPow(ptr *Ctensor, self Ctensor, exponent Cscalar){
|
|
C.atg_pow(ptr, self, exponent )
|
|
}
|
|
func AtgPow1(ptr *Ctensor, self Ctensor, exponent Ctensor){
|
|
C.atg_pow1(ptr, self, exponent)
|
|
}
|
|
func AtgPow2(ptr *Ctensor, selfScalar Cscalar, exponent Ctensor){
|
|
C.atg_pow2(ptr, selfScalar , exponent)
|
|
}
|
|
func AtgPow_(ptr *Ctensor, self Ctensor, exponent Cscalar){
|
|
C.atg_pow_(ptr, self, exponent )
|
|
}
|
|
func AtgPow1_(ptr *Ctensor, self Ctensor, exponent Ctensor){
|
|
C.atg_pow_1(ptr, self, exponent)
|
|
}
|
|
func AtgPowOut(ptr *Ctensor, out Ctensor, self Ctensor, exponent Cscalar){
|
|
C.atg_pow_out(ptr, out, self, exponent )
|
|
}
|
|
func AtgPowOut1(ptr *Ctensor, out Ctensor, self Ctensor, exponent Ctensor){
|
|
C.atg_pow_out1(ptr, out, self, exponent)
|
|
}
|
|
func AtgPowOut2(ptr *Ctensor, out Ctensor, selfScalar Cscalar, exponent Ctensor){
|
|
C.atg_pow_out2(ptr, out, selfScalar , exponent)
|
|
}
|
|
func AtgPrelu(ptr *Ctensor, self Ctensor, weight Ctensor){
|
|
C.atg_prelu(ptr, self, weight)
|
|
}
|
|
func AtgPreluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, weight Ctensor){
|
|
C.atg_prelu_backward(ptr, gradOutput, self, weight)
|
|
}
|
|
func AtgProd(ptr *Ctensor, self Ctensor, dtype int32){
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_prod(ptr, self, cdtype)
|
|
}
|
|
func AtgProd1(ptr *Ctensor, self Ctensor, dim int64, keepdim int32, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_prod1(ptr, self, cdim, ckeepdim, cdtype)
|
|
}
|
|
func AtgProdOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, keepdim int32, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_prod_out(ptr, out, self, cdim, ckeepdim, cdtype)
|
|
}
|
|
func AtgPut_(ptr *Ctensor, self Ctensor, index Ctensor, source Ctensor, accumulate int32){
|
|
caccumulate := *(*C.int)(unsafe.Pointer(&accumulate))
|
|
C.atg_put_(ptr, self, index, source, caccumulate)
|
|
}
|
|
func AtgQPerChannelScales(ptr *Ctensor, self Ctensor){
|
|
C.atg_q_per_channel_scales(ptr, self)
|
|
}
|
|
func AtgQPerChannelZeroPoints(ptr *Ctensor, self Ctensor){
|
|
C.atg_q_per_channel_zero_points(ptr, self)
|
|
}
|
|
func AtgQr(ptr *Ctensor, self Ctensor, some int32){
|
|
csome := *(*C.int)(unsafe.Pointer(&some))
|
|
C.atg_qr(ptr, self, csome)
|
|
}
|
|
func AtgQrOut(ptr *Ctensor, q Ctensor, r Ctensor, self Ctensor, some int32){
|
|
csome := *(*C.int)(unsafe.Pointer(&some))
|
|
C.atg_qr_out(ptr, q, r, self, csome)
|
|
}
|
|
func AtgQuantile(ptr *Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32){
|
|
cq := *(*C.double)(unsafe.Pointer(&q))
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_quantile(ptr, self, cq, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgQuantile1(ptr *Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_quantile1(ptr, self, q, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgQuantileOut(ptr *Ctensor, out Ctensor, self Ctensor, q float64, dimVal int64, dimNull int, keepdim int32){
|
|
cq := *(*C.double)(unsafe.Pointer(&q))
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_quantile_out(ptr, out, self, cq, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgQuantileOut1(ptr *Ctensor, out Ctensor, self Ctensor, q Ctensor, dimVal int64, dimNull int, keepdim int32){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_quantile_out1(ptr, out, self, q, cdimVal, cdimNull, ckeepdim)
|
|
}
|
|
func AtgQuantizePerChannel(ptr *Ctensor, self Ctensor, scales Ctensor, zeroPoints Ctensor, axis int64, dtype int32){
|
|
caxis := *(*C.int64_t)(unsafe.Pointer(&axis))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_quantize_per_channel(ptr, self, scales, zeroPoints, caxis, cdtype)
|
|
}
|
|
func AtgQuantizePerTensor(ptr *Ctensor, self Ctensor, scale float64, zeroPoint int64, dtype int32){
|
|
cscale := *(*C.double)(unsafe.Pointer(&scale))
|
|
czeroPoint := *(*C.int64_t)(unsafe.Pointer(&zeroPoint))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_quantize_per_tensor(ptr, self, cscale, czeroPoint, cdtype)
|
|
}
|
|
|
|
func AtgQuantizedBatchNorm(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, mean Ctensor, vari Ctensor, eps float64, outputScale float64, outputZeroPoint int64){
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
coutputScale := *(*C.double)(unsafe.Pointer(&outputScale))
|
|
coutputZeroPoint := *(*C.int64_t)(unsafe.Pointer(&outputZeroPoint))
|
|
C.atg_quantized_batch_norm(ptr, input, weight, bias, mean, vari, ceps, coutputScale, coutputZeroPoint)
|
|
}
|
|
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){
|
|
C.atg_quantized_gru_cell(ptr, input, hx, wIh, wHh, bIh, bHh, packedIh, packedHh, colOffsetsIh, colOffsetsHh, scaleIh , scaleHh , zeroPointIh , zeroPointHh )
|
|
}
|
|
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){
|
|
chxDataPtr := (*Ctensor)(unsafe.Pointer(&hxData[0]))
|
|
chxLen := *(*C.int)(unsafe.Pointer(&hxLen))
|
|
C.atg_quantized_lstm_cell(ptr, input, chxDataPtr, chxLen, wIh, wHh, bIh, bHh, packedIh, packedHh, colOffsetsIh, colOffsetsHh, scaleIh , scaleHh , zeroPointIh , zeroPointHh )
|
|
}
|
|
func AtgQuantizedMaxPool1d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_quantized_max_pool1d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
func AtgQuantizedMaxPool2d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode))
|
|
C.atg_quantized_max_pool2d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode)
|
|
}
|
|
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){
|
|
C.atg_quantized_rnn_relu_cell(ptr, input, hx, wIh, wHh, bIh, bHh, packedIh, packedHh, colOffsetsIh, colOffsetsHh, scaleIh , scaleHh , zeroPointIh , zeroPointHh )
|
|
}
|
|
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){
|
|
C.atg_quantized_rnn_tanh_cell(ptr, input, hx, wIh, wHh, bIh, bHh, packedIh, packedHh, colOffsetsIh, colOffsetsHh, scaleIh , scaleHh , zeroPointIh , zeroPointHh )
|
|
}
|
|
func AtgRad2deg(ptr *Ctensor, self Ctensor){
|
|
C.atg_rad2deg(ptr, self)
|
|
}
|
|
func AtgRad2deg_(ptr *Ctensor, self Ctensor){
|
|
C.atg_rad2deg_(ptr, self)
|
|
}
|
|
func AtgRad2degOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_rad2deg_out(ptr, out, self)
|
|
}
|
|
func AtgRand(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_rand(ptr, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgRandLike(ptr *Ctensor, self Ctensor){
|
|
C.atg_rand_like(ptr, self)
|
|
}
|
|
func AtgRandOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_rand_out(ptr, out, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgRandint(ptr *Ctensor, high int64, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
chigh := *(*C.int64_t)(unsafe.Pointer(&high))
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_randint(ptr, chigh, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgRandint1(ptr *Ctensor, low int64, high int64, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
clow := *(*C.int64_t)(unsafe.Pointer(&low))
|
|
chigh := *(*C.int64_t)(unsafe.Pointer(&high))
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_randint1(ptr, clow, chigh, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgRandintLike(ptr *Ctensor, self Ctensor, high int64){
|
|
chigh := *(*C.int64_t)(unsafe.Pointer(&high))
|
|
C.atg_randint_like(ptr, self, chigh)
|
|
}
|
|
func AtgRandintLike1(ptr *Ctensor, self Ctensor, low int64, high int64){
|
|
clow := *(*C.int64_t)(unsafe.Pointer(&low))
|
|
chigh := *(*C.int64_t)(unsafe.Pointer(&high))
|
|
C.atg_randint_like1(ptr, self, clow, chigh)
|
|
}
|
|
func AtgRandintOut(ptr *Ctensor, out Ctensor, high int64, sizeData []int64, sizeLen int){
|
|
chigh := *(*C.int64_t)(unsafe.Pointer(&high))
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_randint_out(ptr, out, chigh, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgRandintOut1(ptr *Ctensor, out Ctensor, low int64, high int64, sizeData []int64, sizeLen int){
|
|
clow := *(*C.int64_t)(unsafe.Pointer(&low))
|
|
chigh := *(*C.int64_t)(unsafe.Pointer(&high))
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_randint_out1(ptr, out, clow, chigh, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgRandn(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_randn(ptr, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgRandnLike(ptr *Ctensor, self Ctensor){
|
|
C.atg_randn_like(ptr, self)
|
|
}
|
|
func AtgRandnOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_randn_out(ptr, out, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgRandom_(ptr *Ctensor, self Ctensor){
|
|
C.atg_random_(ptr, self)
|
|
}
|
|
func AtgRandom1_(ptr *Ctensor, self Ctensor, to int64){
|
|
cto := *(*C.int64_t)(unsafe.Pointer(&to))
|
|
C.atg_random_1(ptr, self, cto)
|
|
}
|
|
func AtgRandom2(ptr *Ctensor, self Ctensor, from int64, toVal int64, toNull int){
|
|
cfrom := *(*C.int64_t)(unsafe.Pointer(&from))
|
|
ctoVal := *(*C.int64_t)(unsafe.Pointer(&toVal))
|
|
ctoNull := *(*C.uint8_t)(unsafe.Pointer(&toNull))
|
|
C.atg_random_2(ptr, self, cfrom, ctoVal, ctoNull)
|
|
}
|
|
func AtgRandperm(ptr *Ctensor, n int64, optionsKind int32, optionsDevice int32){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_randperm(ptr, cn, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgRandpermOut(ptr *Ctensor, out Ctensor, n int64){
|
|
cn := *(*C.int64_t)(unsafe.Pointer(&n))
|
|
C.atg_randperm_out(ptr, out, cn)
|
|
}
|
|
func AtgRange(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, optionsDevice int32){
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_range(ptr, start , end , coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgRange1(ptr *Ctensor, start Cscalar, end Cscalar, optionsKind int32, optionsDevice int32){
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_range1(ptr, start , end , coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgRangeOut(ptr *Ctensor, out Ctensor, start Cscalar, end Cscalar){
|
|
C.atg_range_out(ptr, out, start , end )
|
|
}
|
|
func AtgReal(ptr *Ctensor, self Ctensor){
|
|
C.atg_real(ptr, self)
|
|
}
|
|
func AtgReciprocal(ptr *Ctensor, self Ctensor){
|
|
C.atg_reciprocal(ptr, self)
|
|
}
|
|
func AtgReciprocal_(ptr *Ctensor, self Ctensor){
|
|
C.atg_reciprocal_(ptr, self)
|
|
}
|
|
func AtgReciprocalOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_reciprocal_out(ptr, out, self)
|
|
}
|
|
func AtgReflectionPad1d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_reflection_pad1d(ptr, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReflectionPad1dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_reflection_pad1d_backward(ptr, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReflectionPad1dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_reflection_pad1d_backward_out(ptr, gradInput, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReflectionPad1dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_reflection_pad1d_out(ptr, out, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReflectionPad2d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_reflection_pad2d(ptr, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReflectionPad2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_reflection_pad2d_backward(ptr, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReflectionPad2dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_reflection_pad2d_backward_out(ptr, gradInput, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReflectionPad2dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_reflection_pad2d_out(ptr, out, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgRelu(ptr *Ctensor, self Ctensor){
|
|
C.atg_relu(ptr, self)
|
|
}
|
|
func AtgRelu_(ptr *Ctensor, self Ctensor){
|
|
C.atg_relu_(ptr, self)
|
|
}
|
|
func AtgRemainder(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_remainder(ptr, self, other )
|
|
}
|
|
func AtgRemainder1(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_remainder1(ptr, self, other)
|
|
}
|
|
func AtgRemainder_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_remainder_(ptr, self, other )
|
|
}
|
|
func AtgRemainder1_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_remainder_1(ptr, self, other)
|
|
}
|
|
func AtgRemainderOut(ptr *Ctensor, out Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_remainder_out(ptr, out, self, other )
|
|
}
|
|
func AtgRemainderOut1(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_remainder_out1(ptr, out, self, other)
|
|
}
|
|
func AtgRenorm(ptr *Ctensor, self Ctensor, p Cscalar, dim int64, maxnorm Cscalar){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_renorm(ptr, self, p , cdim, maxnorm )
|
|
}
|
|
func AtgRenorm_(ptr *Ctensor, self Ctensor, p Cscalar, dim int64, maxnorm Cscalar){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_renorm_(ptr, self, p , cdim, maxnorm )
|
|
}
|
|
func AtgRenormOut(ptr *Ctensor, out Ctensor, self Ctensor, p Cscalar, dim int64, maxnorm Cscalar){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_renorm_out(ptr, out, self, p , cdim, maxnorm )
|
|
}
|
|
func AtgRepeat(ptr *Ctensor, self Ctensor, repeatsData []int64, repeatsLen int){
|
|
crepeatsDataPtr := (*C.int64_t)(unsafe.Pointer(&repeatsData[0]))
|
|
crepeatsLen := *(*C.int)(unsafe.Pointer(&repeatsLen))
|
|
C.atg_repeat(ptr, self, crepeatsDataPtr, crepeatsLen)
|
|
}
|
|
func AtgRepeatInterleave(ptr *Ctensor, repeats Ctensor){
|
|
C.atg_repeat_interleave(ptr, repeats)
|
|
}
|
|
func AtgRepeatInterleave1(ptr *Ctensor, self Ctensor, repeats Ctensor, dimVal int64, dimNull int){
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
C.atg_repeat_interleave1(ptr, self, repeats, cdimVal, cdimNull)
|
|
}
|
|
func AtgRepeatInterleave2(ptr *Ctensor, self Ctensor, repeats int64, dimVal int64, dimNull int){
|
|
crepeats := *(*C.int64_t)(unsafe.Pointer(&repeats))
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
C.atg_repeat_interleave2(ptr, self, crepeats, cdimVal, cdimNull)
|
|
}
|
|
func AtgReplicationPad1d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad1d(ptr, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad1dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad1d_backward(ptr, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad1dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad1d_backward_out(ptr, gradInput, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad1dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad1d_out(ptr, out, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad2d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad2d(ptr, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad2dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad2d_backward(ptr, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad2dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad2d_backward_out(ptr, gradInput, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad2dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad2d_out(ptr, out, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad3d(ptr *Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad3d(ptr, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad3dBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad3d_backward(ptr, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad3dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad3d_backward_out(ptr, gradInput, gradOutput, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgReplicationPad3dOut(ptr *Ctensor, out Ctensor, self Ctensor, paddingData []int64, paddingLen int){
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_replication_pad3d_out(ptr, out, self, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgRequiresGrad_(ptr *Ctensor, self Ctensor, requiresGrad int32){
|
|
crequiresGrad := *(*C.int)(unsafe.Pointer(&requiresGrad))
|
|
C.atg_requires_grad_(ptr, self, crequiresGrad)
|
|
}
|
|
func AtgReshape(ptr *Ctensor, self Ctensor, shapeData []int64, shapeLen int){
|
|
cshapeDataPtr := (*C.int64_t)(unsafe.Pointer(&shapeData[0]))
|
|
cshapeLen := *(*C.int)(unsafe.Pointer(&shapeLen))
|
|
C.atg_reshape(ptr, self, cshapeDataPtr, cshapeLen)
|
|
}
|
|
func AtgReshapeAs(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_reshape_as(ptr, self, other)
|
|
}
|
|
func AtgResize_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_resize_(ptr, self, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgResizeAs_(ptr *Ctensor, self Ctensor, theTemplate Ctensor){
|
|
C.atg_resize_as_(ptr, self, theTemplate)
|
|
}
|
|
func AtgRfft(ptr *Ctensor, self Ctensor, signalNdim int64, normalized int32, onesided int32){
|
|
csignalNdim := *(*C.int64_t)(unsafe.Pointer(&signalNdim))
|
|
cnormalized := *(*C.int)(unsafe.Pointer(&normalized))
|
|
conesided := *(*C.int)(unsafe.Pointer(&onesided))
|
|
C.atg_rfft(ptr, self, csignalNdim, cnormalized, conesided)
|
|
}
|
|
func AtgRnnRelu(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32, batchFirst int32){
|
|
cparamsDataPtr := (*Ctensor)(unsafe.Pointer(¶msData[0]))
|
|
cparamsLen := *(*C.int)(unsafe.Pointer(¶msLen))
|
|
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_rnn_relu(ptr, input, hx, cparamsDataPtr, cparamsLen, chasBiases, cnumLayers, cdropout, ctrain, cbidirectional, cbatchFirst)
|
|
}
|
|
func AtgRnnRelu1(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32){
|
|
cparamsDataPtr := (*Ctensor)(unsafe.Pointer(¶msData[0]))
|
|
cparamsLen := *(*C.int)(unsafe.Pointer(¶msLen))
|
|
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))
|
|
C.atg_rnn_relu1(ptr, data, batchSizes, hx, cparamsDataPtr, cparamsLen, chasBiases, cnumLayers, cdropout, ctrain, cbidirectional)
|
|
}
|
|
func AtgRnnReluCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor){
|
|
C.atg_rnn_relu_cell(ptr, input, hx, wIh, wHh, bIh, bHh)
|
|
}
|
|
func AtgRnnTanh(ptr *Ctensor, input Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32, batchFirst int32){
|
|
cparamsDataPtr := (*Ctensor)(unsafe.Pointer(¶msData[0]))
|
|
cparamsLen := *(*C.int)(unsafe.Pointer(¶msLen))
|
|
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_rnn_tanh(ptr, input, hx, cparamsDataPtr, cparamsLen, chasBiases, cnumLayers, cdropout, ctrain, cbidirectional, cbatchFirst)
|
|
}
|
|
func AtgRnnTanh1(ptr *Ctensor, data Ctensor, batchSizes Ctensor, hx Ctensor, paramsData []Ctensor, paramsLen int, hasBiases int32, numLayers int64, dropout float64, train int32, bidirectional int32){
|
|
cparamsDataPtr := (*Ctensor)(unsafe.Pointer(¶msData[0]))
|
|
cparamsLen := *(*C.int)(unsafe.Pointer(¶msLen))
|
|
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))
|
|
C.atg_rnn_tanh1(ptr, data, batchSizes, hx, cparamsDataPtr, cparamsLen, chasBiases, cnumLayers, cdropout, ctrain, cbidirectional)
|
|
}
|
|
func AtgRnnTanhCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor){
|
|
C.atg_rnn_tanh_cell(ptr, input, hx, wIh, wHh, bIh, bHh)
|
|
}
|
|
func AtgRoll(ptr *Ctensor, self Ctensor, shiftsData []int64, shiftsLen int, dimsData []int64, dimsLen int){
|
|
cshiftsDataPtr := (*C.int64_t)(unsafe.Pointer(&shiftsData[0]))
|
|
cshiftsLen := *(*C.int)(unsafe.Pointer(&shiftsLen))
|
|
cdimsDataPtr := (*C.int64_t)(unsafe.Pointer(&dimsData[0]))
|
|
cdimsLen := *(*C.int)(unsafe.Pointer(&dimsLen))
|
|
C.atg_roll(ptr, self, cshiftsDataPtr, cshiftsLen, cdimsDataPtr, cdimsLen)
|
|
}
|
|
func AtgRot90(ptr *Ctensor, self Ctensor, k int64, dimsData []int64, dimsLen int){
|
|
ck := *(*C.int64_t)(unsafe.Pointer(&k))
|
|
cdimsDataPtr := (*C.int64_t)(unsafe.Pointer(&dimsData[0]))
|
|
cdimsLen := *(*C.int)(unsafe.Pointer(&dimsLen))
|
|
C.atg_rot90(ptr, self, ck, cdimsDataPtr, cdimsLen)
|
|
}
|
|
func AtgRound(ptr *Ctensor, self Ctensor){
|
|
C.atg_round(ptr, self)
|
|
}
|
|
func AtgRound_(ptr *Ctensor, self Ctensor){
|
|
C.atg_round_(ptr, self)
|
|
}
|
|
func AtgRoundOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_round_out(ptr, out, self)
|
|
}
|
|
func AtgRrelu(ptr *Ctensor, self Ctensor, training int32){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
C.atg_rrelu(ptr, self, ctraining)
|
|
}
|
|
func AtgRrelu_(ptr *Ctensor, self Ctensor, training int32){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
C.atg_rrelu_(ptr, self, ctraining)
|
|
}
|
|
func AtgRreluWithNoise(ptr *Ctensor, self Ctensor, noise Ctensor, training int32){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
C.atg_rrelu_with_noise(ptr, self, noise, ctraining)
|
|
}
|
|
func AtgRreluWithNoise_(ptr *Ctensor, self Ctensor, noise Ctensor, training int32){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
C.atg_rrelu_with_noise_(ptr, self, noise, ctraining)
|
|
}
|
|
func AtgRreluWithNoiseBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, noise Ctensor, lower Cscalar, upper Cscalar, training int32, selfIsResult int32){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
cselfIsResult := *(*C.int)(unsafe.Pointer(&selfIsResult))
|
|
C.atg_rrelu_with_noise_backward(ptr, gradOutput, self, noise, lower , upper , ctraining, cselfIsResult)
|
|
}
|
|
func AtgRreluWithNoiseOut(ptr *Ctensor, out Ctensor, self Ctensor, noise Ctensor, training int32){
|
|
ctraining := *(*C.int)(unsafe.Pointer(&training))
|
|
C.atg_rrelu_with_noise_out(ptr, out, self, noise, ctraining)
|
|
}
|
|
func AtgRsqrt(ptr *Ctensor, self Ctensor){
|
|
C.atg_rsqrt(ptr, self)
|
|
}
|
|
func AtgRsqrt_(ptr *Ctensor, self Ctensor){
|
|
C.atg_rsqrt_(ptr, self)
|
|
}
|
|
func AtgRsqrtOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_rsqrt_out(ptr, out, self)
|
|
}
|
|
func AtgRsub(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_rsub(ptr, self, other)
|
|
}
|
|
func AtgRsub1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_rsub1(ptr, self, other )
|
|
}
|
|
func AtgScalarTensor(ptr *Ctensor, s Cscalar, optionsKind int32, optionsDevice int32){
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_scalar_tensor(ptr, s , coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgScatter(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_scatter(ptr, self, cdim, index, src)
|
|
}
|
|
func AtgScatter1(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_scatter1(ptr, self, cdim, index, value )
|
|
}
|
|
func AtgScatter_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_scatter_(ptr, self, cdim, index, src)
|
|
}
|
|
func AtgScatter1_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_scatter_1(ptr, self, cdim, index, value )
|
|
}
|
|
func AtgScatter2(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, reduce string){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
creduce := C.CString(reduce)
|
|
reduceLen := len(reduce)
|
|
creduceLen := *(*C.int)(unsafe.Pointer(&reduceLen))
|
|
C.atg_scatter_2(ptr, self, cdim, index, src, creduce, creduceLen)
|
|
}
|
|
func AtgScatter3(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, value Cscalar, reduce string){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
creduce := C.CString(reduce)
|
|
reduceLen := len(reduce)
|
|
creduceLen := *(*C.int)(unsafe.Pointer(&reduceLen))
|
|
C.atg_scatter_3(ptr, self, cdim, index, value , creduce, creduceLen)
|
|
}
|
|
func AtgScatterAdd(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_scatter_add(ptr, self, cdim, index, src)
|
|
}
|
|
func AtgScatterAdd_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_scatter_add_(ptr, self, cdim, index, src)
|
|
}
|
|
func AtgSearchsorted(ptr *Ctensor, sortedSequence Ctensor, self Ctensor, outInt32 int32, right int32){
|
|
coutInt32 := *(*C.int)(unsafe.Pointer(&outInt32))
|
|
cright := *(*C.int)(unsafe.Pointer(&right))
|
|
C.atg_searchsorted(ptr, sortedSequence, self, coutInt32, cright)
|
|
}
|
|
func AtgSearchsorted1(ptr *Ctensor, sortedSequence Ctensor, selfScalar Cscalar, outInt32 int32, right int32){
|
|
coutInt32 := *(*C.int)(unsafe.Pointer(&outInt32))
|
|
cright := *(*C.int)(unsafe.Pointer(&right))
|
|
C.atg_searchsorted1(ptr, sortedSequence, selfScalar , coutInt32, cright)
|
|
}
|
|
func AtgSearchsortedOut(ptr *Ctensor, out Ctensor, sortedSequence Ctensor, self Ctensor, outInt32 int32, right int32){
|
|
coutInt32 := *(*C.int)(unsafe.Pointer(&outInt32))
|
|
cright := *(*C.int)(unsafe.Pointer(&right))
|
|
C.atg_searchsorted_out(ptr, out, sortedSequence, self, coutInt32, cright)
|
|
}
|
|
func AtgSelect(ptr *Ctensor, self Ctensor, dim int64, index int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cindex := *(*C.int64_t)(unsafe.Pointer(&index))
|
|
C.atg_select(ptr, self, cdim, cindex)
|
|
}
|
|
func AtgSelectBackward(ptr *Ctensor, grad Ctensor, inputSizesData []int64, inputSizesLen int, dim int64, index int64){
|
|
cinputSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizesData[0]))
|
|
cinputSizesLen := *(*C.int)(unsafe.Pointer(&inputSizesLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cindex := *(*C.int64_t)(unsafe.Pointer(&index))
|
|
C.atg_select_backward(ptr, grad, cinputSizesDataPtr, cinputSizesLen, cdim, cindex)
|
|
}
|
|
func AtgSelu(ptr *Ctensor, self Ctensor){
|
|
C.atg_selu(ptr, self)
|
|
}
|
|
func AtgSelu_(ptr *Ctensor, self Ctensor){
|
|
C.atg_selu_(ptr, self)
|
|
}
|
|
func AtgSet_(ptr *Ctensor, self Ctensor){
|
|
C.atg_set_(ptr, self)
|
|
}
|
|
func AtgSet1_(ptr *Ctensor, self Ctensor, source Ctensor){
|
|
C.atg_set_1(ptr, self, source)
|
|
}
|
|
func AtgSetRequiresGrad(ptr *Ctensor, self Ctensor, r int32){
|
|
cr := *(*C.int)(unsafe.Pointer(&r))
|
|
C.atg_set_requires_grad(ptr, self, cr)
|
|
}
|
|
func AtgSgn(ptr *Ctensor, self Ctensor){
|
|
C.atg_sgn(ptr, self)
|
|
}
|
|
func AtgSgn_(ptr *Ctensor, self Ctensor){
|
|
C.atg_sgn_(ptr, self)
|
|
}
|
|
func AtgSgnOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_sgn_out(ptr, out, self)
|
|
}
|
|
func AtgSigmoid(ptr *Ctensor, self Ctensor){
|
|
C.atg_sigmoid(ptr, self)
|
|
}
|
|
func AtgSigmoid_(ptr *Ctensor, self Ctensor){
|
|
C.atg_sigmoid_(ptr, self)
|
|
}
|
|
func AtgSigmoidBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor){
|
|
C.atg_sigmoid_backward(ptr, gradOutput, output)
|
|
}
|
|
func AtgSigmoidBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, output Ctensor){
|
|
C.atg_sigmoid_backward_out(ptr, gradInput, gradOutput, output)
|
|
}
|
|
func AtgSigmoidOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_sigmoid_out(ptr, out, self)
|
|
}
|
|
func AtgSign(ptr *Ctensor, self Ctensor){
|
|
C.atg_sign(ptr, self)
|
|
}
|
|
func AtgSign_(ptr *Ctensor, self Ctensor){
|
|
C.atg_sign_(ptr, self)
|
|
}
|
|
func AtgSignOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_sign_out(ptr, out, self)
|
|
}
|
|
func AtgSignbit(ptr *Ctensor, self Ctensor){
|
|
C.atg_signbit(ptr, self)
|
|
}
|
|
func AtgSignbitOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_signbit_out(ptr, out, self)
|
|
}
|
|
func AtgSilu(ptr *Ctensor, self Ctensor){
|
|
C.atg_silu(ptr, self)
|
|
}
|
|
func AtgSilu_(ptr *Ctensor, self Ctensor){
|
|
C.atg_silu_(ptr, self)
|
|
}
|
|
func AtgSiluBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor){
|
|
C.atg_silu_backward(ptr, gradOutput, self)
|
|
}
|
|
func AtgSiluOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_silu_out(ptr, out, self)
|
|
}
|
|
func AtgSin(ptr *Ctensor, self Ctensor){
|
|
C.atg_sin(ptr, self)
|
|
}
|
|
func AtgSin_(ptr *Ctensor, self Ctensor){
|
|
C.atg_sin_(ptr, self)
|
|
}
|
|
func AtgSinOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_sin_out(ptr, out, self)
|
|
}
|
|
func AtgSinh(ptr *Ctensor, self Ctensor){
|
|
C.atg_sinh(ptr, self)
|
|
}
|
|
func AtgSinh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_sinh_(ptr, self)
|
|
}
|
|
func AtgSinhOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_sinh_out(ptr, out, self)
|
|
}
|
|
func AtgSlice(ptr *Ctensor, self Ctensor, dim int64, start int64, end int64, step int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cstart := *(*C.int64_t)(unsafe.Pointer(&start))
|
|
cend := *(*C.int64_t)(unsafe.Pointer(&end))
|
|
cstep := *(*C.int64_t)(unsafe.Pointer(&step))
|
|
C.atg_slice(ptr, self, cdim, cstart, cend, cstep)
|
|
}
|
|
func AtgSliceBackward(ptr *Ctensor, grad Ctensor, inputSizesData []int64, inputSizesLen int, dim int64, start int64, end int64, step int64){
|
|
cinputSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizesData[0]))
|
|
cinputSizesLen := *(*C.int)(unsafe.Pointer(&inputSizesLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cstart := *(*C.int64_t)(unsafe.Pointer(&start))
|
|
cend := *(*C.int64_t)(unsafe.Pointer(&end))
|
|
cstep := *(*C.int64_t)(unsafe.Pointer(&step))
|
|
C.atg_slice_backward(ptr, grad, cinputSizesDataPtr, cinputSizesLen, cdim, cstart, cend, cstep)
|
|
}
|
|
func AtgSlogdet(ptr *Ctensor, self Ctensor){
|
|
C.atg_slogdet(ptr, self)
|
|
}
|
|
func AtgSlowConv3d(ptr *Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_slow_conv3d(ptr, self, weight, ckernelSizeDataPtr, ckernelSizeLen, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
func AtgSlowConv3dOut(ptr *Ctensor, out Ctensor, self Ctensor, weight Ctensor, kernelSizeData []int64, kernelSizeLen int, bias Ctensor, strideData []int64, strideLen int, paddingData []int64, paddingLen int){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
C.atg_slow_conv3d_out(ptr, out, self, weight, ckernelSizeDataPtr, ckernelSizeLen, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
C.atg_slow_conv_dilated2d(ptr, self, weight, ckernelSizeDataPtr, ckernelSizeLen, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
C.atg_slow_conv_dilated3d(ptr, self, weight, ckernelSizeDataPtr, ckernelSizeLen, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
C.atg_slow_conv_transpose2d(ptr, self, weight, ckernelSizeDataPtr, ckernelSizeLen, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cdilationDataPtr, cdilationLen)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
C.atg_slow_conv_transpose2d_out(ptr, out, self, weight, ckernelSizeDataPtr, ckernelSizeLen, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cdilationDataPtr, cdilationLen)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
C.atg_slow_conv_transpose3d(ptr, self, weight, ckernelSizeDataPtr, ckernelSizeLen, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cdilationDataPtr, cdilationLen)
|
|
}
|
|
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){
|
|
ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0]))
|
|
ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen))
|
|
cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0]))
|
|
cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen))
|
|
cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0]))
|
|
cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen))
|
|
coutputPaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&outputPaddingData[0]))
|
|
coutputPaddingLen := *(*C.int)(unsafe.Pointer(&outputPaddingLen))
|
|
cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0]))
|
|
cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen))
|
|
C.atg_slow_conv_transpose3d_out(ptr, out, self, weight, ckernelSizeDataPtr, ckernelSizeLen, bias, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, coutputPaddingDataPtr, coutputPaddingLen, cdilationDataPtr, cdilationLen)
|
|
}
|
|
func AtgSmm(ptr *Ctensor, self Ctensor, mat2 Ctensor){
|
|
C.atg_smm(ptr, self, mat2)
|
|
}
|
|
func AtgSmoothL1Loss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64, beta float64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cbeta := *(*C.double)(unsafe.Pointer(&beta))
|
|
C.atg_smooth_l1_loss(ptr, self, target, creduction, cbeta)
|
|
}
|
|
func AtgSmoothL1LossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, beta float64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cbeta := *(*C.double)(unsafe.Pointer(&beta))
|
|
C.atg_smooth_l1_loss_backward(ptr, gradOutput, self, target, creduction, cbeta)
|
|
}
|
|
func AtgSmoothL1LossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64, beta float64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cbeta := *(*C.double)(unsafe.Pointer(&beta))
|
|
C.atg_smooth_l1_loss_backward_out(ptr, gradInput, gradOutput, self, target, creduction, cbeta)
|
|
}
|
|
func AtgSmoothL1LossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64, beta float64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
cbeta := *(*C.double)(unsafe.Pointer(&beta))
|
|
C.atg_smooth_l1_loss_out(ptr, out, self, target, creduction, cbeta)
|
|
}
|
|
func AtgSoftMarginLoss(ptr *Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_soft_margin_loss(ptr, self, target, creduction)
|
|
}
|
|
func AtgSoftMarginLossBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_soft_margin_loss_backward(ptr, gradOutput, self, target, creduction)
|
|
}
|
|
func AtgSoftMarginLossBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_soft_margin_loss_backward_out(ptr, gradInput, gradOutput, self, target, creduction)
|
|
}
|
|
func AtgSoftMarginLossOut(ptr *Ctensor, out Ctensor, self Ctensor, target Ctensor, reduction int64){
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_soft_margin_loss_out(ptr, out, self, target, creduction)
|
|
}
|
|
func AtgSoftmax(ptr *Ctensor, self Ctensor, dim int64, dtype int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_softmax(ptr, self, cdim, cdtype)
|
|
}
|
|
func AtgSoftplus(ptr *Ctensor, self Ctensor){
|
|
C.atg_softplus(ptr, self)
|
|
}
|
|
func AtgSoftplusBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, beta Cscalar, threshold Cscalar, output Ctensor){
|
|
C.atg_softplus_backward(ptr, gradOutput, self, beta , threshold , output)
|
|
}
|
|
func AtgSoftplusBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, beta Cscalar, threshold Cscalar, output Ctensor){
|
|
C.atg_softplus_backward_out(ptr, gradInput, gradOutput, self, beta , threshold , output)
|
|
}
|
|
func AtgSoftplusOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_softplus_out(ptr, out, self)
|
|
}
|
|
func AtgSoftshrink(ptr *Ctensor, self Ctensor){
|
|
C.atg_softshrink(ptr, self)
|
|
}
|
|
func AtgSoftshrinkBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, lambd Cscalar){
|
|
C.atg_softshrink_backward(ptr, gradOutput, self, lambd )
|
|
}
|
|
func AtgSoftshrinkBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, self Ctensor, lambd Cscalar){
|
|
C.atg_softshrink_backward_out(ptr, gradInput, gradOutput, self, lambd )
|
|
}
|
|
func AtgSoftshrinkOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_softshrink_out(ptr, out, self)
|
|
}
|
|
func AtgSolve(ptr *Ctensor, self Ctensor, a Ctensor){
|
|
C.atg_solve(ptr, self, a)
|
|
}
|
|
func AtgSolveOut(ptr *Ctensor, solution Ctensor, lu Ctensor, self Ctensor, a Ctensor){
|
|
C.atg_solve_out(ptr, solution, lu, self, a)
|
|
}
|
|
func AtgSort(ptr *Ctensor, self Ctensor, dim int64, descending int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdescending := *(*C.int)(unsafe.Pointer(&descending))
|
|
C.atg_sort(ptr, self, cdim, cdescending)
|
|
}
|
|
func AtgSortOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, dim int64, descending int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
cdescending := *(*C.int)(unsafe.Pointer(&descending))
|
|
C.atg_sort_out(ptr, values, indices, self, cdim, cdescending)
|
|
}
|
|
func AtgSparseCooTensor(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_sparse_coo_tensor(ptr, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgSparseCooTensor1(ptr *Ctensor, indices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32){
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_sparse_coo_tensor1(ptr, indices, values, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgSparseCooTensor2(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_sparse_coo_tensor2(ptr, indices, values, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgSparseMask(ptr *Ctensor, self Ctensor, mask Ctensor){
|
|
C.atg_sparse_mask(ptr, self, mask)
|
|
}
|
|
func AtgSparseResize_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, sparseDim int64, denseDim int64){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim))
|
|
cdenseDim := *(*C.int64_t)(unsafe.Pointer(&denseDim))
|
|
C.atg_sparse_resize_(ptr, self, csizeDataPtr, csizeLen, csparseDim, cdenseDim)
|
|
}
|
|
func AtgSparseResizeAndClear_(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int, sparseDim int64, denseDim int64){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim))
|
|
cdenseDim := *(*C.int64_t)(unsafe.Pointer(&denseDim))
|
|
C.atg_sparse_resize_and_clear_(ptr, self, csizeDataPtr, csizeLen, csparseDim, cdenseDim)
|
|
}
|
|
|
|
|
|
func AtgSqrt(ptr *Ctensor, self Ctensor){
|
|
C.atg_sqrt(ptr, self)
|
|
}
|
|
func AtgSqrt_(ptr *Ctensor, self Ctensor){
|
|
C.atg_sqrt_(ptr, self)
|
|
}
|
|
func AtgSqrtOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_sqrt_out(ptr, out, self)
|
|
}
|
|
func AtgSquare(ptr *Ctensor, self Ctensor){
|
|
C.atg_square(ptr, self)
|
|
}
|
|
func AtgSquare_(ptr *Ctensor, self Ctensor){
|
|
C.atg_square_(ptr, self)
|
|
}
|
|
func AtgSqueeze(ptr *Ctensor, self Ctensor){
|
|
C.atg_squeeze(ptr, self)
|
|
}
|
|
func AtgSqueeze1(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_squeeze1(ptr, self, cdim)
|
|
}
|
|
func AtgSqueeze_(ptr *Ctensor, self Ctensor){
|
|
C.atg_squeeze_(ptr, self)
|
|
}
|
|
func AtgSqueeze1_(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_squeeze_1(ptr, self, cdim)
|
|
}
|
|
func AtgSspaddmm(ptr *Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor){
|
|
C.atg_sspaddmm(ptr, self, mat1, mat2)
|
|
}
|
|
func AtgSspaddmmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat1 Ctensor, mat2 Ctensor){
|
|
C.atg_sspaddmm_out(ptr, out, self, mat1, mat2)
|
|
}
|
|
func AtgStack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_stack(ptr, ctensorsDataPtr, ctensorsLen, cdim)
|
|
}
|
|
func AtgStackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int, dim int64){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_stack_out(ptr, out, ctensorsDataPtr, ctensorsLen, cdim)
|
|
}
|
|
func AtgStd(ptr *Ctensor, self Ctensor, unbiased int32){
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
C.atg_std(ptr, self, cunbiased)
|
|
}
|
|
func AtgStd1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_std1(ptr, self, cdimDataPtr, cdimLen, cunbiased, ckeepdim)
|
|
}
|
|
func AtgStdMean(ptr *Ctensor, self Ctensor, unbiased int32){
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
C.atg_std_mean(ptr, self, cunbiased)
|
|
}
|
|
func AtgStdMean1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_std_mean1(ptr, self, cdimDataPtr, cdimLen, cunbiased, ckeepdim)
|
|
}
|
|
func AtgStdOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_std_out(ptr, out, self, cdimDataPtr, cdimLen, cunbiased, ckeepdim)
|
|
}
|
|
func AtgStft(ptr *Ctensor, self Ctensor, nFft int64, hopLengthVal int64, hopLengthNull int, winLengthVal int64, winLengthNull int, window Ctensor, normalized int32, onesided int32, returnComplex int32){
|
|
cnFft := *(*C.int64_t)(unsafe.Pointer(&nFft))
|
|
chopLengthVal := *(*C.int64_t)(unsafe.Pointer(&hopLengthVal))
|
|
chopLengthNull := *(*C.uint8_t)(unsafe.Pointer(&hopLengthNull))
|
|
cwinLengthVal := *(*C.int64_t)(unsafe.Pointer(&winLengthVal))
|
|
cwinLengthNull := *(*C.uint8_t)(unsafe.Pointer(&winLengthNull))
|
|
cnormalized := *(*C.int)(unsafe.Pointer(&normalized))
|
|
conesided := *(*C.int)(unsafe.Pointer(&onesided))
|
|
creturnComplex := *(*C.int)(unsafe.Pointer(&returnComplex))
|
|
C.atg_stft(ptr, self, cnFft, chopLengthVal, chopLengthNull, cwinLengthVal, cwinLengthNull, window, cnormalized, conesided, creturnComplex)
|
|
}
|
|
func AtgSub(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_sub(ptr, self, other)
|
|
}
|
|
func AtgSub1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_sub1(ptr, self, other )
|
|
}
|
|
func AtgSub_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_sub_(ptr, self, other)
|
|
}
|
|
func AtgSub1_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_sub_1(ptr, self, other )
|
|
}
|
|
func AtgSubOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_sub_out(ptr, out, self, other)
|
|
}
|
|
func AtgSubtract(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_subtract(ptr, self, other)
|
|
}
|
|
func AtgSubtract1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_subtract1(ptr, self, other )
|
|
}
|
|
func AtgSubtract_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_subtract_(ptr, self, other)
|
|
}
|
|
func AtgSubtract1_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_subtract_1(ptr, self, other )
|
|
}
|
|
func AtgSubtractOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_subtract_out(ptr, out, self, other)
|
|
}
|
|
func AtgSum(ptr *Ctensor, self Ctensor, dtype int32){
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_sum(ptr, self, cdtype)
|
|
}
|
|
func AtgSum1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_sum1(ptr, self, cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgSumOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, keepdim int32, dtype int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
C.atg_sum_out(ptr, out, self, cdimDataPtr, cdimLen, ckeepdim, cdtype)
|
|
}
|
|
func AtgSumToSize(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_sum_to_size(ptr, self, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgSvd(ptr *Ctensor, self Ctensor, some int32, computeUv int32){
|
|
csome := *(*C.int)(unsafe.Pointer(&some))
|
|
ccomputeUv := *(*C.int)(unsafe.Pointer(&computeUv))
|
|
C.atg_svd(ptr, self, csome, ccomputeUv)
|
|
}
|
|
func AtgSvdOut(ptr *Ctensor, u Ctensor, s Ctensor, v Ctensor, self Ctensor, some int32, computeUv int32){
|
|
csome := *(*C.int)(unsafe.Pointer(&some))
|
|
ccomputeUv := *(*C.int)(unsafe.Pointer(&computeUv))
|
|
C.atg_svd_out(ptr, u, s, v, self, csome, ccomputeUv)
|
|
}
|
|
func AtgSymeig(ptr *Ctensor, self Ctensor, eigenvectors int32, upper int32){
|
|
ceigenvectors := *(*C.int)(unsafe.Pointer(&eigenvectors))
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg_symeig(ptr, self, ceigenvectors, cupper)
|
|
}
|
|
func AtgSymeigOut(ptr *Ctensor, e Ctensor, v Ctensor, self Ctensor, eigenvectors int32, upper int32){
|
|
ceigenvectors := *(*C.int)(unsafe.Pointer(&eigenvectors))
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
C.atg_symeig_out(ptr, e, v, self, ceigenvectors, cupper)
|
|
}
|
|
func AtgT(ptr *Ctensor, self Ctensor){
|
|
C.atg_t(ptr, self)
|
|
}
|
|
func AtgT_(ptr *Ctensor, self Ctensor){
|
|
C.atg_t_(ptr, self)
|
|
}
|
|
func AtgTake(ptr *Ctensor, self Ctensor, index Ctensor){
|
|
C.atg_take(ptr, self, index)
|
|
}
|
|
func AtgTakeBackward(ptr *Ctensor, grad Ctensor, input Ctensor, index Ctensor){
|
|
C.atg_take_backward(ptr, grad, input, index)
|
|
}
|
|
func AtgTakeOut(ptr *Ctensor, out Ctensor, self Ctensor, index Ctensor){
|
|
C.atg_take_out(ptr, out, self, index)
|
|
}
|
|
func AtgTan(ptr *Ctensor, self Ctensor){
|
|
C.atg_tan(ptr, self)
|
|
}
|
|
func AtgTan_(ptr *Ctensor, self Ctensor){
|
|
C.atg_tan_(ptr, self)
|
|
}
|
|
func AtgTanOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_tan_out(ptr, out, self)
|
|
}
|
|
func AtgTanh(ptr *Ctensor, self Ctensor){
|
|
C.atg_tanh(ptr, self)
|
|
}
|
|
func AtgTanh_(ptr *Ctensor, self Ctensor){
|
|
C.atg_tanh_(ptr, self)
|
|
}
|
|
func AtgTanhBackward(ptr *Ctensor, gradOutput Ctensor, output Ctensor){
|
|
C.atg_tanh_backward(ptr, gradOutput, output)
|
|
}
|
|
func AtgTanhBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, output Ctensor){
|
|
C.atg_tanh_backward_out(ptr, gradInput, gradOutput, output)
|
|
}
|
|
func AtgTanhOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_tanh_out(ptr, out, self)
|
|
}
|
|
func AtgTensordot(ptr *Ctensor, self Ctensor, other Ctensor, dimsSelfData []int64, dimsSelfLen int, dimsOtherData []int64, dimsOtherLen int){
|
|
cdimsSelfDataPtr := (*C.int64_t)(unsafe.Pointer(&dimsSelfData[0]))
|
|
cdimsSelfLen := *(*C.int)(unsafe.Pointer(&dimsSelfLen))
|
|
cdimsOtherDataPtr := (*C.int64_t)(unsafe.Pointer(&dimsOtherData[0]))
|
|
cdimsOtherLen := *(*C.int)(unsafe.Pointer(&dimsOtherLen))
|
|
C.atg_tensordot(ptr, self, other, cdimsSelfDataPtr, cdimsSelfLen, cdimsOtherDataPtr, cdimsOtherLen)
|
|
}
|
|
func AtgThreshold(ptr *Ctensor, self Ctensor, threshold Cscalar, value Cscalar){
|
|
C.atg_threshold(ptr, self, threshold , value )
|
|
}
|
|
func AtgThreshold_(ptr *Ctensor, self Ctensor, threshold Cscalar, value Cscalar){
|
|
C.atg_threshold_(ptr, self, threshold , value )
|
|
}
|
|
func AtgThresholdBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, threshold Cscalar){
|
|
C.atg_threshold_backward(ptr, gradOutput, self, threshold )
|
|
}
|
|
func AtgThresholdOut(ptr *Ctensor, out Ctensor, self Ctensor, threshold Cscalar, value Cscalar){
|
|
C.atg_threshold_out(ptr, out, self, threshold , value )
|
|
}
|
|
func AtgTo(ptr *Ctensor, self Ctensor, device int32){
|
|
cdevice := *(*C.int)(unsafe.Pointer(&device))
|
|
C.atg_to(ptr, self, cdevice)
|
|
}
|
|
func AtgTo1(ptr *Ctensor, self Ctensor, optionsKind int32, optionsDevice int32, nonBlocking int32, copy int32){
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
ccopy := *(*C.int)(unsafe.Pointer(©))
|
|
C.atg_to1(ptr, self, coptionsKind, coptionsDevice, cnonBlocking, ccopy)
|
|
}
|
|
func AtgTo2(ptr *Ctensor, self Ctensor, dtype int32, nonBlocking int32, copy int32){
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
ccopy := *(*C.int)(unsafe.Pointer(©))
|
|
C.atg_to2(ptr, self, cdtype, cnonBlocking, ccopy)
|
|
}
|
|
func AtgTo3(ptr *Ctensor, self Ctensor, other Ctensor, nonBlocking int32, copy int32){
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
ccopy := *(*C.int)(unsafe.Pointer(©))
|
|
C.atg_to3(ptr, self, other, cnonBlocking, ccopy)
|
|
}
|
|
func AtgTo4(ptr *Ctensor, self Ctensor, device int32, dtype int32, nonBlocking int32, copy int32){
|
|
cdevice := *(*C.int)(unsafe.Pointer(&device))
|
|
cdtype := *(*C.int)(unsafe.Pointer(&dtype))
|
|
cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking))
|
|
ccopy := *(*C.int)(unsafe.Pointer(©))
|
|
C.atg_to4(ptr, self, cdevice, cdtype, cnonBlocking, ccopy)
|
|
}
|
|
func AtgToDense(ptr *Ctensor, self Ctensor){
|
|
C.atg_to_dense(ptr, self)
|
|
}
|
|
func AtgToDenseBackward(ptr *Ctensor, grad Ctensor, input Ctensor){
|
|
C.atg_to_dense_backward(ptr, grad, input)
|
|
}
|
|
func AtgToMkldnn(ptr *Ctensor, self Ctensor){
|
|
C.atg_to_mkldnn(ptr, self)
|
|
}
|
|
func AtgToMkldnnBackward(ptr *Ctensor, grad Ctensor, input Ctensor){
|
|
C.atg_to_mkldnn_backward(ptr, grad, input)
|
|
}
|
|
func AtgToSparse(ptr *Ctensor, self Ctensor){
|
|
C.atg_to_sparse(ptr, self)
|
|
}
|
|
func AtgToSparse1(ptr *Ctensor, self Ctensor, sparseDim int64){
|
|
csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim))
|
|
C.atg_to_sparse1(ptr, self, csparseDim)
|
|
}
|
|
func AtgTopk(ptr *Ctensor, self Ctensor, k int64, dim int64, largest int32, sorted int32){
|
|
ck := *(*C.int64_t)(unsafe.Pointer(&k))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
clargest := *(*C.int)(unsafe.Pointer(&largest))
|
|
csorted := *(*C.int)(unsafe.Pointer(&sorted))
|
|
C.atg_topk(ptr, self, ck, cdim, clargest, csorted)
|
|
}
|
|
func AtgTopkOut(ptr *Ctensor, values Ctensor, indices Ctensor, self Ctensor, k int64, dim int64, largest int32, sorted int32){
|
|
ck := *(*C.int64_t)(unsafe.Pointer(&k))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
clargest := *(*C.int)(unsafe.Pointer(&largest))
|
|
csorted := *(*C.int)(unsafe.Pointer(&sorted))
|
|
C.atg_topk_out(ptr, values, indices, self, ck, cdim, clargest, csorted)
|
|
}
|
|
func AtgTotype(ptr *Ctensor, self Ctensor, scalarType int32){
|
|
cscalarType := *(*C.int)(unsafe.Pointer(&scalarType))
|
|
C.atg_totype(ptr, self, cscalarType)
|
|
}
|
|
func AtgTrace(ptr *Ctensor, self Ctensor){
|
|
C.atg_trace(ptr, self)
|
|
}
|
|
func AtgTraceBackward(ptr *Ctensor, grad Ctensor, sizesData []int64, sizesLen int){
|
|
csizesDataPtr := (*C.int64_t)(unsafe.Pointer(&sizesData[0]))
|
|
csizesLen := *(*C.int)(unsafe.Pointer(&sizesLen))
|
|
C.atg_trace_backward(ptr, grad, csizesDataPtr, csizesLen)
|
|
}
|
|
func AtgTranspose(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64){
|
|
cdim0 := *(*C.int64_t)(unsafe.Pointer(&dim0))
|
|
cdim1 := *(*C.int64_t)(unsafe.Pointer(&dim1))
|
|
C.atg_transpose(ptr, self, cdim0, cdim1)
|
|
}
|
|
func AtgTranspose_(ptr *Ctensor, self Ctensor, dim0 int64, dim1 int64){
|
|
cdim0 := *(*C.int64_t)(unsafe.Pointer(&dim0))
|
|
cdim1 := *(*C.int64_t)(unsafe.Pointer(&dim1))
|
|
C.atg_transpose_(ptr, self, cdim0, cdim1)
|
|
}
|
|
func AtgTrapz(ptr *Ctensor, y Ctensor, x Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_trapz(ptr, y, x, cdim)
|
|
}
|
|
func AtgTrapz1(ptr *Ctensor, y Ctensor, dx float64, dim int64){
|
|
cdx := *(*C.double)(unsafe.Pointer(&dx))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_trapz1(ptr, y, cdx, cdim)
|
|
}
|
|
func AtgTriangularSolve(ptr *Ctensor, self Ctensor, a Ctensor, upper int32, transpose int32, unitriangular int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
ctranspose := *(*C.int)(unsafe.Pointer(&transpose))
|
|
cunitriangular := *(*C.int)(unsafe.Pointer(&unitriangular))
|
|
C.atg_triangular_solve(ptr, self, a, cupper, ctranspose, cunitriangular)
|
|
}
|
|
func AtgTriangularSolveOut(ptr *Ctensor, x Ctensor, m Ctensor, self Ctensor, a Ctensor, upper int32, transpose int32, unitriangular int32){
|
|
cupper := *(*C.int)(unsafe.Pointer(&upper))
|
|
ctranspose := *(*C.int)(unsafe.Pointer(&transpose))
|
|
cunitriangular := *(*C.int)(unsafe.Pointer(&unitriangular))
|
|
C.atg_triangular_solve_out(ptr, x, m, self, a, cupper, ctranspose, cunitriangular)
|
|
}
|
|
func AtgTril(ptr *Ctensor, self Ctensor, diagonal int64){
|
|
cdiagonal := *(*C.int64_t)(unsafe.Pointer(&diagonal))
|
|
C.atg_tril(ptr, self, cdiagonal)
|
|
}
|
|
func AtgTril_(ptr *Ctensor, self Ctensor, diagonal int64){
|
|
cdiagonal := *(*C.int64_t)(unsafe.Pointer(&diagonal))
|
|
C.atg_tril_(ptr, self, cdiagonal)
|
|
}
|
|
func AtgTrilIndices(ptr *Ctensor, row int64, col int64, offset int64, optionsKind int32, optionsDevice int32){
|
|
crow := *(*C.int64_t)(unsafe.Pointer(&row))
|
|
ccol := *(*C.int64_t)(unsafe.Pointer(&col))
|
|
coffset := *(*C.int64_t)(unsafe.Pointer(&offset))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_tril_indices(ptr, crow, ccol, coffset, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgTrilOut(ptr *Ctensor, out Ctensor, self Ctensor, diagonal int64){
|
|
cdiagonal := *(*C.int64_t)(unsafe.Pointer(&diagonal))
|
|
C.atg_tril_out(ptr, out, self, cdiagonal)
|
|
}
|
|
func AtgTripletMarginLoss(ptr *Ctensor, anchor Ctensor, positive Ctensor, negative Ctensor, margin float64, p float64, eps float64, swap int32, reduction int64){
|
|
cmargin := *(*C.double)(unsafe.Pointer(&margin))
|
|
cp := *(*C.double)(unsafe.Pointer(&p))
|
|
ceps := *(*C.double)(unsafe.Pointer(&eps))
|
|
cswap := *(*C.int)(unsafe.Pointer(&swap))
|
|
creduction := *(*C.int64_t)(unsafe.Pointer(&reduction))
|
|
C.atg_triplet_margin_loss(ptr, anchor, positive, negative, cmargin, cp, ceps, cswap, creduction)
|
|
}
|
|
func AtgTriu(ptr *Ctensor, self Ctensor, diagonal int64){
|
|
cdiagonal := *(*C.int64_t)(unsafe.Pointer(&diagonal))
|
|
C.atg_triu(ptr, self, cdiagonal)
|
|
}
|
|
func AtgTriu_(ptr *Ctensor, self Ctensor, diagonal int64){
|
|
cdiagonal := *(*C.int64_t)(unsafe.Pointer(&diagonal))
|
|
C.atg_triu_(ptr, self, cdiagonal)
|
|
}
|
|
func AtgTriuIndices(ptr *Ctensor, row int64, col int64, offset int64, optionsKind int32, optionsDevice int32){
|
|
crow := *(*C.int64_t)(unsafe.Pointer(&row))
|
|
ccol := *(*C.int64_t)(unsafe.Pointer(&col))
|
|
coffset := *(*C.int64_t)(unsafe.Pointer(&offset))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_triu_indices(ptr, crow, ccol, coffset, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgTriuOut(ptr *Ctensor, out Ctensor, self Ctensor, diagonal int64){
|
|
cdiagonal := *(*C.int64_t)(unsafe.Pointer(&diagonal))
|
|
C.atg_triu_out(ptr, out, self, cdiagonal)
|
|
}
|
|
func AtgTrueDivide(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_true_divide(ptr, self, other)
|
|
}
|
|
func AtgTrueDivide1(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_true_divide1(ptr, self, other )
|
|
}
|
|
func AtgTrueDivide_(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_true_divide_(ptr, self, other)
|
|
}
|
|
func AtgTrueDivide1_(ptr *Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_true_divide_1(ptr, self, other )
|
|
}
|
|
func AtgTrueDivideOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_true_divide_out(ptr, out, self, other)
|
|
}
|
|
func AtgTrunc(ptr *Ctensor, self Ctensor){
|
|
C.atg_trunc(ptr, self)
|
|
}
|
|
func AtgTrunc_(ptr *Ctensor, self Ctensor){
|
|
C.atg_trunc_(ptr, self)
|
|
}
|
|
func AtgTruncOut(ptr *Ctensor, out Ctensor, self Ctensor){
|
|
C.atg_trunc_out(ptr, out, self)
|
|
}
|
|
func AtgTypeAs(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_type_as(ptr, self, other)
|
|
}
|
|
|
|
func AtgUnflatten(ptr *Ctensor, self Ctensor, dim int64, sizesData []int64, sizesLen int){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
csizesDataPtr := (*C.int64_t)(unsafe.Pointer(&sizesData[0]))
|
|
csizesLen := *(*C.int)(unsafe.Pointer(&sizesLen))
|
|
C.atg_unflatten(ptr, self, cdim, csizesDataPtr, csizesLen)
|
|
}
|
|
func AtgUnfold(ptr *Ctensor, self Ctensor, dimension int64, size int64, step int64){
|
|
cdimension := *(*C.int64_t)(unsafe.Pointer(&dimension))
|
|
csize := *(*C.int64_t)(unsafe.Pointer(&size))
|
|
cstep := *(*C.int64_t)(unsafe.Pointer(&step))
|
|
C.atg_unfold(ptr, self, cdimension, csize, cstep)
|
|
}
|
|
func AtgUnfoldBackward(ptr *Ctensor, gradIn Ctensor, inputSizesData []int64, inputSizesLen int, dim int64, size int64, step int64){
|
|
cinputSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizesData[0]))
|
|
cinputSizesLen := *(*C.int)(unsafe.Pointer(&inputSizesLen))
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
csize := *(*C.int64_t)(unsafe.Pointer(&size))
|
|
cstep := *(*C.int64_t)(unsafe.Pointer(&step))
|
|
C.atg_unfold_backward(ptr, gradIn, cinputSizesDataPtr, cinputSizesLen, cdim, csize, cstep)
|
|
}
|
|
func AtgUniform_(ptr *Ctensor, self Ctensor, from float64, to float64){
|
|
cfrom := *(*C.double)(unsafe.Pointer(&from))
|
|
cto := *(*C.double)(unsafe.Pointer(&to))
|
|
C.atg_uniform_(ptr, self, cfrom, cto)
|
|
}
|
|
func AtgUniqueConsecutive(ptr *Ctensor, self Ctensor, returnInverse int32, returnCounts int32, dimVal int64, dimNull int){
|
|
creturnInverse := *(*C.int)(unsafe.Pointer(&returnInverse))
|
|
creturnCounts := *(*C.int)(unsafe.Pointer(&returnCounts))
|
|
cdimVal := *(*C.int64_t)(unsafe.Pointer(&dimVal))
|
|
cdimNull := *(*C.uint8_t)(unsafe.Pointer(&dimNull))
|
|
C.atg_unique_consecutive(ptr, self, creturnInverse, creturnCounts, cdimVal, cdimNull)
|
|
}
|
|
func AtgUniqueDim(ptr *Ctensor, self Ctensor, dim int64, sorted int32, returnInverse int32, returnCounts int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
csorted := *(*C.int)(unsafe.Pointer(&sorted))
|
|
creturnInverse := *(*C.int)(unsafe.Pointer(&returnInverse))
|
|
creturnCounts := *(*C.int)(unsafe.Pointer(&returnCounts))
|
|
C.atg_unique_dim(ptr, self, cdim, csorted, creturnInverse, creturnCounts)
|
|
}
|
|
func AtgUniqueDimConsecutive(ptr *Ctensor, self Ctensor, dim int64, returnInverse int32, returnCounts int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
creturnInverse := *(*C.int)(unsafe.Pointer(&returnInverse))
|
|
creturnCounts := *(*C.int)(unsafe.Pointer(&returnCounts))
|
|
C.atg_unique_dim_consecutive(ptr, self, cdim, creturnInverse, creturnCounts)
|
|
}
|
|
|
|
|
|
|
|
func AtgUnsqueeze(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_unsqueeze(ptr, self, cdim)
|
|
}
|
|
func AtgUnsqueeze_(ptr *Ctensor, self Ctensor, dim int64){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
C.atg_unsqueeze_(ptr, self, cdim)
|
|
}
|
|
func AtgUpsampleBicubic2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_bicubic2d(ptr, self, coutputSizeDataPtr, coutputSizeLen, calignCorners, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleBicubic2dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_bicubic2d_backward(ptr, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, calignCorners, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
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){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_bicubic2d_backward_out(ptr, gradInput, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, calignCorners, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleBicubic2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_bicubic2d_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen, calignCorners, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleBilinear2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_bilinear2d(ptr, self, coutputSizeDataPtr, coutputSizeLen, calignCorners, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleBilinear2dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_bilinear2d_backward(ptr, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, calignCorners, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
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){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_bilinear2d_backward_out(ptr, gradInput, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, calignCorners, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleBilinear2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_bilinear2d_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen, calignCorners, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleLinear1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesVal float64, scalesNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesVal := *(*C.double)(unsafe.Pointer(&scalesVal))
|
|
cscalesNull := *(*C.uint8_t)(unsafe.Pointer(&scalesNull))
|
|
C.atg_upsample_linear1d(ptr, self, coutputSizeDataPtr, coutputSizeLen, calignCorners, cscalesVal, cscalesNull)
|
|
}
|
|
func AtgUpsampleLinear1dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesVal float64, scalesNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesVal := *(*C.double)(unsafe.Pointer(&scalesVal))
|
|
cscalesNull := *(*C.uint8_t)(unsafe.Pointer(&scalesNull))
|
|
C.atg_upsample_linear1d_backward(ptr, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, calignCorners, cscalesVal, cscalesNull)
|
|
}
|
|
func AtgUpsampleLinear1dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, alignCorners int32, scalesVal float64, scalesNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesVal := *(*C.double)(unsafe.Pointer(&scalesVal))
|
|
cscalesNull := *(*C.uint8_t)(unsafe.Pointer(&scalesNull))
|
|
C.atg_upsample_linear1d_backward_out(ptr, gradInput, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, calignCorners, cscalesVal, cscalesNull)
|
|
}
|
|
func AtgUpsampleLinear1dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesVal float64, scalesNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesVal := *(*C.double)(unsafe.Pointer(&scalesVal))
|
|
cscalesNull := *(*C.uint8_t)(unsafe.Pointer(&scalesNull))
|
|
C.atg_upsample_linear1d_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen, calignCorners, cscalesVal, cscalesNull)
|
|
}
|
|
func AtgUpsampleNearest1d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesVal float64, scalesNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cscalesVal := *(*C.double)(unsafe.Pointer(&scalesVal))
|
|
cscalesNull := *(*C.uint8_t)(unsafe.Pointer(&scalesNull))
|
|
C.atg_upsample_nearest1d(ptr, self, coutputSizeDataPtr, coutputSizeLen, cscalesVal, cscalesNull)
|
|
}
|
|
func AtgUpsampleNearest1dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesVal float64, scalesNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
cscalesVal := *(*C.double)(unsafe.Pointer(&scalesVal))
|
|
cscalesNull := *(*C.uint8_t)(unsafe.Pointer(&scalesNull))
|
|
C.atg_upsample_nearest1d_backward(ptr, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, cscalesVal, cscalesNull)
|
|
}
|
|
func AtgUpsampleNearest1dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesVal float64, scalesNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
cscalesVal := *(*C.double)(unsafe.Pointer(&scalesVal))
|
|
cscalesNull := *(*C.uint8_t)(unsafe.Pointer(&scalesNull))
|
|
C.atg_upsample_nearest1d_backward_out(ptr, gradInput, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, cscalesVal, cscalesNull)
|
|
}
|
|
func AtgUpsampleNearest1dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesVal float64, scalesNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cscalesVal := *(*C.double)(unsafe.Pointer(&scalesVal))
|
|
cscalesNull := *(*C.uint8_t)(unsafe.Pointer(&scalesNull))
|
|
C.atg_upsample_nearest1d_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen, cscalesVal, cscalesNull)
|
|
}
|
|
func AtgUpsampleNearest2d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_nearest2d(ptr, self, coutputSizeDataPtr, coutputSizeLen, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleNearest2dBackward(ptr *Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_nearest2d_backward(ptr, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleNearest2dBackwardOut(ptr *Ctensor, gradInput Ctensor, gradOutput Ctensor, outputSizeData []int64, outputSizeLen int, inputSizeData []int64, inputSizeLen int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_nearest2d_backward_out(ptr, gradInput, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleNearest2dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_nearest2d_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleNearest3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cscalesDVal := *(*C.double)(unsafe.Pointer(&scalesDVal))
|
|
cscalesDNull := *(*C.uint8_t)(unsafe.Pointer(&scalesDNull))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_nearest3d(ptr, self, coutputSizeDataPtr, coutputSizeLen, cscalesDVal, cscalesDNull, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
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){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
cscalesDVal := *(*C.double)(unsafe.Pointer(&scalesDVal))
|
|
cscalesDNull := *(*C.uint8_t)(unsafe.Pointer(&scalesDNull))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_nearest3d_backward(ptr, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, cscalesDVal, cscalesDNull, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
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){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
cscalesDVal := *(*C.double)(unsafe.Pointer(&scalesDVal))
|
|
cscalesDNull := *(*C.uint8_t)(unsafe.Pointer(&scalesDNull))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_nearest3d_backward_out(ptr, gradInput, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, cscalesDVal, cscalesDNull, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleNearest3dOut(ptr *Ctensor, out Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cscalesDVal := *(*C.double)(unsafe.Pointer(&scalesDVal))
|
|
cscalesDNull := *(*C.uint8_t)(unsafe.Pointer(&scalesDNull))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_nearest3d_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen, cscalesDVal, cscalesDNull, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgUpsampleTrilinear3d(ptr *Ctensor, self Ctensor, outputSizeData []int64, outputSizeLen int, alignCorners int32, scalesDVal float64, scalesDNull int, scalesHVal float64, scalesHNull int, scalesWVal float64, scalesWNull int){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesDVal := *(*C.double)(unsafe.Pointer(&scalesDVal))
|
|
cscalesDNull := *(*C.uint8_t)(unsafe.Pointer(&scalesDNull))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_trilinear3d(ptr, self, coutputSizeDataPtr, coutputSizeLen, calignCorners, cscalesDVal, cscalesDNull, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
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){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesDVal := *(*C.double)(unsafe.Pointer(&scalesDVal))
|
|
cscalesDNull := *(*C.uint8_t)(unsafe.Pointer(&scalesDNull))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_trilinear3d_backward(ptr, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, calignCorners, cscalesDVal, cscalesDNull, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
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){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
cinputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&inputSizeData[0]))
|
|
cinputSizeLen := *(*C.int)(unsafe.Pointer(&inputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesDVal := *(*C.double)(unsafe.Pointer(&scalesDVal))
|
|
cscalesDNull := *(*C.uint8_t)(unsafe.Pointer(&scalesDNull))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_trilinear3d_backward_out(ptr, gradInput, gradOutput, coutputSizeDataPtr, coutputSizeLen, cinputSizeDataPtr, cinputSizeLen, calignCorners, cscalesDVal, cscalesDNull, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
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){
|
|
coutputSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&outputSizeData[0]))
|
|
coutputSizeLen := *(*C.int)(unsafe.Pointer(&outputSizeLen))
|
|
calignCorners := *(*C.int)(unsafe.Pointer(&alignCorners))
|
|
cscalesDVal := *(*C.double)(unsafe.Pointer(&scalesDVal))
|
|
cscalesDNull := *(*C.uint8_t)(unsafe.Pointer(&scalesDNull))
|
|
cscalesHVal := *(*C.double)(unsafe.Pointer(&scalesHVal))
|
|
cscalesHNull := *(*C.uint8_t)(unsafe.Pointer(&scalesHNull))
|
|
cscalesWVal := *(*C.double)(unsafe.Pointer(&scalesWVal))
|
|
cscalesWNull := *(*C.uint8_t)(unsafe.Pointer(&scalesWNull))
|
|
C.atg_upsample_trilinear3d_out(ptr, out, self, coutputSizeDataPtr, coutputSizeLen, calignCorners, cscalesDVal, cscalesDNull, cscalesHVal, cscalesHNull, cscalesWVal, cscalesWNull)
|
|
}
|
|
func AtgValueSelectingReductionBackward(ptr *Ctensor, grad Ctensor, dim int64, indices Ctensor, sizesData []int64, sizesLen int, keepdim int32){
|
|
cdim := *(*C.int64_t)(unsafe.Pointer(&dim))
|
|
csizesDataPtr := (*C.int64_t)(unsafe.Pointer(&sizesData[0]))
|
|
csizesLen := *(*C.int)(unsafe.Pointer(&sizesLen))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_value_selecting_reduction_backward(ptr, grad, cdim, indices, csizesDataPtr, csizesLen, ckeepdim)
|
|
}
|
|
func AtgValues(ptr *Ctensor, self Ctensor){
|
|
C.atg_values(ptr, self)
|
|
}
|
|
func AtgVander(ptr *Ctensor, x Ctensor, nVal int64, nNull int, increasing int32){
|
|
cnVal := *(*C.int64_t)(unsafe.Pointer(&nVal))
|
|
cnNull := *(*C.uint8_t)(unsafe.Pointer(&nNull))
|
|
cincreasing := *(*C.int)(unsafe.Pointer(&increasing))
|
|
C.atg_vander(ptr, x, cnVal, cnNull, cincreasing)
|
|
}
|
|
func AtgVar(ptr *Ctensor, self Ctensor, unbiased int32){
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
C.atg_var(ptr, self, cunbiased)
|
|
}
|
|
func AtgVar1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_var1(ptr, self, cdimDataPtr, cdimLen, cunbiased, ckeepdim)
|
|
}
|
|
func AtgVarMean(ptr *Ctensor, self Ctensor, unbiased int32){
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
C.atg_var_mean(ptr, self, cunbiased)
|
|
}
|
|
func AtgVarMean1(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_var_mean1(ptr, self, cdimDataPtr, cdimLen, cunbiased, ckeepdim)
|
|
}
|
|
func AtgVarOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){
|
|
cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0]))
|
|
cdimLen := *(*C.int)(unsafe.Pointer(&dimLen))
|
|
cunbiased := *(*C.int)(unsafe.Pointer(&unbiased))
|
|
ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim))
|
|
C.atg_var_out(ptr, out, self, cdimDataPtr, cdimLen, cunbiased, ckeepdim)
|
|
}
|
|
func AtgVdot(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_vdot(ptr, self, other)
|
|
}
|
|
func AtgVdotOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_vdot_out(ptr, out, self, other)
|
|
}
|
|
func AtgView(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_view(ptr, self, csizeDataPtr, csizeLen)
|
|
}
|
|
func AtgViewAs(ptr *Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_view_as(ptr, self, other)
|
|
}
|
|
func AtgViewAsComplex(ptr *Ctensor, self Ctensor){
|
|
C.atg_view_as_complex(ptr, self)
|
|
}
|
|
func AtgViewAsReal(ptr *Ctensor, self Ctensor){
|
|
C.atg_view_as_real(ptr, self)
|
|
}
|
|
func AtgVstack(ptr *Ctensor, tensorsData []Ctensor, tensorsLen int){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
C.atg_vstack(ptr, ctensorsDataPtr, ctensorsLen)
|
|
}
|
|
func AtgVstackOut(ptr *Ctensor, out Ctensor, tensorsData []Ctensor, tensorsLen int){
|
|
ctensorsDataPtr := (*Ctensor)(unsafe.Pointer(&tensorsData[0]))
|
|
ctensorsLen := *(*C.int)(unsafe.Pointer(&tensorsLen))
|
|
C.atg_vstack_out(ptr, out, ctensorsDataPtr, ctensorsLen)
|
|
}
|
|
|
|
func AtgWhere1(ptr *Ctensor, condition Ctensor, self Ctensor, other Ctensor){
|
|
C.atg_where1(ptr, condition, self, other)
|
|
}
|
|
func AtgWhere2(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Ctensor){
|
|
C.atg_where2(ptr, condition, selfScalar , other)
|
|
}
|
|
func AtgWhere3(ptr *Ctensor, condition Ctensor, self Ctensor, other Cscalar){
|
|
C.atg_where3(ptr, condition, self, other )
|
|
}
|
|
func AtgWhere4(ptr *Ctensor, condition Ctensor, selfScalar Cscalar, other Cscalar){
|
|
C.atg_where4(ptr, condition, selfScalar , other )
|
|
}
|
|
func AtgZero_(ptr *Ctensor, self Ctensor){
|
|
C.atg_zero_(ptr, self)
|
|
}
|
|
func AtgZeros(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind))
|
|
coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice))
|
|
C.atg_zeros(ptr, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice)
|
|
}
|
|
func AtgZerosLike(ptr *Ctensor, self Ctensor){
|
|
C.atg_zeros_like(ptr, self)
|
|
}
|
|
func AtgZerosOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int){
|
|
csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0]))
|
|
csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen))
|
|
C.atg_zeros_out(ptr, out, csizeDataPtr, csizeLen)
|
|
}
|