void atg_abs(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::abs(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_abs_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::abs_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_abs_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::abs_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_acos(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::acos(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_acos_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::acos_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_acos_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::acos_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_avg_pool1d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_avg_pool1d(*self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_avg_pool2d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_avg_pool2d(*self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_avg_pool2d_backward(tensor *out__, tensor grad_output, tensor self) {
PROTECT(
auto outputs__ = torch::adaptive_avg_pool2d_backward(*grad_output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_avg_pool2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self) {
PROTECT(
auto outputs__ = torch::adaptive_avg_pool2d_backward_out(*grad_input, *grad_output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_avg_pool2d_out(tensor *out__, tensor output, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_avg_pool2d_out(*output, *self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_avg_pool3d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_avg_pool3d(*self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_avg_pool3d_backward(tensor *out__, tensor grad_output, tensor self) {
PROTECT(
auto outputs__ = torch::adaptive_avg_pool3d_backward(*grad_output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_avg_pool3d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self) {
PROTECT(
auto outputs__ = torch::adaptive_avg_pool3d_backward_out(*grad_input, *grad_output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_avg_pool3d_out(tensor *out__, tensor output, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_avg_pool3d_out(*output, *self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_max_pool1d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_max_pool1d(*self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_adaptive_max_pool2d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_max_pool2d(*self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_adaptive_max_pool2d_backward(tensor *out__, tensor grad_output, tensor self, tensor indices) {
PROTECT(
auto outputs__ = torch::adaptive_max_pool2d_backward(*grad_output, *self, *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_max_pool2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor indices) {
PROTECT(
auto outputs__ = torch::adaptive_max_pool2d_backward_out(*grad_input, *grad_output, *self, *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_max_pool2d_out(tensor *out__, tensor output, tensor indices, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_max_pool2d_out(*output, *indices, *self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_adaptive_max_pool3d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_max_pool3d(*self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_adaptive_max_pool3d_backward(tensor *out__, tensor grad_output, tensor self, tensor indices) {
PROTECT(
auto outputs__ = torch::adaptive_max_pool3d_backward(*grad_output, *self, *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_max_pool3d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor indices) {
PROTECT(
auto outputs__ = torch::adaptive_max_pool3d_backward_out(*grad_input, *grad_output, *self, *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_adaptive_max_pool3d_out(tensor *out__, tensor output, tensor indices, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::adaptive_max_pool3d_out(*output, *indices, *self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_add(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::add(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_add1(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::add(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_add_(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->add_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_add_1(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->add_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_add_out(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::add_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addbmm(tensor *out__, tensor self, tensor batch1, tensor batch2) {
PROTECT(
auto outputs__ = torch::addbmm(*self, *batch1, *batch2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addbmm_(tensor *out__, tensor self, tensor batch1, tensor batch2) {
PROTECT(
auto outputs__ = self->addbmm_(*batch1, *batch2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addbmm_out(tensor *out__, tensor result, tensor self, tensor batch1, tensor batch2) {
PROTECT(
auto outputs__ = torch::addbmm_out(*result, *self, *batch1, *batch2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addcdiv(tensor *out__, tensor self, tensor tensor1, tensor tensor2) {
PROTECT(
auto outputs__ = torch::addcdiv(*self, *tensor1, *tensor2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addcdiv_(tensor *out__, tensor self, tensor tensor1, tensor tensor2) {
PROTECT(
auto outputs__ = self->addcdiv_(*tensor1, *tensor2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addcdiv_out(tensor *out__, tensor result, tensor self, tensor tensor1, tensor tensor2) {
PROTECT(
auto outputs__ = torch::addcdiv_out(*result, *self, *tensor1, *tensor2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addcmul(tensor *out__, tensor self, tensor tensor1, tensor tensor2) {
PROTECT(
auto outputs__ = torch::addcmul(*self, *tensor1, *tensor2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addcmul_(tensor *out__, tensor self, tensor tensor1, tensor tensor2) {
PROTECT(
auto outputs__ = self->addcmul_(*tensor1, *tensor2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addcmul_out(tensor *out__, tensor result, tensor self, tensor tensor1, tensor tensor2) {
PROTECT(
auto outputs__ = torch::addcmul_out(*result, *self, *tensor1, *tensor2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addmm(tensor *out__, tensor self, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = torch::addmm(*self, *mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addmm_(tensor *out__, tensor self, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = self->addmm_(*mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addmm_out(tensor *out__, tensor result, tensor self, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = torch::addmm_out(*result, *self, *mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addmv(tensor *out__, tensor self, tensor mat, tensor vec) {
PROTECT(
auto outputs__ = torch::addmv(*self, *mat, *vec);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addmv_(tensor *out__, tensor self, tensor mat, tensor vec) {
PROTECT(
auto outputs__ = torch::addmv_(*self, *mat, *vec);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addmv_out(tensor *out__, tensor result, tensor self, tensor mat, tensor vec) {
PROTECT(
auto outputs__ = torch::addmv_out(*result, *self, *mat, *vec);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addr(tensor *out__, tensor self, tensor vec1, tensor vec2) {
PROTECT(
auto outputs__ = torch::addr(*self, *vec1, *vec2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addr_(tensor *out__, tensor self, tensor vec1, tensor vec2) {
PROTECT(
auto outputs__ = self->addr_(*vec1, *vec2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_addr_out(tensor *out__, tensor result, tensor self, tensor vec1, tensor vec2) {
PROTECT(
auto outputs__ = torch::addr_out(*result, *self, *vec1, *vec2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_alias(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::alias(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_all(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::all(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_all1(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::all(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_all_out(tensor *out__, tensor result, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::all_out(*result, *self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_alpha_dropout(tensor *out__, tensor input, double p, int train) {
PROTECT(
auto outputs__ = torch::alpha_dropout(*input, p, (bool)train);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_alpha_dropout_(tensor *out__, tensor self, double p, int train) {
PROTECT(
auto outputs__ = torch::alpha_dropout_(*self, p, (bool)train);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_any(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::any(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_any1(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::any(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_any_out(tensor *out__, tensor result, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::any_out(*result, *self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_arange(tensor *out__, scalar end, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::arange(*end, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_arange1(tensor *out__, scalar start, scalar end, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::arange(*start, *end, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_arange2(tensor *out__, scalar start, scalar end, scalar step, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::arange(*start, *end, *step, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_arange_out(tensor *out__, tensor result, scalar end) {
PROTECT(
auto outputs__ = torch::arange_out(*result, *end);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_arange_out1(tensor *out__, tensor result, scalar start, scalar end) {
PROTECT(
auto outputs__ = torch::arange_out(*result, *start, *end);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_arange_out2(tensor *out__, tensor result, scalar start, scalar end, scalar step) {
PROTECT(
auto outputs__ = torch::arange_out(*result, *start, *end, *step);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_argmax(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::argmax(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_argmax1(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::argmax(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_argmin(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::argmin(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_argmin1(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::argmin(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_as_strided(tensor *out__, tensor self, int64_t *size_data, int size_len, int64_t *stride_data, int stride_len) {
PROTECT(
auto outputs__ = torch::as_strided(*self, torch::IntList(size_data, size_len), torch::IntList(stride_data, stride_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_as_strided1(tensor *out__, tensor self, int64_t *size_data, int size_len, int64_t *stride_data, int stride_len, int64_t storage_offset) {
PROTECT(
auto outputs__ = torch::as_strided(*self, torch::IntList(size_data, size_len), torch::IntList(stride_data, stride_len), storage_offset);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_as_strided_(tensor *out__, tensor self, int64_t *size_data, int size_len, int64_t *stride_data, int stride_len) {
PROTECT(
auto outputs__ = torch::as_strided_(*self, torch::IntList(size_data, size_len), torch::IntList(stride_data, stride_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_as_strided_1(tensor *out__, tensor self, int64_t *size_data, int size_len, int64_t *stride_data, int stride_len, int64_t storage_offset) {
PROTECT(
auto outputs__ = torch::as_strided_(*self, torch::IntList(size_data, size_len), torch::IntList(stride_data, stride_len), storage_offset);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_asin(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::asin(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_asin_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::asin_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_asin_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::asin_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_atan(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::atan(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_atan2(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::atan2(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_atan2_(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->atan2_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_atan2_out(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::atan2_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_atan_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::atan_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_atan_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::atan_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_avg_pool1d(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int ceil_mode, int count_include_pad) {
PROTECT(
auto outputs__ = torch::avg_pool1d(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), (bool)ceil_mode, (bool)count_include_pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_avg_pool2d(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int ceil_mode, int count_include_pad) {
PROTECT(
auto outputs__ = torch::avg_pool2d(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), (bool)ceil_mode, (bool)count_include_pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_avg_pool2d_backward(tensor *out__, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int ceil_mode, int count_include_pad) {
PROTECT(
auto outputs__ = torch::avg_pool2d_backward(*grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), (bool)ceil_mode, (bool)count_include_pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_avg_pool2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int ceil_mode, int count_include_pad) {
PROTECT(
auto outputs__ = torch::avg_pool2d_backward_out(*grad_input, *grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), (bool)ceil_mode, (bool)count_include_pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_avg_pool2d_out(tensor *out__, tensor output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int ceil_mode, int count_include_pad) {
PROTECT(
auto outputs__ = torch::avg_pool2d_out(*output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), (bool)ceil_mode, (bool)count_include_pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_avg_pool3d(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int ceil_mode, int count_include_pad) {
PROTECT(
auto outputs__ = torch::avg_pool3d(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), (bool)ceil_mode, (bool)count_include_pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_avg_pool3d_backward(tensor *out__, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int ceil_mode, int count_include_pad) {
PROTECT(
auto outputs__ = torch::avg_pool3d_backward(*grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), (bool)ceil_mode, (bool)count_include_pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_avg_pool3d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int ceil_mode, int count_include_pad) {
PROTECT(
auto outputs__ = torch::avg_pool3d_backward_out(*grad_input, *grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), (bool)ceil_mode, (bool)count_include_pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_avg_pool3d_out(tensor *out__, tensor output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int ceil_mode, int count_include_pad) {
PROTECT(
auto outputs__ = torch::avg_pool3d_out(*output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), (bool)ceil_mode, (bool)count_include_pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_baddbmm(tensor *out__, tensor self, tensor batch1, tensor batch2) {
PROTECT(
auto outputs__ = torch::baddbmm(*self, *batch1, *batch2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_baddbmm_(tensor *out__, tensor self, tensor batch1, tensor batch2) {
PROTECT(
auto outputs__ = self->baddbmm_(*batch1, *batch2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_baddbmm_out(tensor *out__, tensor result, tensor self, tensor batch1, tensor batch2) {
PROTECT(
auto outputs__ = torch::baddbmm_out(*result, *self, *batch1, *batch2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bartlett_window(tensor *out__, int64_t window_length, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::bartlett_window(window_length, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bartlett_window1(tensor *out__, int64_t window_length, int periodic, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::bartlett_window(window_length, (bool)periodic, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_batch_norm(tensor *out__, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int training, double momentum, double eps, int cudnn_enabled) {
PROTECT(
auto outputs__ = torch::batch_norm(*input, (weight ? *weight : torch::Tensor()), (bias ? *bias : torch::Tensor()), (running_mean ? *running_mean : torch::Tensor()), (running_var ? *running_var : torch::Tensor()), (bool)training, momentum, eps, (bool)cudnn_enabled);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bernoulli(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::bernoulli(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bernoulli1(tensor *out__, tensor self, double p) {
PROTECT(
auto outputs__ = torch::bernoulli(*self, p);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bernoulli_(tensor *out__, tensor self, tensor p) {
PROTECT(
auto outputs__ = self->bernoulli_(*p);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bernoulli_1(tensor *out__, tensor self, double p) {
PROTECT(
auto outputs__ = self->bernoulli_(p);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bernoulli_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::bernoulli_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bilinear(tensor *out__, tensor input1, tensor input2, tensor weight, tensor bias) {
PROTECT(
auto outputs__ = torch::bilinear(*input1, *input2, *weight, (bias ? *bias : torch::Tensor()));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_binary_cross_entropy(tensor *out__, tensor self, tensor target, tensor weight, int64_t reduction) {
PROTECT(
auto outputs__ = torch::binary_cross_entropy(*self, *target, *weight, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_binary_cross_entropy_backward(tensor *out__, tensor grad_output, tensor self, tensor target, tensor weight, int64_t reduction) {
PROTECT(
auto outputs__ = torch::binary_cross_entropy_backward(*grad_output, *self, *target, (weight ? *weight : torch::Tensor()), reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_binary_cross_entropy_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor target, tensor weight, int64_t reduction) {
PROTECT(
auto outputs__ = torch::binary_cross_entropy_backward_out(*grad_input, *grad_output, *self, *target, (weight ? *weight : torch::Tensor()), reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_binary_cross_entropy_out(tensor *out__, tensor output, tensor self, tensor target, tensor weight, int64_t reduction) {
PROTECT(
auto outputs__ = torch::binary_cross_entropy_out(*output, *self, *target, *weight, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_binary_cross_entropy_with_logits(tensor *out__, tensor self, tensor target, tensor weight, tensor pos_weight, int64_t reduction) {
PROTECT(
auto outputs__ = torch::binary_cross_entropy_with_logits(*self, *target, (weight ? *weight : torch::Tensor()), (pos_weight ? *pos_weight : torch::Tensor()), reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_binary_cross_entropy_with_logits_backward(tensor *out__, tensor grad_output, tensor self, tensor target, tensor weight, tensor pos_weight, int64_t reduction) {
PROTECT(
auto outputs__ = torch::binary_cross_entropy_with_logits_backward(*grad_output, *self, *target, (weight ? *weight : torch::Tensor()), (pos_weight ? *pos_weight : torch::Tensor()), reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bincount(tensor *out__, tensor self, tensor weights, int64_t minlength) {
PROTECT(
auto outputs__ = torch::bincount(*self, (weights ? *weights : torch::Tensor()), minlength);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_blackman_window(tensor *out__, int64_t window_length, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::blackman_window(window_length, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_blackman_window1(tensor *out__, int64_t window_length, int periodic, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::blackman_window(window_length, (bool)periodic, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bmm(tensor *out__, tensor self, tensor mat2) {
PROTECT(
auto outputs__ = torch::bmm(*self, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_bmm_out(tensor *out__, tensor result, tensor self, tensor mat2) {
PROTECT(
auto outputs__ = torch::bmm_out(*result, *self, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_btrifact(tensor *out__, tensor self, int pivot) {
PROTECT(
auto outputs__ = torch::btrifact(*self, (bool)pivot);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_btrifact_out(tensor *out__, tensor A_LU, tensor pivots, tensor self, int pivot) {
PROTECT(
auto outputs__ = torch::btrifact_out(*A_LU, *pivots, *self, (bool)pivot);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_btrifact_with_info(tensor *out__, tensor self, int pivot) {
PROTECT(
auto outputs__ = torch::btrifact_with_info(*self, (bool)pivot);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_btrifact_with_info_out(tensor *out__, tensor A_LU, tensor pivots, tensor info, tensor self, int pivot) {
PROTECT(
auto outputs__ = torch::btrifact_with_info_out(*A_LU, *pivots, *info, *self, (bool)pivot);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_btrisolve(tensor *out__, tensor self, tensor LU_data, tensor LU_pivots) {
PROTECT(
auto outputs__ = torch::btrisolve(*self, *LU_data, *LU_pivots);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_btrisolve_out(tensor *out__, tensor result, tensor self, tensor LU_data, tensor LU_pivots) {
PROTECT(
auto outputs__ = torch::btrisolve_out(*result, *self, *LU_data, *LU_pivots);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cat(tensor *out__, tensor *tensors_data, int tensors_len, int64_t dim) {
PROTECT(
auto outputs__ = torch::cat(of_carray_tensor(tensors_data, tensors_len), dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cat_out(tensor *out__, tensor result, tensor *tensors_data, int tensors_len, int64_t dim) {
PROTECT(
auto outputs__ = torch::cat_out(*result, of_carray_tensor(tensors_data, tensors_len), dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cauchy_(tensor *out__, tensor self, double median, double sigma) {
PROTECT(
auto outputs__ = self->cauchy_(median, sigma);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ceil(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::ceil(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ceil_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::ceil_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ceil_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::ceil_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_celu(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::celu(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_celu_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::celu_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_chain_matmul(tensor *out__, tensor *matrices_data, int matrices_len) {
PROTECT(
auto outputs__ = torch::chain_matmul(of_carray_tensor(matrices_data, matrices_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cholesky(tensor *out__, tensor self, int upper) {
PROTECT(
auto outputs__ = torch::cholesky(*self, (bool)upper);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cholesky_out(tensor *out__, tensor result, tensor self, int upper) {
PROTECT(
auto outputs__ = torch::cholesky_out(*result, *self, (bool)upper);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clamp(tensor *out__, tensor self, scalar min, scalar max) {
PROTECT(
auto outputs__ = torch::clamp(*self, *min, *max);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clamp_(tensor *out__, tensor self, scalar min, scalar max) {
PROTECT(
auto outputs__ = torch::clamp_(*self, *min, *max);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clamp_max(tensor *out__, tensor self, scalar max) {
PROTECT(
auto outputs__ = torch::clamp_max(*self, *max);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clamp_max_(tensor *out__, tensor self, scalar max) {
PROTECT(
auto outputs__ = torch::clamp_max_(*self, *max);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clamp_max_out(tensor *out__, tensor result, tensor self, scalar max) {
PROTECT(
auto outputs__ = torch::clamp_max_out(*result, *self, *max);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clamp_min(tensor *out__, tensor self, scalar min) {
PROTECT(
auto outputs__ = torch::clamp_min(*self, *min);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clamp_min_(tensor *out__, tensor self, scalar min) {
PROTECT(
auto outputs__ = torch::clamp_min_(*self, *min);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clamp_min_out(tensor *out__, tensor result, tensor self, scalar min) {
PROTECT(
auto outputs__ = torch::clamp_min_out(*result, *self, *min);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clamp_out(tensor *out__, tensor result, tensor self, scalar min, scalar max) {
PROTECT(
auto outputs__ = torch::clamp_out(*result, *self, *min, *max);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_clone(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::clone(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_coalesce(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->coalesce();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_constant_pad_nd(tensor *out__, tensor self, int64_t *pad_data, int pad_len) {
PROTECT(
auto outputs__ = torch::constant_pad_nd(*self, torch::IntList(pad_data, pad_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_contiguous(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->contiguous();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_conv1d(tensor *out__, tensor input, tensor weight, tensor bias, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int64_t groups) {
PROTECT(
auto outputs__ = torch::conv1d(*input, *weight, *bias, torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), groups);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_conv2d(tensor *out__, tensor input, tensor weight, tensor bias, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int64_t groups) {
PROTECT(
auto outputs__ = torch::conv2d(*input, *weight, *bias, torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), groups);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_conv3d(tensor *out__, tensor input, tensor weight, tensor bias, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int64_t groups) {
PROTECT(
auto outputs__ = torch::conv3d(*input, *weight, *bias, torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), groups);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_conv_tbc(tensor *out__, tensor self, tensor weight, tensor bias, int64_t pad) {
PROTECT(
auto outputs__ = torch::conv_tbc(*self, *weight, *bias, pad);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_conv_tbc_backward(tensor *out__, tensor self, tensor input, tensor weight, tensor bias, int64_t pad) {
PROTECT(
auto outputs__ = torch::conv_tbc_backward(*self, *input, *weight, *bias, pad);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_conv_transpose1d(tensor *out__, tensor input, tensor weight, tensor bias, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *output_padding_data, int output_padding_len, int64_t groups, int64_t *dilation_data, int dilation_len) {
PROTECT(
auto outputs__ = torch::conv_transpose1d(*input, *weight, *bias, torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(output_padding_data, output_padding_len), groups, torch::IntList(dilation_data, dilation_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_conv_transpose2d(tensor *out__, tensor input, tensor weight, tensor bias, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *output_padding_data, int output_padding_len, int64_t groups, int64_t *dilation_data, int dilation_len) {
PROTECT(
auto outputs__ = torch::conv_transpose2d(*input, *weight, *bias, torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(output_padding_data, output_padding_len), groups, torch::IntList(dilation_data, dilation_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_conv_transpose3d(tensor *out__, tensor input, tensor weight, tensor bias, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *output_padding_data, int output_padding_len, int64_t groups, int64_t *dilation_data, int dilation_len) {
PROTECT(
auto outputs__ = torch::conv_transpose3d(*input, *weight, *bias, torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(output_padding_data, output_padding_len), groups, torch::IntList(dilation_data, dilation_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_convolution(tensor *out__, tensor input, tensor weight, tensor bias, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int transposed, int64_t *output_padding_data, int output_padding_len, int64_t groups) {
PROTECT(
auto outputs__ = torch::convolution(*input, *weight, (bias ? *bias : torch::Tensor()), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)transposed, torch::IntList(output_padding_data, output_padding_len), groups);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_copy_sparse_to_sparse_(tensor *out__, tensor self, tensor src, int non_blocking) {
PROTECT(
auto outputs__ = torch::copy_sparse_to_sparse_(*self, *src, (bool)non_blocking);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cos(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::cos(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cos_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::cos_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cos_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::cos_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cosh(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::cosh(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cosh_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::cosh_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cosh_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::cosh_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cosine_embedding_loss(tensor *out__, tensor input1, tensor input2, tensor target, double margin, int64_t reduction) {
PROTECT(
auto outputs__ = torch::cosine_embedding_loss(*input1, *input2, *target, margin, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cross(tensor *out__, tensor self, tensor other, int64_t dim) {
PROTECT(
auto outputs__ = torch::cross(*self, *other, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cross_out(tensor *out__, tensor result, tensor self, tensor other, int64_t dim) {
PROTECT(
auto outputs__ = torch::cross_out(*result, *self, *other, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ctc_loss(tensor *out__, tensor log_probs, tensor targets, int64_t *input_lengths_data, int input_lengths_len, int64_t *target_lengths_data, int target_lengths_len, int64_t blank, int64_t reduction) {
PROTECT(
auto outputs__ = torch::ctc_loss(*log_probs, *targets, torch::IntList(input_lengths_data, input_lengths_len), torch::IntList(target_lengths_data, target_lengths_len), blank, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ctc_loss1(tensor *out__, tensor log_probs, tensor targets, tensor input_lengths, tensor target_lengths, int64_t blank, int64_t reduction) {
PROTECT(
auto outputs__ = torch::ctc_loss(*log_probs, *targets, *input_lengths, *target_lengths, blank, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_affine_grid_generator(tensor *out__, tensor theta, int64_t N, int64_t C, int64_t H, int64_t W) {
PROTECT(
auto outputs__ = torch::cudnn_affine_grid_generator(*theta, N, C, H, W);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_affine_grid_generator_backward(tensor *out__, tensor grad, int64_t N, int64_t C, int64_t H, int64_t W) {
PROTECT(
auto outputs__ = torch::cudnn_affine_grid_generator_backward(*grad, N, C, H, W);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_batch_norm(tensor *out__, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int training, double exponential_average_factor, double epsilon) {
PROTECT(
auto outputs__ = torch::cudnn_batch_norm(*input, *weight, (bias ? *bias : torch::Tensor()), (running_mean ? *running_mean : torch::Tensor()), (running_var ? *running_var : torch::Tensor()), (bool)training, exponential_average_factor, epsilon);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_cudnn_batch_norm_backward(tensor *out__, tensor input, tensor grad_output, tensor weight, tensor running_mean, tensor running_var, tensor save_mean, tensor save_var, double epsilon) {
PROTECT(
auto outputs__ = torch::cudnn_batch_norm_backward(*input, *grad_output, *weight, (running_mean ? *running_mean : torch::Tensor()), (running_var ? *running_var : torch::Tensor()), (save_mean ? *save_mean : torch::Tensor()), (save_var ? *save_var : torch::Tensor()), epsilon);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_cudnn_convolution(tensor *out__, tensor self, tensor weight, tensor bias, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::cudnn_convolution(*self, *weight, (bias ? *bias : torch::Tensor()), torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_convolution_backward_bias(tensor *out__, tensor grad_output) {
PROTECT(
auto outputs__ = torch::cudnn_convolution_backward_bias(*grad_output);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_convolution_backward_input(tensor *out__, int64_t *self_size_data, int self_size_len, tensor grad_output, tensor weight, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::cudnn_convolution_backward_input(torch::IntList(self_size_data, self_size_len), *grad_output, *weight, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_convolution_backward_weight(tensor *out__, int64_t *weight_size_data, int weight_size_len, tensor grad_output, tensor self, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::cudnn_convolution_backward_weight(torch::IntList(weight_size_data, weight_size_len), *grad_output, *self, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_convolution_transpose(tensor *out__, tensor self, tensor weight, tensor bias, int64_t *padding_data, int padding_len, int64_t *output_padding_data, int output_padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::cudnn_convolution_transpose(*self, *weight, (bias ? *bias : torch::Tensor()), torch::IntList(padding_data, padding_len), torch::IntList(output_padding_data, output_padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_convolution_transpose_backward_bias(tensor *out__, tensor grad_output) {
PROTECT(
auto outputs__ = torch::cudnn_convolution_transpose_backward_bias(*grad_output);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_convolution_transpose_backward_input(tensor *out__, tensor grad_output, tensor weight, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::cudnn_convolution_transpose_backward_input(*grad_output, *weight, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_convolution_transpose_backward_weight(tensor *out__, int64_t *weight_size_data, int weight_size_len, tensor grad_output, tensor self, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::cudnn_convolution_transpose_backward_weight(torch::IntList(weight_size_data, weight_size_len), *grad_output, *self, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_grid_sampler(tensor *out__, tensor self, tensor grid) {
PROTECT(
auto outputs__ = torch::cudnn_grid_sampler(*self, *grid);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cudnn_grid_sampler_backward(tensor *out__, tensor self, tensor grid, tensor grad_output) {
PROTECT(
auto outputs__ = torch::cudnn_grid_sampler_backward(*self, *grid, *grad_output);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_cumprod(tensor *out__, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::cumprod(*self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cumprod1(tensor *out__, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::cumprod(*self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cumprod_out(tensor *out__, tensor result, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::cumprod_out(*result, *self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cumprod_out1(tensor *out__, tensor result, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::cumprod_out(*result, *self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cumsum(tensor *out__, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::cumsum(*self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cumsum1(tensor *out__, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::cumsum(*self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cumsum_out(tensor *out__, tensor result, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::cumsum_out(*result, *self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_cumsum_out1(tensor *out__, tensor result, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::cumsum_out(*result, *self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_det(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::det(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_detach(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::detach(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_detach_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::detach_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_diag(tensor *out__, tensor self, int64_t diagonal) {
PROTECT(
auto outputs__ = torch::diag(*self, diagonal);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_diag_embed(tensor *out__, tensor self, int64_t offset, int64_t dim1, int64_t dim2) {
PROTECT(
auto outputs__ = torch::diag_embed(*self, offset, dim1, dim2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_diag_out(tensor *out__, tensor result, tensor self, int64_t diagonal) {
PROTECT(
auto outputs__ = torch::diag_out(*result, *self, diagonal);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_diagflat(tensor *out__, tensor self, int64_t offset) {
PROTECT(
auto outputs__ = torch::diagflat(*self, offset);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_diagonal(tensor *out__, tensor self, int64_t offset, int64_t dim1, int64_t dim2) {
PROTECT(
auto outputs__ = torch::diagonal(*self, offset, dim1, dim2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_digamma(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::digamma(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_digamma_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->digamma_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_digamma_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::digamma_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_dist(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::dist(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_div(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::div(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_div1(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::div(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_div_(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->div_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_div_1(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->div_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_div_out(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::div_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_dot(tensor *out__, tensor self, tensor tensor) {
PROTECT(
auto outputs__ = torch::dot(*self, *tensor);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_dot_out(tensor *out__, tensor result, tensor self, tensor tensor) {
PROTECT(
auto outputs__ = torch::dot_out(*result, *self, *tensor);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_dropout(tensor *out__, tensor input, double p, int train) {
PROTECT(
auto outputs__ = torch::dropout(*input, p, (bool)train);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_dropout_(tensor *out__, tensor self, double p, int train) {
PROTECT(
auto outputs__ = torch::dropout_(*self, p, (bool)train);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eig(tensor *out__, tensor self, int eigenvectors) {
PROTECT(
auto outputs__ = torch::eig(*self, (bool)eigenvectors);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_eig_out(tensor *out__, tensor e, tensor v, tensor self, int eigenvectors) {
PROTECT(
auto outputs__ = torch::eig_out(*e, *v, *self, (bool)eigenvectors);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_elu(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::elu(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_elu_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::elu_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_elu_out(tensor *out__, tensor output, tensor self) {
PROTECT(
auto outputs__ = torch::elu_out(*output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_embedding(tensor *out__, tensor weight, tensor indices, int64_t padding_idx, int scale_grad_by_freq, int sparse) {
PROTECT(
auto outputs__ = torch::embedding(*weight, *indices, padding_idx, (bool)scale_grad_by_freq, (bool)sparse);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_embedding_backward(tensor *out__, tensor grad, tensor indices, int64_t num_weights, int64_t padding_idx, int scale_grad_by_freq, int sparse) {
PROTECT(
auto outputs__ = torch::embedding_backward(*grad, *indices, num_weights, padding_idx, (bool)scale_grad_by_freq, (bool)sparse);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_embedding_bag(tensor *out__, tensor weight, tensor indices, tensor offsets, int scale_grad_by_freq, int64_t mode, int sparse) {
PROTECT(
auto outputs__ = torch::embedding_bag(*weight, *indices, *offsets, (bool)scale_grad_by_freq, mode, (bool)sparse);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
out__[3] = new torch::Tensor(std::get<3>(outputs__));
)
}
void atg_embedding_dense_backward(tensor *out__, tensor grad, tensor indices, int64_t num_weights, int64_t padding_idx, int scale_grad_by_freq) {
PROTECT(
auto outputs__ = torch::embedding_dense_backward(*grad, *indices, num_weights, padding_idx, (bool)scale_grad_by_freq);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_embedding_renorm_(tensor *out__, tensor self, tensor indices, double max_norm, double norm_type) {
PROTECT(
auto outputs__ = torch::embedding_renorm_(*self, *indices, max_norm, norm_type);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_embedding_sparse_backward(tensor *out__, tensor grad, tensor indices, int64_t num_weights, int64_t padding_idx, int scale_grad_by_freq) {
PROTECT(
auto outputs__ = torch::embedding_sparse_backward(*grad, *indices, num_weights, padding_idx, (bool)scale_grad_by_freq);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_empty(tensor *out__, int64_t *size_data, int size_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::empty(torch::IntList(size_data, size_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_empty_like(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::empty_like(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_empty_like1(tensor *out__, tensor self, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::empty_like(*self, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_empty_out(tensor *out__, tensor result, int64_t *size_data, int size_len) {
PROTECT(
auto outputs__ = torch::empty_out(*result, torch::IntList(size_data, size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_empty_strided(tensor *out__, int64_t *size_data, int size_len, int64_t *stride_data, int stride_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::empty_strided(torch::IntList(size_data, size_len), torch::IntList(stride_data, stride_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eq(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::eq(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eq1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::eq(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eq_(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->eq_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eq_1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->eq_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eq_out(tensor *out__, tensor result, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::eq_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eq_out1(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::eq_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_erf(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::erf(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_erf_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::erf_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_erf_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::erf_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_erfc(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::erfc(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_erfc_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::erfc_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_erfc_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::erfc_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_erfinv(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::erfinv(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_erfinv_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->erfinv_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_erfinv_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::erfinv_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_exp(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::exp(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_exp_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::exp_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_exp_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::exp_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_expand(tensor *out__, tensor self, int64_t *size_data, int size_len, int implicit) {
PROTECT(
auto outputs__ = self->expand(torch::IntList(size_data, size_len), (bool)implicit);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_expand_as(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->expand_as(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_expm1(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::expm1(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_expm1_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::expm1_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_expm1_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::expm1_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_exponential_(tensor *out__, tensor self, double lambd) {
PROTECT(
auto outputs__ = self->exponential_(lambd);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eye(tensor *out__, int64_t n, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::eye(n, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eye1(tensor *out__, int64_t n, int64_t m, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::eye(n, m, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eye_out(tensor *out__, tensor result, int64_t n) {
PROTECT(
auto outputs__ = torch::eye_out(*result, n);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_eye_out1(tensor *out__, tensor result, int64_t n, int64_t m) {
PROTECT(
auto outputs__ = torch::eye_out(*result, n, m);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_feature_alpha_dropout(tensor *out__, tensor input, double p, int train) {
PROTECT(
auto outputs__ = torch::feature_alpha_dropout(*input, p, (bool)train);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_feature_alpha_dropout_(tensor *out__, tensor self, double p, int train) {
PROTECT(
auto outputs__ = torch::feature_alpha_dropout_(*self, p, (bool)train);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_feature_dropout(tensor *out__, tensor input, double p, int train) {
PROTECT(
auto outputs__ = torch::feature_dropout(*input, p, (bool)train);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_feature_dropout_(tensor *out__, tensor self, double p, int train) {
PROTECT(
auto outputs__ = torch::feature_dropout_(*self, p, (bool)train);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fft(tensor *out__, tensor self, int64_t signal_ndim, int normalized) {
PROTECT(
auto outputs__ = torch::fft(*self, signal_ndim, (bool)normalized);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fill_(tensor *out__, tensor self, scalar value) {
PROTECT(
auto outputs__ = torch::fill_(*self, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fill_1(tensor *out__, tensor self, tensor value) {
PROTECT(
auto outputs__ = torch::fill_(*self, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_flatten(tensor *out__, tensor self, int64_t start_dim, int64_t end_dim) {
PROTECT(
auto outputs__ = torch::flatten(*self, start_dim, end_dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_flip(tensor *out__, tensor self, int64_t *dims_data, int dims_len) {
PROTECT(
auto outputs__ = torch::flip(*self, torch::IntList(dims_data, dims_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_floor(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::floor(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_floor_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::floor_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_floor_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::floor_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fmod(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::fmod(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fmod1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::fmod(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fmod_(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->fmod_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fmod_1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->fmod_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fmod_out(tensor *out__, tensor result, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::fmod_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fmod_out1(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::fmod_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_frac(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::frac(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_frac_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->frac_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_frac_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::frac_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fractional_max_pool2d(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *output_size_data, int output_size_len, tensor random_samples) {
PROTECT(
auto outputs__ = torch::fractional_max_pool2d(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(output_size_data, output_size_len), *random_samples);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_fractional_max_pool2d_backward(tensor *out__, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *output_size_data, int output_size_len, tensor indices) {
PROTECT(
auto outputs__ = torch::fractional_max_pool2d_backward(*grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(output_size_data, output_size_len), *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fractional_max_pool2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *output_size_data, int output_size_len, tensor indices) {
PROTECT(
auto outputs__ = torch::fractional_max_pool2d_backward_out(*grad_input, *grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(output_size_data, output_size_len), *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_fractional_max_pool2d_out(tensor *out__, tensor output, tensor indices, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *output_size_data, int output_size_len, tensor random_samples) {
PROTECT(
auto outputs__ = torch::fractional_max_pool2d_out(*output, *indices, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(output_size_data, output_size_len), *random_samples);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_frobenius_norm(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::frobenius_norm(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_frobenius_norm1(tensor *out__, tensor self, int64_t *dim_data, int dim_len, int keepdim) {
PROTECT(
auto outputs__ = torch::frobenius_norm(*self, torch::IntList(dim_data, dim_len), (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_frobenius_norm_out(tensor *out__, tensor result, tensor self, int64_t *dim_data, int dim_len, int keepdim) {
PROTECT(
auto outputs__ = torch::frobenius_norm_out(*result, *self, torch::IntList(dim_data, dim_len), (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_full(tensor *out__, int64_t *size_data, int size_len, scalar fill_value, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::full(torch::IntList(size_data, size_len), *fill_value, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_full_like(tensor *out__, tensor self, scalar fill_value) {
PROTECT(
auto outputs__ = torch::full_like(*self, *fill_value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_full_like1(tensor *out__, tensor self, scalar fill_value, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::full_like(*self, *fill_value, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_full_out(tensor *out__, tensor result, int64_t *size_data, int size_len, scalar fill_value) {
PROTECT(
auto outputs__ = torch::full_out(*result, torch::IntList(size_data, size_len), *fill_value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gather(tensor *out__, tensor self, int64_t dim, tensor index) {
PROTECT(
auto outputs__ = torch::gather(*self, dim, *index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gather_out(tensor *out__, tensor result, tensor self, int64_t dim, tensor index) {
PROTECT(
auto outputs__ = torch::gather_out(*result, *self, dim, *index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ge(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::ge(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ge1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::ge(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ge_(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->ge_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ge_1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->ge_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ge_out(tensor *out__, tensor result, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::ge_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ge_out1(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::ge_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gels(tensor *out__, tensor self, tensor A) {
PROTECT(
auto outputs__ = torch::gels(*self, *A);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_gels_out(tensor *out__, tensor X, tensor qr, tensor self, tensor A) {
PROTECT(
auto outputs__ = torch::gels_out(*X, *qr, *self, *A);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_geometric_(tensor *out__, tensor self, double p) {
PROTECT(
auto outputs__ = self->geometric_(p);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_geqrf(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::geqrf(*self);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_geqrf_out(tensor *out__, tensor result0, tensor result1, tensor self) {
PROTECT(
auto outputs__ = torch::geqrf_out(*result0, *result1, *self);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_ger(tensor *out__, tensor self, tensor vec2) {
PROTECT(
auto outputs__ = torch::ger(*self, *vec2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ger_out(tensor *out__, tensor result, tensor self, tensor vec2) {
PROTECT(
auto outputs__ = torch::ger_out(*result, *self, *vec2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gesv(tensor *out__, tensor self, tensor A) {
PROTECT(
auto outputs__ = torch::gesv(*self, *A);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_gesv_out(tensor *out__, tensor solution, tensor lu, tensor self, tensor A) {
PROTECT(
auto outputs__ = torch::gesv_out(*solution, *lu, *self, *A);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_glu(tensor *out__, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::glu(*self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_glu_backward(tensor *out__, tensor grad_output, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::glu_backward(*grad_output, *self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_glu_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::glu_backward_out(*grad_input, *grad_output, *self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_glu_out(tensor *out__, tensor output, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::glu_out(*output, *self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_grad(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->grad();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_grid_sampler(tensor *out__, tensor input, tensor grid, int64_t interpolation_mode, int64_t padding_mode) {
PROTECT(
auto outputs__ = torch::grid_sampler(*input, *grid, interpolation_mode, padding_mode);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_grid_sampler_2d(tensor *out__, tensor input, tensor grid, int64_t interpolation_mode, int64_t padding_mode) {
PROTECT(
auto outputs__ = torch::grid_sampler_2d(*input, *grid, interpolation_mode, padding_mode);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_grid_sampler_2d_backward(tensor *out__, tensor grad_output, tensor input, tensor grid, int64_t interpolation_mode, int64_t padding_mode) {
PROTECT(
auto outputs__ = torch::grid_sampler_2d_backward(*grad_output, *input, *grid, interpolation_mode, padding_mode);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_grid_sampler_3d(tensor *out__, tensor input, tensor grid, int64_t interpolation_mode, int64_t padding_mode) {
PROTECT(
auto outputs__ = torch::grid_sampler_3d(*input, *grid, interpolation_mode, padding_mode);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_grid_sampler_3d_backward(tensor *out__, tensor grad_output, tensor input, tensor grid, int64_t interpolation_mode, int64_t padding_mode) {
PROTECT(
auto outputs__ = torch::grid_sampler_3d_backward(*grad_output, *input, *grid, interpolation_mode, padding_mode);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_group_norm(tensor *out__, tensor input, int64_t num_groups, tensor weight, tensor bias, double eps, int cudnn_enabled) {
PROTECT(
auto outputs__ = torch::group_norm(*input, num_groups, (weight ? *weight : torch::Tensor()), (bias ? *bias : torch::Tensor()), eps, (bool)cudnn_enabled);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gru(tensor *out__, tensor input, tensor hx, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional, int batch_first) {
PROTECT(
auto outputs__ = torch::gru(*input, *hx, of_carray_tensor(params_data, params_len), (bool)has_biases, num_layers, dropout, (bool)train, (bool)bidirectional, (bool)batch_first);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_gru1(tensor *out__, tensor data, tensor batch_sizes, tensor hx, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional) {
PROTECT(
auto outputs__ = torch::gru(*data, *batch_sizes, *hx, of_carray_tensor(params_data, params_len), (bool)has_biases, num_layers, dropout, (bool)train, (bool)bidirectional);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_gru_cell(tensor *out__, tensor input, tensor hx, tensor w_ih, tensor w_hh, tensor b_ih, tensor b_hh) {
PROTECT(
auto outputs__ = torch::gru_cell(*input, *hx, *w_ih, *w_hh, (b_ih ? *b_ih : torch::Tensor()), (b_hh ? *b_hh : torch::Tensor()));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gt(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::gt(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gt1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::gt(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gt_(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->gt_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gt_1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->gt_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gt_out(tensor *out__, tensor result, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::gt_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_gt_out1(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::gt_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hamming_window(tensor *out__, int64_t window_length, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::hamming_window(window_length, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hamming_window1(tensor *out__, int64_t window_length, int periodic, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::hamming_window(window_length, (bool)periodic, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hamming_window2(tensor *out__, int64_t window_length, int periodic, double alpha, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::hamming_window(window_length, (bool)periodic, alpha, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hamming_window3(tensor *out__, int64_t window_length, int periodic, double alpha, double beta, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::hamming_window(window_length, (bool)periodic, alpha, beta, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hann_window(tensor *out__, int64_t window_length, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::hann_window(window_length, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hann_window1(tensor *out__, int64_t window_length, int periodic, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::hann_window(window_length, (bool)periodic, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hardshrink(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::hardshrink(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hardshrink_backward(tensor *out__, tensor grad_out, tensor self, scalar lambd) {
PROTECT(
auto outputs__ = torch::hardshrink_backward(*grad_out, *self, *lambd);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hardtanh(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::hardtanh(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hardtanh_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::hardtanh_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hardtanh_out(tensor *out__, tensor output, tensor self) {
PROTECT(
auto outputs__ = torch::hardtanh_out(*output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hinge_embedding_loss(tensor *out__, tensor self, tensor target, double margin, int64_t reduction) {
PROTECT(
auto outputs__ = torch::hinge_embedding_loss(*self, *target, margin, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_histc(tensor *out__, tensor self, int64_t bins) {
PROTECT(
auto outputs__ = torch::histc(*self, bins);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_histc_out(tensor *out__, tensor result, tensor self, int64_t bins) {
PROTECT(
auto outputs__ = torch::histc_out(*result, *self, bins);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hspmm(tensor *out__, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = torch::hspmm(*mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_hspmm_out(tensor *out__, tensor result, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = torch::hspmm_out(*result, *mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ifft(tensor *out__, tensor self, int64_t signal_ndim, int normalized) {
PROTECT(
auto outputs__ = torch::ifft(*self, signal_ndim, (bool)normalized);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_index(tensor *out__, tensor self, tensor *indices_data, int indices_len) {
PROTECT(
auto outputs__ = torch::index(*self, of_carray_tensor(indices_data, indices_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_index_add_(tensor *out__, tensor self, int64_t dim, tensor index, tensor source) {
PROTECT(
auto outputs__ = self->index_add_(dim, *index, *source);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_index_copy_(tensor *out__, tensor self, int64_t dim, tensor index, tensor source) {
PROTECT(
auto outputs__ = self->index_copy_(dim, *index, *source);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_index_fill_(tensor *out__, tensor self, int64_t dim, tensor index, scalar value) {
PROTECT(
auto outputs__ = self->index_fill_(dim, *index, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_index_fill_1(tensor *out__, tensor self, int64_t dim, tensor index, tensor value) {
PROTECT(
auto outputs__ = self->index_fill_(dim, *index, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_index_put(tensor *out__, tensor self, tensor *indices_data, int indices_len, tensor values) {
PROTECT(
auto outputs__ = torch::index_put(*self, of_carray_tensor(indices_data, indices_len), *values);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_index_put_(tensor *out__, tensor self, tensor *indices_data, int indices_len, tensor values) {
PROTECT(
auto outputs__ = torch::index_put_(*self, of_carray_tensor(indices_data, indices_len), *values);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_index_select(tensor *out__, tensor self, int64_t dim, tensor index) {
PROTECT(
auto outputs__ = torch::index_select(*self, dim, *index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_index_select_out(tensor *out__, tensor result, tensor self, int64_t dim, tensor index) {
PROTECT(
auto outputs__ = torch::index_select_out(*result, *self, dim, *index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_indices(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->indices();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_instance_norm(tensor *out__, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int use_input_stats, double momentum, double eps, int cudnn_enabled) {
PROTECT(
auto outputs__ = torch::instance_norm(*input, (weight ? *weight : torch::Tensor()), (bias ? *bias : torch::Tensor()), (running_mean ? *running_mean : torch::Tensor()), (running_var ? *running_var : torch::Tensor()), (bool)use_input_stats, momentum, eps, (bool)cudnn_enabled);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_inverse(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::inverse(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_inverse_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::inverse_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_irfft(tensor *out__, tensor self, int64_t signal_ndim, int normalized, int onesided, int64_t *signal_sizes_data, int signal_sizes_len) {
PROTECT(
auto outputs__ = torch::irfft(*self, signal_ndim, (bool)normalized, (bool)onesided, torch::IntList(signal_sizes_data, signal_sizes_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_isclose(tensor *out__, tensor self, tensor other, double rtol, double atol, int equal_nan) {
PROTECT(
auto outputs__ = torch::isclose(*self, *other, rtol, atol, (bool)equal_nan);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_kl_div(tensor *out__, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::kl_div(*self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_kl_div_backward(tensor *out__, tensor grad_output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::kl_div_backward(*grad_output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_kthvalue(tensor *out__, tensor self, int64_t k, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::kthvalue(*self, k, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_kthvalue_out(tensor *out__, tensor values, tensor indices, tensor self, int64_t k, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::kthvalue_out(*values, *indices, *self, k, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_l1_loss(tensor *out__, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::l1_loss(*self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_l1_loss_backward(tensor *out__, tensor grad_output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::l1_loss_backward(*grad_output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_l1_loss_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::l1_loss_backward_out(*grad_input, *grad_output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_l1_loss_out(tensor *out__, tensor output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::l1_loss_out(*output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_layer_norm(tensor *out__, tensor input, int64_t *normalized_shape_data, int normalized_shape_len, tensor weight, tensor bias, double eps, int cudnn_enable) {
PROTECT(
auto outputs__ = torch::layer_norm(*input, torch::IntList(normalized_shape_data, normalized_shape_len), (weight ? *weight : torch::Tensor()), (bias ? *bias : torch::Tensor()), eps, (bool)cudnn_enable);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_le(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::le(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_le1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::le(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_le_(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->le_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_le_1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->le_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_le_out(tensor *out__, tensor result, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::le_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_le_out1(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::le_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_leaky_relu(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::leaky_relu(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_leaky_relu_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::leaky_relu_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_leaky_relu_out(tensor *out__, tensor output, tensor self) {
PROTECT(
auto outputs__ = torch::leaky_relu_out(*output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lerp(tensor *out__, tensor self, tensor end, scalar weight) {
PROTECT(
auto outputs__ = torch::lerp(*self, *end, *weight);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lerp_(tensor *out__, tensor self, tensor end, scalar weight) {
PROTECT(
auto outputs__ = self->lerp_(*end, *weight);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lerp_out(tensor *out__, tensor result, tensor self, tensor end, scalar weight) {
PROTECT(
auto outputs__ = torch::lerp_out(*result, *self, *end, *weight);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lgamma(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::lgamma(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lgamma_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->lgamma_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lgamma_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::lgamma_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_linear(tensor *out__, tensor input, tensor weight, tensor bias) {
PROTECT(
auto outputs__ = torch::linear(*input, *weight, *bias);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_linspace(tensor *out__, scalar start, scalar end, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::linspace(*start, *end, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_linspace1(tensor *out__, scalar start, scalar end, int64_t steps, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::linspace(*start, *end, steps, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_linspace_out(tensor *out__, tensor result, scalar start, scalar end) {
PROTECT(
auto outputs__ = torch::linspace_out(*result, *start, *end);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_linspace_out1(tensor *out__, tensor result, scalar start, scalar end, int64_t steps) {
PROTECT(
auto outputs__ = torch::linspace_out(*result, *start, *end, steps);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::log(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log10(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::log10(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log10_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::log10_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log10_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::log10_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log1p(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::log1p(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log1p_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::log1p_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log1p_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::log1p_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log2(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::log2(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log2_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::log2_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log2_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::log2_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::log_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log_normal_(tensor *out__, tensor self, double mean, double std) {
PROTECT(
auto outputs__ = self->log_normal_(mean, std);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::log_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log_sigmoid(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::log_sigmoid(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log_sigmoid_backward(tensor *out__, tensor grad_output, tensor self, tensor buffer) {
PROTECT(
auto outputs__ = torch::log_sigmoid_backward(*grad_output, *self, *buffer);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log_sigmoid_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor buffer) {
PROTECT(
auto outputs__ = torch::log_sigmoid_backward_out(*grad_input, *grad_output, *self, *buffer);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log_sigmoid_out(tensor *out__, tensor output, tensor self) {
PROTECT(
auto outputs__ = torch::log_sigmoid_out(*output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log_softmax(tensor *out__, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::log_softmax(*self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_log_softmax1(tensor *out__, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::log_softmax(*self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_logdet(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::logdet(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_logspace(tensor *out__, scalar start, scalar end, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::logspace(*start, *end, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_logspace1(tensor *out__, scalar start, scalar end, int64_t steps, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::logspace(*start, *end, steps, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_logspace_out(tensor *out__, tensor result, scalar start, scalar end) {
PROTECT(
auto outputs__ = torch::logspace_out(*result, *start, *end);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_logspace_out1(tensor *out__, tensor result, scalar start, scalar end, int64_t steps) {
PROTECT(
auto outputs__ = torch::logspace_out(*result, *start, *end, steps);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_logsumexp(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::logsumexp(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_logsumexp_out(tensor *out__, tensor result, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::logsumexp_out(*result, *self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lstm(tensor *out__, tensor input, tensor *hx_data, int hx_len, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional, int batch_first) {
PROTECT(
auto outputs__ = torch::lstm(*input, of_carray_tensor(hx_data, hx_len), of_carray_tensor(params_data, params_len), (bool)has_biases, num_layers, dropout, (bool)train, (bool)bidirectional, (bool)batch_first);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_lstm1(tensor *out__, tensor data, tensor batch_sizes, tensor *hx_data, int hx_len, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional) {
PROTECT(
auto outputs__ = torch::lstm(*data, *batch_sizes, of_carray_tensor(hx_data, hx_len), of_carray_tensor(params_data, params_len), (bool)has_biases, num_layers, dropout, (bool)train, (bool)bidirectional);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_lstm_cell(tensor *out__, tensor input, tensor *hx_data, int hx_len, tensor w_ih, tensor w_hh, tensor b_ih, tensor b_hh) {
PROTECT(
auto outputs__ = torch::lstm_cell(*input, of_carray_tensor(hx_data, hx_len), *w_ih, *w_hh, (b_ih ? *b_ih : torch::Tensor()), (b_hh ? *b_hh : torch::Tensor()));
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_lt(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::lt(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lt1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::lt(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lt_(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->lt_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lt_1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->lt_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lt_out(tensor *out__, tensor result, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::lt_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_lt_out1(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::lt_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_margin_ranking_loss(tensor *out__, tensor input1, tensor input2, tensor target, double margin, int64_t reduction) {
PROTECT(
auto outputs__ = torch::margin_ranking_loss(*input1, *input2, *target, margin, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_masked_fill_(tensor *out__, tensor self, tensor mask, scalar value) {
PROTECT(
auto outputs__ = self->masked_fill_(*mask, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_masked_fill_1(tensor *out__, tensor self, tensor mask, tensor value) {
PROTECT(
auto outputs__ = self->masked_fill_(*mask, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_masked_scatter_(tensor *out__, tensor self, tensor mask, tensor source) {
PROTECT(
auto outputs__ = self->masked_scatter_(*mask, *source);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_masked_select(tensor *out__, tensor self, tensor mask) {
PROTECT(
auto outputs__ = torch::masked_select(*self, *mask);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_masked_select_out(tensor *out__, tensor result, tensor self, tensor mask) {
PROTECT(
auto outputs__ = torch::masked_select_out(*result, *self, *mask);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_matmul(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::matmul(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_matmul_out(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::matmul_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_matrix_power(tensor *out__, tensor self, int64_t n) {
PROTECT(
auto outputs__ = torch::matrix_power(*self, n);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_matrix_rank(tensor *out__, tensor self, int symmetric) {
PROTECT(
auto outputs__ = torch::matrix_rank(*self, (bool)symmetric);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_matrix_rank1(tensor *out__, tensor self, double tol, int symmetric) {
PROTECT(
auto outputs__ = torch::matrix_rank(*self, tol, (bool)symmetric);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::max(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::max(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max2(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::max(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_max_out(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::max_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_out1(tensor *out__, tensor max, tensor max_values, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::max_out(*max, *max_values, *self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_max_pool1d(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) {
PROTECT(
auto outputs__ = torch::max_pool1d(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_pool1d_with_indices(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) {
PROTECT(
auto outputs__ = torch::max_pool1d_with_indices(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_max_pool2d(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) {
PROTECT(
auto outputs__ = torch::max_pool2d(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_pool2d_with_indices(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) {
PROTECT(
auto outputs__ = torch::max_pool2d_with_indices(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_max_pool2d_with_indices_backward(tensor *out__, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode, tensor indices) {
PROTECT(
auto outputs__ = torch::max_pool2d_with_indices_backward(*grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode, *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_pool2d_with_indices_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode, tensor indices) {
PROTECT(
auto outputs__ = torch::max_pool2d_with_indices_backward_out(*grad_input, *grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode, *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_pool2d_with_indices_out(tensor *out__, tensor output, tensor indices, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) {
PROTECT(
auto outputs__ = torch::max_pool2d_with_indices_out(*output, *indices, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_max_pool3d(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) {
PROTECT(
auto outputs__ = torch::max_pool3d(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_pool3d_with_indices(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) {
PROTECT(
auto outputs__ = torch::max_pool3d_with_indices(*self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_max_pool3d_with_indices_backward(tensor *out__, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode, tensor indices) {
PROTECT(
auto outputs__ = torch::max_pool3d_with_indices_backward(*grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode, *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_pool3d_with_indices_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode, tensor indices) {
PROTECT(
auto outputs__ = torch::max_pool3d_with_indices_backward_out(*grad_input, *grad_output, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode, *indices);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_pool3d_with_indices_out(tensor *out__, tensor output, tensor indices, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) {
PROTECT(
auto outputs__ = torch::max_pool3d_with_indices_out(*output, *indices, *self, torch::IntList(kernel_size_data, kernel_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len), torch::IntList(dilation_data, dilation_len), (bool)ceil_mode);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_max_unpool2d(tensor *out__, tensor self, tensor indices, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::max_unpool2d(*self, *indices, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_unpool2d_backward(tensor *out__, tensor grad_output, tensor self, tensor indices, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::max_unpool2d_backward(*grad_output, *self, *indices, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_unpool2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor indices, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::max_unpool2d_backward_out(*grad_input, *grad_output, *self, *indices, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_unpool2d_out(tensor *out__, tensor output, tensor self, tensor indices, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::max_unpool2d_out(*output, *self, *indices, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_unpool3d(tensor *out__, tensor self, tensor indices, int64_t *output_size_data, int output_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::max_unpool3d(*self, *indices, torch::IntList(output_size_data, output_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_unpool3d_backward(tensor *out__, tensor grad_output, tensor self, tensor indices, int64_t *output_size_data, int output_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::max_unpool3d_backward(*grad_output, *self, *indices, torch::IntList(output_size_data, output_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_unpool3d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor indices, int64_t *output_size_data, int output_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::max_unpool3d_backward_out(*grad_input, *grad_output, *self, *indices, torch::IntList(output_size_data, output_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_unpool3d_out(tensor *out__, tensor output, tensor self, tensor indices, int64_t *output_size_data, int output_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::max_unpool3d_out(*output, *self, *indices, torch::IntList(output_size_data, output_size_len), torch::IntList(stride_data, stride_len), torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_max_values(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::max_values(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mean(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::mean(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mean1(tensor *out__, tensor self, int dtype) {
PROTECT(
auto outputs__ = torch::mean(*self, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mean2(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::mean(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mean3(tensor *out__, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::mean(*self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mean4(tensor *out__, tensor self, int64_t dim, int keepdim, int dtype) {
PROTECT(
auto outputs__ = torch::mean(*self, dim, (bool)keepdim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mean_out(tensor *out__, tensor result, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::mean_out(*result, *self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mean_out1(tensor *out__, tensor result, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::mean_out(*result, *self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mean_out2(tensor *out__, tensor result, tensor self, int64_t dim, int keepdim, int dtype) {
PROTECT(
auto outputs__ = torch::mean_out(*result, *self, dim, (bool)keepdim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_median(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::median(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_median1(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::median(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_median_out(tensor *out__, tensor values, tensor indices, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::median_out(*values, *indices, *self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_min(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::min(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_min1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::min(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_min2(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::min(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_min_out(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::min_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_min_out1(tensor *out__, tensor min, tensor min_indices, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::min_out(*min, *min_indices, *self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_min_values(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::min_values(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_miopen_batch_norm(tensor *out__, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int training, double exponential_average_factor, double epsilon) {
PROTECT(
auto outputs__ = torch::miopen_batch_norm(*input, *weight, (bias ? *bias : torch::Tensor()), (running_mean ? *running_mean : torch::Tensor()), (running_var ? *running_var : torch::Tensor()), (bool)training, exponential_average_factor, epsilon);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_miopen_batch_norm_backward(tensor *out__, tensor input, tensor grad_output, tensor weight, tensor running_mean, tensor running_var, tensor save_mean, tensor save_var, double epsilon) {
PROTECT(
auto outputs__ = torch::miopen_batch_norm_backward(*input, *grad_output, *weight, (running_mean ? *running_mean : torch::Tensor()), (running_var ? *running_var : torch::Tensor()), (save_mean ? *save_mean : torch::Tensor()), (save_var ? *save_var : torch::Tensor()), epsilon);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_miopen_convolution(tensor *out__, tensor self, tensor weight, tensor bias, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::miopen_convolution(*self, *weight, (bias ? *bias : torch::Tensor()), torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_miopen_convolution_backward_bias(tensor *out__, tensor grad_output) {
PROTECT(
auto outputs__ = torch::miopen_convolution_backward_bias(*grad_output);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_miopen_convolution_backward_input(tensor *out__, int64_t *self_size_data, int self_size_len, tensor grad_output, tensor weight, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::miopen_convolution_backward_input(torch::IntList(self_size_data, self_size_len), *grad_output, *weight, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_miopen_convolution_backward_weight(tensor *out__, int64_t *weight_size_data, int weight_size_len, tensor grad_output, tensor self, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::miopen_convolution_backward_weight(torch::IntList(weight_size_data, weight_size_len), *grad_output, *self, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_miopen_convolution_transpose(tensor *out__, tensor self, tensor weight, tensor bias, int64_t *padding_data, int padding_len, int64_t *output_padding_data, int output_padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::miopen_convolution_transpose(*self, *weight, (bias ? *bias : torch::Tensor()), torch::IntList(padding_data, padding_len), torch::IntList(output_padding_data, output_padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_miopen_convolution_transpose_backward_input(tensor *out__, tensor grad_output, tensor weight, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::miopen_convolution_transpose_backward_input(*grad_output, *weight, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_miopen_convolution_transpose_backward_weight(tensor *out__, int64_t *weight_size_data, int weight_size_len, tensor grad_output, tensor self, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int benchmark, int deterministic) {
PROTECT(
auto outputs__ = torch::miopen_convolution_transpose_backward_weight(torch::IntList(weight_size_data, weight_size_len), *grad_output, *self, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)benchmark, (bool)deterministic);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mkldnn_convolution(tensor *out__, tensor self, tensor weight, tensor bias, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups) {
PROTECT(
auto outputs__ = torch::mkldnn_convolution(*self, *weight, (bias ? *bias : torch::Tensor()), torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mkldnn_convolution_backward_input(tensor *out__, int64_t *self_size_data, int self_size_len, tensor grad_output, tensor weight, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int bias_defined) {
PROTECT(
auto outputs__ = torch::mkldnn_convolution_backward_input(torch::IntList(self_size_data, self_size_len), *grad_output, *weight, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)bias_defined);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mkldnn_convolution_backward_weights(tensor *out__, int64_t *weight_size_data, int weight_size_len, tensor grad_output, tensor self, int64_t *padding_data, int padding_len, int64_t *stride_data, int stride_len, int64_t *dilation_data, int dilation_len, int64_t groups, int bias_defined) {
PROTECT(
auto outputs__ = torch::mkldnn_convolution_backward_weights(torch::IntList(weight_size_data, weight_size_len), *grad_output, *self, torch::IntList(padding_data, padding_len), torch::IntList(stride_data, stride_len), torch::IntList(dilation_data, dilation_len), groups, (bool)bias_defined);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_mm(tensor *out__, tensor self, tensor mat2) {
PROTECT(
auto outputs__ = torch::mm(*self, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mm_out(tensor *out__, tensor result, tensor self, tensor mat2) {
PROTECT(
auto outputs__ = torch::mm_out(*result, *self, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mode(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::mode(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_mode_out(tensor *out__, tensor values, tensor indices, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::mode_out(*values, *indices, *self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_mse_loss(tensor *out__, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::mse_loss(*self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mse_loss_backward(tensor *out__, tensor grad_output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::mse_loss_backward(*grad_output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mse_loss_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::mse_loss_backward_out(*grad_input, *grad_output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mse_loss_out(tensor *out__, tensor output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::mse_loss_out(*output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mul(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::mul(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mul1(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::mul(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mul_(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->mul_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mul_1(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->mul_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mul_out(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::mul_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_multilabel_margin_loss(tensor *out__, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::multilabel_margin_loss(*self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_multilabel_margin_loss_backward(tensor *out__, tensor grad_output, tensor self, tensor target, int64_t reduction, tensor is_target) {
PROTECT(
auto outputs__ = torch::multilabel_margin_loss_backward(*grad_output, *self, *target, reduction, *is_target);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_multilabel_margin_loss_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor target, int64_t reduction, tensor is_target) {
PROTECT(
auto outputs__ = torch::multilabel_margin_loss_backward_out(*grad_input, *grad_output, *self, *target, reduction, *is_target);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_multilabel_margin_loss_out(tensor *out__, tensor output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::multilabel_margin_loss_out(*output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_multinomial(tensor *out__, tensor self, int64_t num_samples, int replacement) {
PROTECT(
auto outputs__ = torch::multinomial(*self, num_samples, (bool)replacement);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_multinomial_out(tensor *out__, tensor result, tensor self, int64_t num_samples, int replacement) {
PROTECT(
auto outputs__ = torch::multinomial_out(*result, *self, num_samples, (bool)replacement);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mv(tensor *out__, tensor self, tensor vec) {
PROTECT(
auto outputs__ = torch::mv(*self, *vec);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mv_out(tensor *out__, tensor result, tensor self, tensor vec) {
PROTECT(
auto outputs__ = torch::mv_out(*result, *self, *vec);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mvlgamma(tensor *out__, tensor self, int64_t p) {
PROTECT(
auto outputs__ = torch::mvlgamma(*self, p);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_mvlgamma_(tensor *out__, tensor self, int64_t p) {
PROTECT(
auto outputs__ = self->mvlgamma_(p);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_narrow(tensor *out__, tensor self, int64_t dim, int64_t start, int64_t length) {
PROTECT(
auto outputs__ = torch::narrow(*self, dim, start, length);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_narrow_copy(tensor *out__, tensor self, int64_t dim, int64_t start, int64_t length) {
PROTECT(
auto outputs__ = self->narrow_copy(dim, start, length);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_native_batch_norm(tensor *out__, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int training, double momentum, double eps) {
PROTECT(
auto outputs__ = torch::native_batch_norm(*input, (weight ? *weight : torch::Tensor()), (bias ? *bias : torch::Tensor()), (running_mean ? *running_mean : torch::Tensor()), (running_var ? *running_var : torch::Tensor()), (bool)training, momentum, eps);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_native_clone(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::native_clone(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_native_norm(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::native_norm(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_native_pow(tensor *out__, tensor self, scalar exponent) {
PROTECT(
auto outputs__ = torch::native_pow(*self, *exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_native_pow_out(tensor *out__, tensor result, tensor self, scalar exponent) {
PROTECT(
auto outputs__ = torch::native_pow_out(*result, *self, *exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_native_resize_as_(tensor *out__, tensor self, tensor the_template) {
PROTECT(
auto outputs__ = torch::native_resize_as_(*self, *the_template);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_native_zero_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::native_zero_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ne(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::ne(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ne1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::ne(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ne_(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->ne_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ne_1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->ne_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ne_out(tensor *out__, tensor result, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::ne_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ne_out1(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::ne_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_neg(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::neg(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_neg_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->neg_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_neg_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::neg_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nll_loss(tensor *out__, tensor self, tensor target, tensor weight, int64_t reduction, int64_t ignore_index) {
PROTECT(
auto outputs__ = torch::nll_loss(*self, *target, *weight, reduction, ignore_index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nll_loss2d(tensor *out__, tensor self, tensor target, tensor weight, int64_t reduction, int64_t ignore_index) {
PROTECT(
auto outputs__ = torch::nll_loss2d(*self, *target, *weight, reduction, ignore_index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nll_loss2d_backward(tensor *out__, tensor grad_output, tensor self, tensor target, tensor weight, int64_t reduction, int64_t ignore_index, tensor total_weight) {
PROTECT(
auto outputs__ = torch::nll_loss2d_backward(*grad_output, *self, *target, (weight ? *weight : torch::Tensor()), reduction, ignore_index, *total_weight);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nll_loss2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor target, tensor weight, int64_t reduction, int64_t ignore_index, tensor total_weight) {
PROTECT(
auto outputs__ = torch::nll_loss2d_backward_out(*grad_input, *grad_output, *self, *target, (weight ? *weight : torch::Tensor()), reduction, ignore_index, *total_weight);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nll_loss2d_out(tensor *out__, tensor output, tensor self, tensor target, tensor weight, int64_t reduction, int64_t ignore_index) {
PROTECT(
auto outputs__ = torch::nll_loss2d_out(*output, *self, *target, *weight, reduction, ignore_index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nll_loss_backward(tensor *out__, tensor grad_output, tensor self, tensor target, tensor weight, int64_t reduction, int64_t ignore_index, tensor total_weight) {
PROTECT(
auto outputs__ = torch::nll_loss_backward(*grad_output, *self, *target, (weight ? *weight : torch::Tensor()), reduction, ignore_index, *total_weight);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nll_loss_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor target, tensor weight, int64_t reduction, int64_t ignore_index, tensor total_weight) {
PROTECT(
auto outputs__ = torch::nll_loss_backward_out(*grad_input, *grad_output, *self, *target, (weight ? *weight : torch::Tensor()), reduction, ignore_index, *total_weight);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nll_loss_out(tensor *out__, tensor output, tensor self, tensor target, tensor weight, int64_t reduction, int64_t ignore_index) {
PROTECT(
auto outputs__ = torch::nll_loss_out(*output, *self, *target, *weight, reduction, ignore_index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nonzero(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::nonzero(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nonzero_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::nonzero_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_norm(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::norm(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_norm1(tensor *out__, tensor self, scalar p, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::norm(*self, *p, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_norm_except_dim(tensor *out__, tensor v, int64_t pow, int64_t dim) {
PROTECT(
auto outputs__ = torch::norm_except_dim(*v, pow, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_norm_out(tensor *out__, tensor result, tensor self, scalar p, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::norm_out(*result, *self, *p, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_normal(tensor *out__, tensor mean, double std) {
PROTECT(
auto outputs__ = torch::normal(*mean, std);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_normal1(tensor *out__, double mean, tensor std) {
PROTECT(
auto outputs__ = torch::normal(mean, *std);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_normal2(tensor *out__, tensor mean, tensor std) {
PROTECT(
auto outputs__ = torch::normal(*mean, *std);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_normal_(tensor *out__, tensor self, double mean, double std) {
PROTECT(
auto outputs__ = self->normal_(mean, std);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_normal_out(tensor *out__, tensor output, tensor mean, double std) {
PROTECT(
auto outputs__ = torch::normal_out(*output, *mean, std);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_normal_out1(tensor *out__, tensor output, double mean, tensor std) {
PROTECT(
auto outputs__ = torch::normal_out(*output, mean, *std);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_normal_out2(tensor *out__, tensor output, tensor mean, tensor std) {
PROTECT(
auto outputs__ = torch::normal_out(*output, *mean, *std);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nuclear_norm(tensor *out__, tensor self, int keepdim) {
PROTECT(
auto outputs__ = torch::nuclear_norm(*self, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_nuclear_norm_out(tensor *out__, tensor result, tensor self, int keepdim) {
PROTECT(
auto outputs__ = torch::nuclear_norm_out(*result, *self, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ones(tensor *out__, int64_t *size_data, int size_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::ones(torch::IntList(size_data, size_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ones_like(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::ones_like(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ones_like1(tensor *out__, tensor self, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::ones_like(*self, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ones_out(tensor *out__, tensor result, int64_t *size_data, int size_len) {
PROTECT(
auto outputs__ = torch::ones_out(*result, torch::IntList(size_data, size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_orgqr(tensor *out__, tensor self, tensor input2) {
PROTECT(
auto outputs__ = torch::orgqr(*self, *input2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_orgqr_out(tensor *out__, tensor result, tensor self, tensor input2) {
PROTECT(
auto outputs__ = torch::orgqr_out(*result, *self, *input2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ormqr(tensor *out__, tensor self, tensor input2, tensor input3, int left, int transpose) {
PROTECT(
auto outputs__ = torch::ormqr(*self, *input2, *input3, (bool)left, (bool)transpose);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_ormqr_out(tensor *out__, tensor result, tensor self, tensor input2, tensor input3, int left, int transpose) {
PROTECT(
auto outputs__ = torch::ormqr_out(*result, *self, *input2, *input3, (bool)left, (bool)transpose);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pairwise_distance(tensor *out__, tensor x1, tensor x2, double p, double eps, int keepdim) {
PROTECT(
auto outputs__ = torch::pairwise_distance(*x1, *x2, p, eps, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pdist(tensor *out__, tensor self, double p) {
PROTECT(
auto outputs__ = torch::pdist(*self, p);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_permute(tensor *out__, tensor self, int64_t *dims_data, int dims_len) {
PROTECT(
auto outputs__ = self->permute(torch::IntList(dims_data, dims_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pin_memory(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::pin_memory(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pinverse(tensor *out__, tensor self, double rcond) {
PROTECT(
auto outputs__ = torch::pinverse(*self, rcond);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pixel_shuffle(tensor *out__, tensor self, int64_t upscale_factor) {
PROTECT(
auto outputs__ = torch::pixel_shuffle(*self, upscale_factor);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_poisson(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::poisson(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_polygamma(tensor *out__, int64_t n, tensor self) {
PROTECT(
auto outputs__ = torch::polygamma(n, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_polygamma_(tensor *out__, tensor self, int64_t n) {
PROTECT(
auto outputs__ = self->polygamma_(n);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_polygamma_out(tensor *out__, tensor result, int64_t n, tensor self) {
PROTECT(
auto outputs__ = torch::polygamma_out(*result, n, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_potri(tensor *out__, tensor self, int upper) {
PROTECT(
auto outputs__ = torch::potri(*self, (bool)upper);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_potri_out(tensor *out__, tensor result, tensor self, int upper) {
PROTECT(
auto outputs__ = torch::potri_out(*result, *self, (bool)upper);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_potrs(tensor *out__, tensor self, tensor input2, int upper) {
PROTECT(
auto outputs__ = torch::potrs(*self, *input2, (bool)upper);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_potrs_out(tensor *out__, tensor result, tensor self, tensor input2, int upper) {
PROTECT(
auto outputs__ = torch::potrs_out(*result, *self, *input2, (bool)upper);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pow(tensor *out__, tensor self, scalar exponent) {
PROTECT(
auto outputs__ = torch::pow(*self, *exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pow1(tensor *out__, tensor self, tensor exponent) {
PROTECT(
auto outputs__ = torch::pow(*self, *exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pow2(tensor *out__, scalar self_scalar, tensor exponent) {
PROTECT(
auto outputs__ = torch::pow(*self_scalar, *exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pow_(tensor *out__, tensor self, scalar exponent) {
PROTECT(
auto outputs__ = self->pow_(*exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pow_1(tensor *out__, tensor self, tensor exponent) {
PROTECT(
auto outputs__ = self->pow_(*exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pow_out(tensor *out__, tensor result, tensor self, scalar exponent) {
PROTECT(
auto outputs__ = torch::pow_out(*result, *self, *exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pow_out1(tensor *out__, tensor result, tensor self, tensor exponent) {
PROTECT(
auto outputs__ = torch::pow_out(*result, *self, *exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pow_out2(tensor *out__, tensor result, scalar self_scalar, tensor exponent) {
PROTECT(
auto outputs__ = torch::pow_out(*result, *self_scalar, *exponent);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_prelu(tensor *out__, tensor self, tensor weight) {
PROTECT(
auto outputs__ = torch::prelu(*self, *weight);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_prelu_backward(tensor *out__, tensor grad_output, tensor self, tensor weight) {
PROTECT(
auto outputs__ = torch::prelu_backward(*grad_output, *self, *weight);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_prod(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::prod(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_prod1(tensor *out__, tensor self, int dtype) {
PROTECT(
auto outputs__ = torch::prod(*self, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_prod2(tensor *out__, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::prod(*self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_prod3(tensor *out__, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::prod(*self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_prod4(tensor *out__, tensor self, int64_t dim, int keepdim, int dtype) {
PROTECT(
auto outputs__ = torch::prod(*self, dim, (bool)keepdim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_prod_out(tensor *out__, tensor result, tensor self, int64_t dim, int keepdim) {
PROTECT(
auto outputs__ = torch::prod_out(*result, *self, dim, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_prod_out1(tensor *out__, tensor result, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::prod_out(*result, *self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_prod_out2(tensor *out__, tensor result, tensor self, int64_t dim, int keepdim, int dtype) {
PROTECT(
auto outputs__ = torch::prod_out(*result, *self, dim, (bool)keepdim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_pstrf(tensor *out__, tensor self, int upper) {
PROTECT(
auto outputs__ = torch::pstrf(*self, (bool)upper);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_pstrf_out(tensor *out__, tensor u, tensor piv, tensor self, int upper) {
PROTECT(
auto outputs__ = torch::pstrf_out(*u, *piv, *self, (bool)upper);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_put_(tensor *out__, tensor self, tensor index, tensor source, int accumulate) {
PROTECT(
auto outputs__ = self->put_(*index, *source, (bool)accumulate);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_qr(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::qr(*self);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_qr_out(tensor *out__, tensor Q, tensor R, tensor self) {
PROTECT(
auto outputs__ = torch::qr_out(*Q, *R, *self);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_rand(tensor *out__, int64_t *size_data, int size_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::rand(torch::IntList(size_data, size_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rand_like(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::rand_like(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rand_like1(tensor *out__, tensor self, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::rand_like(*self, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rand_out(tensor *out__, tensor result, int64_t *size_data, int size_len) {
PROTECT(
auto outputs__ = torch::rand_out(*result, torch::IntList(size_data, size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randint(tensor *out__, int64_t high, int64_t *size_data, int size_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::randint(high, torch::IntList(size_data, size_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randint1(tensor *out__, int64_t low, int64_t high, int64_t *size_data, int size_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::randint(low, high, torch::IntList(size_data, size_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randint_like(tensor *out__, tensor self, int64_t high) {
PROTECT(
auto outputs__ = torch::randint_like(*self, high);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randint_like1(tensor *out__, tensor self, int64_t low, int64_t high) {
PROTECT(
auto outputs__ = torch::randint_like(*self, low, high);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randint_like2(tensor *out__, tensor self, int64_t high, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::randint_like(*self, high, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randint_like3(tensor *out__, tensor self, int64_t low, int64_t high, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::randint_like(*self, low, high, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randint_out(tensor *out__, tensor result, int64_t high, int64_t *size_data, int size_len) {
PROTECT(
auto outputs__ = torch::randint_out(*result, high, torch::IntList(size_data, size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randint_out1(tensor *out__, tensor result, int64_t low, int64_t high, int64_t *size_data, int size_len) {
PROTECT(
auto outputs__ = torch::randint_out(*result, low, high, torch::IntList(size_data, size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randn(tensor *out__, int64_t *size_data, int size_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::randn(torch::IntList(size_data, size_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randn_like(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::randn_like(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randn_like1(tensor *out__, tensor self, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::randn_like(*self, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randn_out(tensor *out__, tensor result, int64_t *size_data, int size_len) {
PROTECT(
auto outputs__ = torch::randn_out(*result, torch::IntList(size_data, size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_random_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->random_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_random_1(tensor *out__, tensor self, int64_t to) {
PROTECT(
auto outputs__ = self->random_(to);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_random_2(tensor *out__, tensor self, int64_t from, int64_t to) {
PROTECT(
auto outputs__ = self->random_(from, to);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randperm(tensor *out__, int64_t n, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::randperm(n, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_randperm_out(tensor *out__, tensor result, int64_t n) {
PROTECT(
auto outputs__ = torch::randperm_out(*result, n);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_range(tensor *out__, scalar start, scalar end, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::range(*start, *end, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_range1(tensor *out__, scalar start, scalar end, scalar step, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::range(*start, *end, *step, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_range_out(tensor *out__, tensor result, scalar start, scalar end) {
PROTECT(
auto outputs__ = torch::range_out(*result, *start, *end);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_range_out1(tensor *out__, tensor result, scalar start, scalar end, scalar step) {
PROTECT(
auto outputs__ = torch::range_out(*result, *start, *end, *step);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reciprocal(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::reciprocal(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reciprocal_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->reciprocal_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reciprocal_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::reciprocal_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reflection_pad1d(tensor *out__, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::reflection_pad1d(*self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reflection_pad1d_backward(tensor *out__, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::reflection_pad1d_backward(*grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reflection_pad1d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::reflection_pad1d_backward_out(*grad_input, *grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reflection_pad1d_out(tensor *out__, tensor output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::reflection_pad1d_out(*output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reflection_pad2d(tensor *out__, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::reflection_pad2d(*self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reflection_pad2d_backward(tensor *out__, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::reflection_pad2d_backward(*grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reflection_pad2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::reflection_pad2d_backward_out(*grad_input, *grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reflection_pad2d_out(tensor *out__, tensor output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::reflection_pad2d_out(*output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_relu(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::relu(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_relu_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::relu_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_remainder(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::remainder(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_remainder1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::remainder(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_remainder_(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->remainder_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_remainder_1(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->remainder_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_remainder_out(tensor *out__, tensor result, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::remainder_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_remainder_out1(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::remainder_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_renorm(tensor *out__, tensor self, scalar p, int64_t dim, scalar maxnorm) {
PROTECT(
auto outputs__ = torch::renorm(*self, *p, dim, *maxnorm);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_renorm_(tensor *out__, tensor self, scalar p, int64_t dim, scalar maxnorm) {
PROTECT(
auto outputs__ = self->renorm_(*p, dim, *maxnorm);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_renorm_out(tensor *out__, tensor result, tensor self, scalar p, int64_t dim, scalar maxnorm) {
PROTECT(
auto outputs__ = torch::renorm_out(*result, *self, *p, dim, *maxnorm);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_repeat(tensor *out__, tensor self, int64_t *repeats_data, int repeats_len) {
PROTECT(
auto outputs__ = self->repeat(torch::IntList(repeats_data, repeats_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad1d(tensor *out__, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad1d(*self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad1d_backward(tensor *out__, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad1d_backward(*grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad1d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad1d_backward_out(*grad_input, *grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad1d_out(tensor *out__, tensor output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad1d_out(*output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad2d(tensor *out__, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad2d(*self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad2d_backward(tensor *out__, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad2d_backward(*grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad2d_backward_out(*grad_input, *grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad2d_out(tensor *out__, tensor output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad2d_out(*output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad3d(tensor *out__, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad3d(*self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad3d_backward(tensor *out__, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad3d_backward(*grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad3d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad3d_backward_out(*grad_input, *grad_output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_replication_pad3d_out(tensor *out__, tensor output, tensor self, int64_t *padding_data, int padding_len) {
PROTECT(
auto outputs__ = torch::replication_pad3d_out(*output, *self, torch::IntList(padding_data, padding_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reshape(tensor *out__, tensor self, int64_t *shape_data, int shape_len) {
PROTECT(
auto outputs__ = torch::reshape(*self, torch::IntList(shape_data, shape_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_reshape_as(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->reshape_as(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_resize_(tensor *out__, tensor self, int64_t *size_data, int size_len) {
PROTECT(
auto outputs__ = self->resize_(torch::IntList(size_data, size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_resize_as_(tensor *out__, tensor self, tensor the_template) {
PROTECT(
auto outputs__ = torch::resize_as_(*self, *the_template);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rfft(tensor *out__, tensor self, int64_t signal_ndim, int normalized, int onesided) {
PROTECT(
auto outputs__ = torch::rfft(*self, signal_ndim, (bool)normalized, (bool)onesided);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rnn_relu(tensor *out__, tensor input, tensor hx, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional, int batch_first) {
PROTECT(
auto outputs__ = torch::rnn_relu(*input, *hx, of_carray_tensor(params_data, params_len), (bool)has_biases, num_layers, dropout, (bool)train, (bool)bidirectional, (bool)batch_first);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_rnn_relu1(tensor *out__, tensor data, tensor batch_sizes, tensor hx, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional) {
PROTECT(
auto outputs__ = torch::rnn_relu(*data, *batch_sizes, *hx, of_carray_tensor(params_data, params_len), (bool)has_biases, num_layers, dropout, (bool)train, (bool)bidirectional);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_rnn_relu_cell(tensor *out__, tensor input, tensor hx, tensor w_ih, tensor w_hh, tensor b_ih, tensor b_hh) {
PROTECT(
auto outputs__ = torch::rnn_relu_cell(*input, *hx, *w_ih, *w_hh, (b_ih ? *b_ih : torch::Tensor()), (b_hh ? *b_hh : torch::Tensor()));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rnn_tanh(tensor *out__, tensor input, tensor hx, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional, int batch_first) {
PROTECT(
auto outputs__ = torch::rnn_tanh(*input, *hx, of_carray_tensor(params_data, params_len), (bool)has_biases, num_layers, dropout, (bool)train, (bool)bidirectional, (bool)batch_first);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_rnn_tanh1(tensor *out__, tensor data, tensor batch_sizes, tensor hx, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional) {
PROTECT(
auto outputs__ = torch::rnn_tanh(*data, *batch_sizes, *hx, of_carray_tensor(params_data, params_len), (bool)has_biases, num_layers, dropout, (bool)train, (bool)bidirectional);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_rnn_tanh_cell(tensor *out__, tensor input, tensor hx, tensor w_ih, tensor w_hh, tensor b_ih, tensor b_hh) {
PROTECT(
auto outputs__ = torch::rnn_tanh_cell(*input, *hx, *w_ih, *w_hh, (b_ih ? *b_ih : torch::Tensor()), (b_hh ? *b_hh : torch::Tensor()));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_roipooling2d_backward(tensor *out__, tensor input, tensor rois, int64_t pooledHeight, int64_t pooledWidth, double spatialScale, tensor gradOutput, tensor argmaxes) {
PROTECT(
auto outputs__ = torch::RoiPooling2d_backward(*input, *rois, pooledHeight, pooledWidth, spatialScale, *gradOutput, *argmaxes);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_roll(tensor *out__, tensor self, int64_t *shifts_data, int shifts_len, int64_t *dims_data, int dims_len) {
PROTECT(
auto outputs__ = torch::roll(*self, torch::IntList(shifts_data, shifts_len), torch::IntList(dims_data, dims_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rot90(tensor *out__, tensor self, int64_t k, int64_t *dims_data, int dims_len) {
PROTECT(
auto outputs__ = torch::rot90(*self, k, torch::IntList(dims_data, dims_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_round(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::round(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_round_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::round_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_round_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::round_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rrelu(tensor *out__, tensor self, int training) {
PROTECT(
auto outputs__ = torch::rrelu(*self, (bool)training);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rrelu_(tensor *out__, tensor self, int training) {
PROTECT(
auto outputs__ = torch::rrelu_(*self, (bool)training);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rrelu_with_noise(tensor *out__, tensor self, tensor noise, int training) {
PROTECT(
auto outputs__ = torch::rrelu_with_noise(*self, *noise, (bool)training);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rrelu_with_noise_(tensor *out__, tensor self, tensor noise, int training) {
PROTECT(
auto outputs__ = torch::rrelu_with_noise_(*self, *noise, (bool)training);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rrelu_with_noise_out(tensor *out__, tensor output, tensor self, tensor noise, int training) {
PROTECT(
auto outputs__ = torch::rrelu_with_noise_out(*output, *self, *noise, (bool)training);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rsqrt(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::rsqrt(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rsqrt_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::rsqrt_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rsqrt_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::rsqrt_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rsub(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::rsub(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_rsub1(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::rsub(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_s_native_addmm(tensor *out__, tensor self, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = torch::s_native_addmm(*self, *mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_s_native_addmm_(tensor *out__, tensor self, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = torch::s_native_addmm_(*self, *mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_s_native_addmm_out(tensor *out__, tensor result, tensor self, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = torch::s_native_addmm_out(*result, *self, *mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_scatter_(tensor *out__, tensor self, int64_t dim, tensor index, tensor src) {
PROTECT(
auto outputs__ = self->scatter_(dim, *index, *src);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_scatter_1(tensor *out__, tensor self, int64_t dim, tensor index, scalar value) {
PROTECT(
auto outputs__ = self->scatter_(dim, *index, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_scatter_add_(tensor *out__, tensor self, int64_t dim, tensor index, tensor src) {
PROTECT(
auto outputs__ = self->scatter_add_(dim, *index, *src);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_select(tensor *out__, tensor self, int64_t dim, int64_t index) {
PROTECT(
auto outputs__ = torch::select(*self, dim, index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_selu(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::selu(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_selu_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::selu_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_set_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->set_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_set_1(tensor *out__, tensor self, tensor source) {
PROTECT(
auto outputs__ = self->set_(*source);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_set_requires_grad(tensor *out__, tensor self, int r) {
PROTECT(
auto outputs__ = self->set_requires_grad((bool)r);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sigmoid(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sigmoid(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sigmoid_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sigmoid_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sigmoid_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::sigmoid_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sign(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sign(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sign_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->sign_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sign_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::sign_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sin(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sin(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sin_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sin_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sin_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::sin_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sinh(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sinh(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sinh_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sinh_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sinh_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::sinh_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_slice(tensor *out__, tensor self, int64_t dim, int64_t start, int64_t end, int64_t step) {
PROTECT(
auto outputs__ = torch::slice(*self, dim, start, end, step);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_slogdet(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::slogdet(*self);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_smm(tensor *out__, tensor self, tensor mat2) {
PROTECT(
auto outputs__ = torch::smm(*self, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_smooth_l1_loss(tensor *out__, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::smooth_l1_loss(*self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_smooth_l1_loss_backward(tensor *out__, tensor grad_output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::smooth_l1_loss_backward(*grad_output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_smooth_l1_loss_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::smooth_l1_loss_backward_out(*grad_input, *grad_output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_smooth_l1_loss_out(tensor *out__, tensor output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::smooth_l1_loss_out(*output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_soft_margin_loss(tensor *out__, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::soft_margin_loss(*self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_soft_margin_loss_backward(tensor *out__, tensor grad_output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::soft_margin_loss_backward(*grad_output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_soft_margin_loss_backward_out(tensor *out__, tensor grad_input, tensor grad_output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::soft_margin_loss_backward_out(*grad_input, *grad_output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_soft_margin_loss_out(tensor *out__, tensor output, tensor self, tensor target, int64_t reduction) {
PROTECT(
auto outputs__ = torch::soft_margin_loss_out(*output, *self, *target, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_softmax(tensor *out__, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::softmax(*self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_softmax1(tensor *out__, tensor self, int64_t dim, int dtype) {
PROTECT(
auto outputs__ = torch::softmax(*self, dim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_softplus(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::softplus(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_softplus_out(tensor *out__, tensor output, tensor self) {
PROTECT(
auto outputs__ = torch::softplus_out(*output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_softshrink(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::softshrink(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_softshrink_out(tensor *out__, tensor output, tensor self) {
PROTECT(
auto outputs__ = torch::softshrink_out(*output, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sort(tensor *out__, tensor self, int64_t dim, int descending) {
PROTECT(
auto outputs__ = torch::sort(*self, dim, (bool)descending);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_sort_out(tensor *out__, tensor values, tensor indices, tensor self, int64_t dim, int descending) {
PROTECT(
auto outputs__ = torch::sort_out(*values, *indices, *self, dim, (bool)descending);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_sparse_coo_tensor(tensor *out__, int64_t *size_data, int size_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::sparse_coo_tensor(torch::IntList(size_data, size_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sparse_coo_tensor1(tensor *out__, tensor indices, tensor values, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::sparse_coo_tensor(*indices, *values, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sparse_coo_tensor2(tensor *out__, tensor indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::sparse_coo_tensor(*indices, *values, torch::IntList(size_data, size_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sparse_resize_(tensor *out__, tensor self, int64_t *size_data, int size_len, int64_t sparse_dim, int64_t dense_dim) {
PROTECT(
auto outputs__ = self->sparse_resize_(torch::IntList(size_data, size_len), sparse_dim, dense_dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sparse_resize_and_clear_(tensor *out__, tensor self, int64_t *size_data, int size_len, int64_t sparse_dim, int64_t dense_dim) {
PROTECT(
auto outputs__ = self->sparse_resize_and_clear_(torch::IntList(size_data, size_len), sparse_dim, dense_dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sqrt(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sqrt(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sqrt_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sqrt_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sqrt_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::sqrt_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_squeeze(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::squeeze(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_squeeze1(tensor *out__, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::squeeze(*self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_squeeze_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->squeeze_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_squeeze_1(tensor *out__, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = self->squeeze_(dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sspaddmm(tensor *out__, tensor self, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = torch::sspaddmm(*self, *mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sspaddmm_out(tensor *out__, tensor result, tensor self, tensor mat1, tensor mat2) {
PROTECT(
auto outputs__ = torch::sspaddmm_out(*result, *self, *mat1, *mat2);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_stack(tensor *out__, tensor *tensors_data, int tensors_len, int64_t dim) {
PROTECT(
auto outputs__ = torch::stack(of_carray_tensor(tensors_data, tensors_len), dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_stack_out(tensor *out__, tensor result, tensor *tensors_data, int tensors_len, int64_t dim) {
PROTECT(
auto outputs__ = torch::stack_out(*result, of_carray_tensor(tensors_data, tensors_len), dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_std(tensor *out__, tensor self, int unbiased) {
PROTECT(
auto outputs__ = torch::std(*self, (bool)unbiased);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_std1(tensor *out__, tensor self, int64_t dim, int unbiased, int keepdim) {
PROTECT(
auto outputs__ = torch::std(*self, dim, (bool)unbiased, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_std_out(tensor *out__, tensor result, tensor self, int64_t dim, int unbiased, int keepdim) {
PROTECT(
auto outputs__ = torch::std_out(*result, *self, dim, (bool)unbiased, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_stft(tensor *out__, tensor self, int64_t n_fft, int64_t hop_length, int64_t win_length, tensor window, int normalized, int onesided) {
PROTECT(
auto outputs__ = torch::stft(*self, n_fft, hop_length, win_length, (window ? *window : torch::Tensor()), (bool)normalized, (bool)onesided);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sub(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::sub(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sub1(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = torch::sub(*self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sub_(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->sub_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sub_1(tensor *out__, tensor self, scalar other) {
PROTECT(
auto outputs__ = self->sub_(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sub_out(tensor *out__, tensor result, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::sub_out(*result, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sum(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::sum(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sum1(tensor *out__, tensor self, int dtype) {
PROTECT(
auto outputs__ = torch::sum(*self, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sum2(tensor *out__, tensor self, int64_t *dim_data, int dim_len, int keepdim) {
PROTECT(
auto outputs__ = torch::sum(*self, torch::IntList(dim_data, dim_len), (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sum3(tensor *out__, tensor self, int64_t *dim_data, int dim_len, int dtype) {
PROTECT(
auto outputs__ = torch::sum(*self, torch::IntList(dim_data, dim_len), torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sum4(tensor *out__, tensor self, int64_t *dim_data, int dim_len, int keepdim, int dtype) {
PROTECT(
auto outputs__ = torch::sum(*self, torch::IntList(dim_data, dim_len), (bool)keepdim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sum_out(tensor *out__, tensor result, tensor self, int64_t *dim_data, int dim_len, int keepdim) {
PROTECT(
auto outputs__ = torch::sum_out(*result, *self, torch::IntList(dim_data, dim_len), (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sum_out1(tensor *out__, tensor result, tensor self, int64_t *dim_data, int dim_len, int dtype) {
PROTECT(
auto outputs__ = torch::sum_out(*result, *self, torch::IntList(dim_data, dim_len), torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_sum_out2(tensor *out__, tensor result, tensor self, int64_t *dim_data, int dim_len, int keepdim, int dtype) {
PROTECT(
auto outputs__ = torch::sum_out(*result, *self, torch::IntList(dim_data, dim_len), (bool)keepdim, torch::ScalarType(dtype));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_svd(tensor *out__, tensor self, int some, int compute_uv) {
PROTECT(
auto outputs__ = torch::svd(*self, (bool)some, (bool)compute_uv);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_svd_out(tensor *out__, tensor U, tensor S, tensor V, tensor self, int some, int compute_uv) {
PROTECT(
auto outputs__ = torch::svd_out(*U, *S, *V, *self, (bool)some, (bool)compute_uv);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
out__[2] = new torch::Tensor(std::get<2>(outputs__));
)
}
void atg_symeig(tensor *out__, tensor self, int eigenvectors, int upper) {
PROTECT(
auto outputs__ = torch::symeig(*self, (bool)eigenvectors, (bool)upper);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_symeig_out(tensor *out__, tensor e, tensor V, tensor self, int eigenvectors, int upper) {
PROTECT(
auto outputs__ = torch::symeig_out(*e, *V, *self, (bool)eigenvectors, (bool)upper);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_t(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::t(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_t_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->t_();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_take(tensor *out__, tensor self, tensor index) {
PROTECT(
auto outputs__ = torch::take(*self, *index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_take_out(tensor *out__, tensor result, tensor self, tensor index) {
PROTECT(
auto outputs__ = torch::take_out(*result, *self, *index);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tan(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::tan(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tan_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::tan_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tan_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::tan_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tanh(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::tanh(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tanh_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::tanh_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tanh_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::tanh_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tensordot(tensor *out__, tensor self, tensor other, int64_t *dims_self_data, int dims_self_len, int64_t *dims_other_data, int dims_other_len) {
PROTECT(
auto outputs__ = torch::tensordot(*self, *other, torch::IntList(dims_self_data, dims_self_len), torch::IntList(dims_other_data, dims_other_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_threshold(tensor *out__, tensor self, scalar threshold, scalar value) {
PROTECT(
auto outputs__ = torch::threshold(*self, *threshold, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_threshold_(tensor *out__, tensor self, scalar threshold, scalar value) {
PROTECT(
auto outputs__ = torch::threshold_(*self, *threshold, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_threshold_backward(tensor *out__, tensor grad_output, tensor self, scalar threshold) {
PROTECT(
auto outputs__ = torch::threshold_backward(*grad_output, *self, *threshold);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_threshold_out(tensor *out__, tensor result, tensor self, scalar threshold, scalar value) {
PROTECT(
auto outputs__ = torch::threshold_out(*result, *self, *threshold, *value);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_to(tensor *out__, tensor self, int device) {
PROTECT(
auto outputs__ = self->to(torch::Device(torch::DeviceType(device)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_to1(tensor *out__, tensor self, int options_kind, int options_device, int non_blocking, int copy) {
PROTECT(
auto outputs__ = self->to(at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)), (bool)non_blocking, (bool)copy);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_to2(tensor *out__, tensor self, int dtype, int non_blocking, int copy) {
PROTECT(
auto outputs__ = self->to(torch::ScalarType(dtype), (bool)non_blocking, (bool)copy);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_to3(tensor *out__, tensor self, tensor other, int non_blocking, int copy) {
PROTECT(
auto outputs__ = self->to(*other, (bool)non_blocking, (bool)copy);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_to4(tensor *out__, tensor self, int device, int dtype, int non_blocking, int copy) {
PROTECT(
auto outputs__ = self->to(torch::Device(torch::DeviceType(device)), torch::ScalarType(dtype), (bool)non_blocking, (bool)copy);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_to_dense(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->to_dense();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_to_sparse(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->to_sparse();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_to_sparse1(tensor *out__, tensor self, int64_t sparse_dim) {
PROTECT(
auto outputs__ = self->to_sparse(sparse_dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_topk(tensor *out__, tensor self, int64_t k, int64_t dim, int largest, int sorted) {
PROTECT(
auto outputs__ = torch::topk(*self, k, dim, (bool)largest, (bool)sorted);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_topk_out(tensor *out__, tensor values, tensor indices, tensor self, int64_t k, int64_t dim, int largest, int sorted) {
PROTECT(
auto outputs__ = torch::topk_out(*values, *indices, *self, k, dim, (bool)largest, (bool)sorted);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_totype(tensor *out__, tensor self, int scalar_type) {
PROTECT(
auto outputs__ = self->toType(torch::ScalarType(scalar_type));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_trace(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::trace(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_transpose(tensor *out__, tensor self, int64_t dim0, int64_t dim1) {
PROTECT(
auto outputs__ = torch::transpose(*self, dim0, dim1);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_transpose_(tensor *out__, tensor self, int64_t dim0, int64_t dim1) {
PROTECT(
auto outputs__ = self->transpose_(dim0, dim1);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tril(tensor *out__, tensor self, int64_t diagonal) {
PROTECT(
auto outputs__ = torch::tril(*self, diagonal);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tril_(tensor *out__, tensor self, int64_t diagonal) {
PROTECT(
auto outputs__ = self->tril_(diagonal);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_tril_out(tensor *out__, tensor result, tensor self, int64_t diagonal) {
PROTECT(
auto outputs__ = torch::tril_out(*result, *self, diagonal);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_triplet_margin_loss(tensor *out__, tensor anchor, tensor positive, tensor negative, double margin, double p, double eps, int swap, int64_t reduction) {
PROTECT(
auto outputs__ = torch::triplet_margin_loss(*anchor, *positive, *negative, margin, p, eps, (bool)swap, reduction);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_triu(tensor *out__, tensor self, int64_t diagonal) {
PROTECT(
auto outputs__ = torch::triu(*self, diagonal);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_triu_(tensor *out__, tensor self, int64_t diagonal) {
PROTECT(
auto outputs__ = self->triu_(diagonal);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_triu_out(tensor *out__, tensor result, tensor self, int64_t diagonal) {
PROTECT(
auto outputs__ = torch::triu_out(*result, *self, diagonal);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_trtrs(tensor *out__, tensor self, tensor A, int upper, int transpose, int unitriangular) {
PROTECT(
auto outputs__ = torch::trtrs(*self, *A, (bool)upper, (bool)transpose, (bool)unitriangular);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_trtrs_out(tensor *out__, tensor X, tensor M, tensor self, tensor A, int upper, int transpose, int unitriangular) {
PROTECT(
auto outputs__ = torch::trtrs_out(*X, *M, *self, *A, (bool)upper, (bool)transpose, (bool)unitriangular);
out__[0] = new torch::Tensor(std::get<0>(outputs__));
out__[1] = new torch::Tensor(std::get<1>(outputs__));
)
}
void atg_trunc(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::trunc(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_trunc_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::trunc_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_trunc_out(tensor *out__, tensor result, tensor self) {
PROTECT(
auto outputs__ = torch::trunc_out(*result, *self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_type_as(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->type_as(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_unfold(tensor *out__, tensor self, int64_t dimension, int64_t size, int64_t step) {
PROTECT(
auto outputs__ = self->unfold(dimension, size, step);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_uniform_(tensor *out__, tensor self, double from, double to) {
PROTECT(
auto outputs__ = self->uniform_(from, to);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_unsqueeze(tensor *out__, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = torch::unsqueeze(*self, dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_unsqueeze_(tensor *out__, tensor self, int64_t dim) {
PROTECT(
auto outputs__ = self->unsqueeze_(dim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_bilinear2d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_bilinear2d(*self, torch::IntList(output_size_data, output_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_bilinear2d_backward(tensor *out__, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_bilinear2d_backward(*grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_bilinear2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_bilinear2d_backward_out(*grad_input, *grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_bilinear2d_out(tensor *out__, tensor output, tensor self, int64_t *output_size_data, int output_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_bilinear2d_out(*output, *self, torch::IntList(output_size_data, output_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_linear1d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_linear1d(*self, torch::IntList(output_size_data, output_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_linear1d_backward(tensor *out__, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_linear1d_backward(*grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_linear1d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_linear1d_backward_out(*grad_input, *grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_linear1d_out(tensor *out__, tensor output, tensor self, int64_t *output_size_data, int output_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_linear1d_out(*output, *self, torch::IntList(output_size_data, output_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest1d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest1d(*self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest1d_backward(tensor *out__, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest1d_backward(*grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest1d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest1d_backward_out(*grad_input, *grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest1d_out(tensor *out__, tensor output, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest1d_out(*output, *self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest2d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest2d(*self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest2d_backward(tensor *out__, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest2d_backward(*grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest2d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest2d_backward_out(*grad_input, *grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest2d_out(tensor *out__, tensor output, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest2d_out(*output, *self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest3d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest3d(*self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest3d_backward(tensor *out__, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest3d_backward(*grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest3d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest3d_backward_out(*grad_input, *grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_nearest3d_out(tensor *out__, tensor output, tensor self, int64_t *output_size_data, int output_size_len) {
PROTECT(
auto outputs__ = torch::upsample_nearest3d_out(*output, *self, torch::IntList(output_size_data, output_size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_trilinear3d(tensor *out__, tensor self, int64_t *output_size_data, int output_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_trilinear3d(*self, torch::IntList(output_size_data, output_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_trilinear3d_backward(tensor *out__, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_trilinear3d_backward(*grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_trilinear3d_backward_out(tensor *out__, tensor grad_input, tensor grad_output, int64_t *output_size_data, int output_size_len, int64_t *input_size_data, int input_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_trilinear3d_backward_out(*grad_input, *grad_output, torch::IntList(output_size_data, output_size_len), torch::IntList(input_size_data, input_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_upsample_trilinear3d_out(tensor *out__, tensor output, tensor self, int64_t *output_size_data, int output_size_len, int align_corners) {
PROTECT(
auto outputs__ = torch::upsample_trilinear3d_out(*output, *self, torch::IntList(output_size_data, output_size_len), (bool)align_corners);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_values(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = self->values();
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_var(tensor *out__, tensor self, int unbiased) {
PROTECT(
auto outputs__ = torch::var(*self, (bool)unbiased);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_var1(tensor *out__, tensor self, int64_t dim, int unbiased, int keepdim) {
PROTECT(
auto outputs__ = torch::var(*self, dim, (bool)unbiased, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_var_out(tensor *out__, tensor result, tensor self, int64_t dim, int unbiased, int keepdim) {
PROTECT(
auto outputs__ = torch::var_out(*result, *self, dim, (bool)unbiased, (bool)keepdim);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_view(tensor *out__, tensor self, int64_t *size_data, int size_len) {
PROTECT(
auto outputs__ = self->view(torch::IntList(size_data, size_len));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_view_as(tensor *out__, tensor self, tensor other) {
PROTECT(
auto outputs__ = self->view_as(*other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_where(tensor *out__, tensor condition, tensor self, tensor other) {
PROTECT(
auto outputs__ = torch::where(*condition, *self, *other);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_zero_(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::zero_(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_zeros(tensor *out__, int64_t *size_data, int size_len, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::zeros(torch::IntList(size_data, size_len), at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_zeros_like(tensor *out__, tensor self) {
PROTECT(
auto outputs__ = torch::zeros_like(*self);
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_zeros_like1(tensor *out__, tensor self, int options_kind, int options_device) {
PROTECT(
auto outputs__ = torch::zeros_like(*self, at::device(at::DeviceType(options_device)).dtype(at::ScalarType(options_kind)));
out__[0] = new torch::Tensor(outputs__);
)
}
void atg_zeros_out(tensor *out__, tensor result, int64_t *size_data, int size_len) {
PROTECT(
auto outputs__ = torch::zeros_out(*result, torch::IntList(size_data, size_len));
out__[0] = new torch::Tensor(outputs__);
)
}