R/gen-namespace.R

In torch: Tensors and Neural Networks with 'GPU' Acceleration

# This file is autogenerated. Do not modify it by hand.

#' @rdname torch___and__
torch___and__ <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '__and__',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch___lshift__
torch___lshift__ <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '__lshift__',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch___lshift___out
torch___lshift___out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '__lshift___out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch___or__
torch___or__ <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '__or__',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch___rshift__
torch___rshift__ <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '__rshift__',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch___rshift___out
torch___rshift___out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '__rshift___out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch___xor__
torch___xor__ <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '__xor__',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__adaptive_avg_pool2d
torch__adaptive_avg_pool2d <- function(self, output_size) {
  args <- mget(x = c("self", "output_size"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_adaptive_avg_pool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__adaptive_avg_pool2d_backward
torch__adaptive_avg_pool2d_backward <- function(grad_output, self) {
  args <- mget(x = c("grad_output", "self"))
expected_types <- list(grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_adaptive_avg_pool2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__adaptive_avg_pool2d_backward_out
torch__adaptive_avg_pool2d_backward_out <- function(out, grad_output, self) {
  args <- mget(x = c("out", "grad_output", "self"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", self = "Tensor")
nd_args <- c("out", "grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_adaptive_avg_pool2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__adaptive_avg_pool2d_out
torch__adaptive_avg_pool2d_out <- function(out, self, output_size) {
  args <- mget(x = c("out", "self", "output_size"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_adaptive_avg_pool2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__adaptive_avg_pool3d
torch__adaptive_avg_pool3d <- function(self, output_size) {
  args <- mget(x = c("self", "output_size"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_adaptive_avg_pool3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__adaptive_avg_pool3d_backward
torch__adaptive_avg_pool3d_backward <- function(grad_output, self) {
  args <- mget(x = c("grad_output", "self"))
expected_types <- list(grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_adaptive_avg_pool3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__adaptive_avg_pool3d_backward_out
torch__adaptive_avg_pool3d_backward_out <- function(out, grad_output, self) {
  args <- mget(x = c("out", "grad_output", "self"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", self = "Tensor")
nd_args <- c("out", "grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_adaptive_avg_pool3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__adaptive_avg_pool3d_out
torch__adaptive_avg_pool3d_out <- function(out, self, output_size) {
  args <- mget(x = c("out", "self", "output_size"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_adaptive_avg_pool3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__add_batch_dim
torch__add_batch_dim <- function(self, batch_dim, level) {
  args <- mget(x = c("self", "batch_dim", "level"))
expected_types <- list(self = "Tensor", batch_dim = "int64_t", level = "int64_t")
nd_args <- c("self", "batch_dim", "level")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_add_batch_dim',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__add_relu
torch__add_relu <- function(self, other, alpha = 1L) {
  args <- mget(x = c("self", "other", "alpha"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"), alpha = "Scalar")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_add_relu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__add_relu_
torch__add_relu_ <- function(self, other, alpha = 1L) {
  args <- mget(x = c("self", "other", "alpha"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"), alpha = "Scalar")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_add_relu_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__add_relu_out
torch__add_relu_out <- function(out, self, other, alpha = 1L) {
  args <- mget(x = c("out", "self", "other", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Tensor", "Scalar"
), alpha = "Scalar")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_add_relu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__addmm_activation
torch__addmm_activation <- function(self, mat1, mat2, beta = 1L, alpha = 1L, use_gelu = FALSE) {
  args <- mget(x = c("self", "mat1", "mat2", "beta", "alpha", "use_gelu"))
expected_types <- list(self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", beta = "Scalar", 
    alpha = "Scalar", use_gelu = "bool")
nd_args <- c("self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_addmm_activation',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__addmm_activation_out
torch__addmm_activation_out <- function(out, self, mat1, mat2, beta = 1L, alpha = 1L, use_gelu = FALSE) {
  args <- mget(x = c("out", "self", "mat1", "mat2", "beta", "alpha", "use_gelu"))
expected_types <- list(out = "Tensor", self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", 
    beta = "Scalar", alpha = "Scalar", use_gelu = "bool")
nd_args <- c("out", "self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_addmm_activation_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__aminmax
torch__aminmax <- function(self, dim, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = "int64_t", keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_aminmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__aminmax_out
torch__aminmax_out <- function(out0, out1, self, dim, keepdim = FALSE) {
  args <- mget(x = c("out0", "out1", "self", "dim", "keepdim"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", self = "Tensor", dim = "int64_t", 
    keepdim = "bool")
nd_args <- c("out0", "out1", "self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_aminmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__amp_foreach_non_finite_check_and_unscale
torch__amp_foreach_non_finite_check_and_unscale <- function(self, found_inf, inv_scale) {
  args <- mget(x = c("self", "found_inf", "inv_scale"))
expected_types <- list(self = "TensorList", found_inf = "Tensor", inv_scale = "Tensor")
nd_args <- c("self", "found_inf", "inv_scale")
return_types <- list(list("TensorList", "Tensor"))
call_c_function(
fun_name = '_amp_foreach_non_finite_check_and_unscale',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__amp_foreach_non_finite_check_and_unscale_
torch__amp_foreach_non_finite_check_and_unscale_ <- function(self, found_inf, inv_scale) {
  args <- mget(x = c("self", "found_inf", "inv_scale"))
expected_types <- list(self = "TensorList", found_inf = "Tensor", inv_scale = "Tensor")
nd_args <- c("self", "found_inf", "inv_scale")
return_types <- list(list("void"))
call_c_function(
fun_name = '_amp_foreach_non_finite_check_and_unscale_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__amp_foreach_non_finite_check_and_unscale_out
torch__amp_foreach_non_finite_check_and_unscale_out <- function(out, self, found_inf, inv_scale) {
  args <- mget(x = c("out", "self", "found_inf", "inv_scale"))
expected_types <- list(out = "TensorList", self = "TensorList", found_inf = "Tensor", 
    inv_scale = "Tensor")
nd_args <- c("out", "self", "found_inf", "inv_scale")
return_types <- list(list("void"))
call_c_function(
fun_name = '_amp_foreach_non_finite_check_and_unscale_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__amp_update_scale
torch__amp_update_scale <- function(self, growth_tracker, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval) {
  args <- mget(x = c("self", "growth_tracker", "found_inf", "scale_growth_factor", "scale_backoff_factor", "growth_interval"))
expected_types <- list(self = "Tensor", growth_tracker = "Tensor", found_inf = "Tensor", 
    scale_growth_factor = "double", scale_backoff_factor = "double", 
    growth_interval = "int64_t")
nd_args <- c("self", "growth_tracker", "found_inf", "scale_growth_factor", 
"scale_backoff_factor", "growth_interval")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_amp_update_scale',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__amp_update_scale_
torch__amp_update_scale_ <- function(self, growth_tracker, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval) {
  args <- mget(x = c("self", "growth_tracker", "found_inf", "scale_growth_factor", "scale_backoff_factor", "growth_interval"))
expected_types <- list(self = "Tensor", growth_tracker = "Tensor", found_inf = "Tensor", 
    scale_growth_factor = "double", scale_backoff_factor = "double", 
    growth_interval = "int64_t")
nd_args <- c("self", "growth_tracker", "found_inf", "scale_growth_factor", 
"scale_backoff_factor", "growth_interval")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_amp_update_scale_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__amp_update_scale_out
torch__amp_update_scale_out <- function(out, self, growth_tracker, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval) {
  args <- mget(x = c("out", "self", "growth_tracker", "found_inf", "scale_growth_factor", "scale_backoff_factor", "growth_interval"))
expected_types <- list(out = "Tensor", self = "Tensor", growth_tracker = "Tensor", 
    found_inf = "Tensor", scale_growth_factor = "double", scale_backoff_factor = "double", 
    growth_interval = "int64_t")
nd_args <- c("out", "self", "growth_tracker", "found_inf", "scale_growth_factor", 
"scale_backoff_factor", "growth_interval")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_amp_update_scale_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__assert_async
torch__assert_async <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_assert_async',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__assert_tensor_metadata
torch__assert_tensor_metadata <- function(a, size = NULL, stride = NULL, dtype = NULL) {
  args <- mget(x = c("a", "size", "stride", "dtype"))
expected_types <- list(a = "Tensor", size = "IntArrayRef", stride = "IntArrayRef", 
    dtype = "ScalarType")
nd_args <- "a"
return_types <- list(list("void"))
call_c_function(
fun_name = '_assert_tensor_metadata',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__batch_norm_impl_index
torch__batch_norm_impl_index <- function(input, weight, bias, running_mean, running_var, training, momentum, eps, cudnn_enabled) {
  args <- mget(x = c("input", "weight", "bias", "running_mean", "running_var", "training", "momentum", "eps", "cudnn_enabled"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", momentum = "double", 
    eps = "double", cudnn_enabled = "bool")
nd_args <- c("input", "weight", "bias", "running_mean", "running_var", "training", 
"momentum", "eps", "cudnn_enabled")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "int64_t"))
call_c_function(
fun_name = '_batch_norm_impl_index',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__batch_norm_impl_index_backward
torch__batch_norm_impl_index_backward <- function(impl_index, input, grad_output, weight, running_mean, running_var, save_mean, save_var_transform, train, eps, output_mask, reservedSpace) {
  args <- mget(x = c("impl_index", "input", "grad_output", "weight", "running_mean", "running_var", "save_mean", "save_var_transform", "train", "eps", "output_mask", "reservedSpace"))
expected_types <- list(impl_index = "int64_t", input = "Tensor", grad_output = "Tensor", 
    weight = "Tensor", running_mean = "Tensor", running_var = "Tensor", 
    save_mean = "Tensor", save_var_transform = "Tensor", train = "bool", 
    eps = "double", output_mask = "::std::array<bool,3>", reservedSpace = "Tensor")
nd_args <- c("impl_index", "input", "grad_output", "weight", "running_mean", 
"running_var", "save_mean", "save_var_transform", "train", "eps", 
"output_mask", "reservedSpace")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_batch_norm_impl_index_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cast_Byte
torch__cast_Byte <- function(self, non_blocking = FALSE) {
  args <- mget(x = c("self", "non_blocking"))
expected_types <- list(self = "Tensor", non_blocking = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cast_Byte',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cast_Char
torch__cast_Char <- function(self, non_blocking = FALSE) {
  args <- mget(x = c("self", "non_blocking"))
expected_types <- list(self = "Tensor", non_blocking = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cast_Char',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cast_Double
torch__cast_Double <- function(self, non_blocking = FALSE) {
  args <- mget(x = c("self", "non_blocking"))
expected_types <- list(self = "Tensor", non_blocking = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cast_Double',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cast_Float
torch__cast_Float <- function(self, non_blocking = FALSE) {
  args <- mget(x = c("self", "non_blocking"))
expected_types <- list(self = "Tensor", non_blocking = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cast_Float',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cast_Half
torch__cast_Half <- function(self, non_blocking = FALSE) {
  args <- mget(x = c("self", "non_blocking"))
expected_types <- list(self = "Tensor", non_blocking = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cast_Half',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cast_Int
torch__cast_Int <- function(self, non_blocking = FALSE) {
  args <- mget(x = c("self", "non_blocking"))
expected_types <- list(self = "Tensor", non_blocking = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cast_Int',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cast_Long
torch__cast_Long <- function(self, non_blocking = FALSE) {
  args <- mget(x = c("self", "non_blocking"))
expected_types <- list(self = "Tensor", non_blocking = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cast_Long',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cast_Short
torch__cast_Short <- function(self, non_blocking = FALSE) {
  args <- mget(x = c("self", "non_blocking"))
expected_types <- list(self = "Tensor", non_blocking = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cast_Short',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cdist_backward
torch__cdist_backward <- function(grad, x1, x2, p, cdist) {
  args <- mget(x = c("grad", "x1", "x2", "p", "cdist"))
expected_types <- list(grad = "Tensor", x1 = "Tensor", x2 = "Tensor", p = "double", 
    cdist = "Tensor")
nd_args <- c("grad", "x1", "x2", "p", "cdist")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cdist_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cdist_backward_out
torch__cdist_backward_out <- function(out, grad, x1, x2, p, cdist) {
  args <- mget(x = c("out", "grad", "x1", "x2", "p", "cdist"))
expected_types <- list(out = "Tensor", grad = "Tensor", x1 = "Tensor", x2 = "Tensor", 
    p = "double", cdist = "Tensor")
nd_args <- c("out", "grad", "x1", "x2", "p", "cdist")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cdist_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cdist_forward
torch__cdist_forward <- function(x1, x2, p, compute_mode) {
  args <- mget(x = c("x1", "x2", "p", "compute_mode"))
expected_types <- list(x1 = "Tensor", x2 = "Tensor", p = "double", compute_mode = "int64_t")
nd_args <- c("x1", "x2", "p", "compute_mode")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cdist_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cdist_forward_out
torch__cdist_forward_out <- function(out, x1, x2, p, compute_mode) {
  args <- mget(x = c("out", "x1", "x2", "p", "compute_mode"))
expected_types <- list(out = "Tensor", x1 = "Tensor", x2 = "Tensor", p = "double", 
    compute_mode = "int64_t")
nd_args <- c("out", "x1", "x2", "p", "compute_mode")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cdist_forward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cholesky_solve_helper
torch__cholesky_solve_helper <- function(self, A, upper) {
  args <- mget(x = c("self", "A", "upper"))
expected_types <- list(self = "Tensor", A = "Tensor", upper = "bool")
nd_args <- c("self", "A", "upper")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cholesky_solve_helper',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cholesky_solve_helper_out
torch__cholesky_solve_helper_out <- function(out, self, A, upper) {
  args <- mget(x = c("out", "self", "A", "upper"))
expected_types <- list(out = "Tensor", self = "Tensor", A = "Tensor", upper = "bool")
nd_args <- c("out", "self", "A", "upper")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cholesky_solve_helper_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__choose_qparams_per_tensor
torch__choose_qparams_per_tensor <- function(self, reduce_range = FALSE) {
  args <- mget(x = c("self", "reduce_range"))
expected_types <- list(self = "Tensor", reduce_range = "bool")
nd_args <- "self"
return_types <- list(list("double", "int64_t"))
call_c_function(
fun_name = '_choose_qparams_per_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__chunk_grad_outputs_efficient_attention
torch__chunk_grad_outputs_efficient_attention <- function(query, key, value, is_causal = FALSE) {
  args <- mget(x = c("query", "key", "value", "is_causal"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", is_causal = "bool")
nd_args <- c("query", "key", "value")
return_types <- list(list('bool'))
call_c_function(
fun_name = '_chunk_grad_outputs_efficient_attention',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__coalesce
torch__coalesce <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_coalesce',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__coalesce_out
torch__coalesce_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_coalesce_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__coalesced
torch__coalesced <- function(self, coalesced) {
  args <- mget(x = c("self", "coalesced"))
expected_types <- list(self = "Tensor", coalesced = "bool")
nd_args <- c("self", "coalesced")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_coalesced',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__coalesced_out
torch__coalesced_out <- function(out, self, coalesced) {
  args <- mget(x = c("out", "self", "coalesced"))
expected_types <- list(out = "Tensor", self = "Tensor", coalesced = "bool")
nd_args <- c("out", "self", "coalesced")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_coalesced_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__compute_linear_combination
torch__compute_linear_combination <- function(input, coefficients) {
  args <- mget(x = c("input", "coefficients"))
expected_types <- list(input = "Tensor", coefficients = "Tensor")
nd_args <- c("input", "coefficients")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_compute_linear_combination',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__compute_linear_combination_out
torch__compute_linear_combination_out <- function(out, input, coefficients) {
  args <- mget(x = c("out", "input", "coefficients"))
expected_types <- list(out = "Tensor", input = "Tensor", coefficients = "Tensor")
nd_args <- c("out", "input", "coefficients")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_compute_linear_combination_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__conj
torch__conj <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_conj',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__conj_copy
torch__conj_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_conj_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__conj_copy_out
torch__conj_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_conj_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__conj_physical
torch__conj_physical <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_conj_physical',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__conj_physical_out
torch__conj_physical_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_conj_physical_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__conv_depthwise2d
torch__conv_depthwise2d <- function(self, weight, kernel_size, bias, stride, padding, dilation) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding", "dilation"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size", "bias", "stride", "padding", 
"dilation")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_conv_depthwise2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__conv_depthwise2d_out
torch__conv_depthwise2d_out <- function(out, self, weight, kernel_size, bias, stride, padding, dilation) {
  args <- mget(x = c("out", "self", "weight", "kernel_size", "bias", "stride", "padding", "dilation"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef")
nd_args <- c("out", "self", "weight", "kernel_size", "bias", "stride", "padding", 
"dilation")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_conv_depthwise2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__convert_indices_from_coo_to_csr
torch__convert_indices_from_coo_to_csr <- function(self, size, out_int32 = FALSE) {
  args <- mget(x = c("self", "size", "out_int32"))
expected_types <- list(self = "Tensor", size = "int64_t", out_int32 = "bool")
nd_args <- c("self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_convert_indices_from_coo_to_csr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__convert_indices_from_coo_to_csr_out
torch__convert_indices_from_coo_to_csr_out <- function(out, self, size, out_int32 = FALSE) {
  args <- mget(x = c("out", "self", "size", "out_int32"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "int64_t", out_int32 = "bool")
nd_args <- c("out", "self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_convert_indices_from_coo_to_csr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__convert_indices_from_csr_to_coo
torch__convert_indices_from_csr_to_coo <- function(crow_indices, col_indices, out_int32 = FALSE, transpose = FALSE) {
  args <- mget(x = c("crow_indices", "col_indices", "out_int32", "transpose"))
expected_types <- list(crow_indices = "Tensor", col_indices = "Tensor", out_int32 = "bool", 
    transpose = "bool")
nd_args <- c("crow_indices", "col_indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_convert_indices_from_csr_to_coo',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__convert_indices_from_csr_to_coo_out
torch__convert_indices_from_csr_to_coo_out <- function(out, crow_indices, col_indices, out_int32 = FALSE, transpose = FALSE) {
  args <- mget(x = c("out", "crow_indices", "col_indices", "out_int32", "transpose"))
expected_types <- list(out = "Tensor", crow_indices = "Tensor", col_indices = "Tensor", 
    out_int32 = "bool", transpose = "bool")
nd_args <- c("out", "crow_indices", "col_indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_convert_indices_from_csr_to_coo_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__convolution
torch__convolution <- function(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, allow_tf32) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "dilation", "transposed", "output_padding", "groups", "benchmark", "deterministic", "cudnn_enabled", "allow_tf32"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", transposed = "bool", 
    output_padding = "IntArrayRef", groups = "int64_t", benchmark = "bool", 
    deterministic = "bool", cudnn_enabled = "bool", allow_tf32 = "bool")
nd_args <- c("input", "weight", "bias", "stride", "padding", "dilation", 
"transposed", "output_padding", "groups", "benchmark", "deterministic", 
"cudnn_enabled", "allow_tf32")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_convolution',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__convolution_double_backward
torch__convolution_double_backward <- function(ggI, ggW, ggb, gO, weight, self, stride, padding, dilation, transposed, output_padding, groups, output_mask) {
  args <- mget(x = c("ggI", "ggW", "ggb", "gO", "weight", "self", "stride", "padding", "dilation", "transposed", "output_padding", "groups", "output_mask"))
expected_types <- list(ggI = "Tensor", ggW = "Tensor", ggb = "Tensor", gO = "Tensor", 
    weight = "Tensor", self = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", transposed = "bool", 
    output_padding = "IntArrayRef", groups = "int64_t", output_mask = "::std::array<bool,3>")
nd_args <- c("ggI", "ggW", "ggb", "gO", "weight", "self", "stride", "padding", 
"dilation", "transposed", "output_padding", "groups", "output_mask"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_convolution_double_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__convolution_mode
torch__convolution_mode <- function(input, weight, bias, stride, padding, dilation, groups) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = "c10::string_view", dilation = "IntArrayRef", groups = "int64_t")
nd_args <- c("input", "weight", "bias", "stride", "padding", "dilation", 
"groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_convolution_mode',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__convolution_out
torch__convolution_out <- function(out, input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, allow_tf32) {
  args <- mget(x = c("out", "input", "weight", "bias", "stride", "padding", "dilation", "transposed", "output_padding", "groups", "benchmark", "deterministic", "cudnn_enabled", "allow_tf32"))
expected_types <- list(out = "Tensor", input = "Tensor", weight = "Tensor", bias = "Tensor", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    transposed = "bool", output_padding = "IntArrayRef", groups = "int64_t", 
    benchmark = "bool", deterministic = "bool", cudnn_enabled = "bool", 
    allow_tf32 = "bool")
nd_args <- c("out", "input", "weight", "bias", "stride", "padding", "dilation", 
"transposed", "output_padding", "groups", "benchmark", "deterministic", 
"cudnn_enabled", "allow_tf32")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_convolution_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__copy_from
torch__copy_from <- function(self, dst, non_blocking = FALSE) {
  args <- mget(x = c("self", "dst", "non_blocking"))
expected_types <- list(self = "Tensor", dst = "Tensor", non_blocking = "bool")
nd_args <- c("self", "dst")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_copy_from',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__copy_from_and_resize
torch__copy_from_and_resize <- function(self, dst) {
  args <- mget(x = c("self", "dst"))
expected_types <- list(self = "Tensor", dst = "Tensor")
nd_args <- c("self", "dst")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_copy_from_and_resize',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__copy_from_and_resize_out
torch__copy_from_and_resize_out <- function(out, self, dst) {
  args <- mget(x = c("out", "self", "dst"))
expected_types <- list(out = "Tensor", self = "Tensor", dst = "Tensor")
nd_args <- c("out", "self", "dst")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_copy_from_and_resize_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__copy_from_out
torch__copy_from_out <- function(out, self, dst, non_blocking = FALSE) {
  args <- mget(x = c("out", "self", "dst", "non_blocking"))
expected_types <- list(out = "Tensor", self = "Tensor", dst = "Tensor", non_blocking = "bool")
nd_args <- c("out", "self", "dst")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_copy_from_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__ctc_loss
torch__ctc_loss <- function(log_probs, targets, input_lengths, target_lengths, blank = 0L, zero_infinity = FALSE) {
  args <- mget(x = c("log_probs", "targets", "input_lengths", "target_lengths", "blank", "zero_infinity"))
expected_types <- list(log_probs = "Tensor", targets = "Tensor", input_lengths = c("IntArrayRef", 
"Tensor"), target_lengths = c("IntArrayRef", "Tensor"), blank = "int64_t", 
    zero_infinity = "bool")
nd_args <- c("log_probs", "targets", "input_lengths", "target_lengths")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_ctc_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__ctc_loss_backward
torch__ctc_loss_backward <- function(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, blank, zero_infinity = FALSE) {
  args <- mget(x = c("grad", "log_probs", "targets", "input_lengths", "target_lengths", "neg_log_likelihood", "log_alpha", "blank", "zero_infinity"))
expected_types <- list(grad = "Tensor", log_probs = "Tensor", targets = "Tensor", 
    input_lengths = c("IntArrayRef", "Tensor"), target_lengths = c("IntArrayRef", 
    "Tensor"), neg_log_likelihood = "Tensor", log_alpha = "Tensor", 
    blank = "int64_t", zero_infinity = "bool")
nd_args <- c("grad", "log_probs", "targets", "input_lengths", "target_lengths", 
"neg_log_likelihood", "log_alpha", "blank")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_ctc_loss_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__ctc_loss_backward_out
torch__ctc_loss_backward_out <- function(out, grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, blank, zero_infinity = FALSE) {
  args <- mget(x = c("out", "grad", "log_probs", "targets", "input_lengths", "target_lengths", "neg_log_likelihood", "log_alpha", "blank", "zero_infinity"))
expected_types <- list(out = "Tensor", grad = "Tensor", log_probs = "Tensor", targets = "Tensor", 
    input_lengths = "IntArrayRef", target_lengths = "IntArrayRef", 
    neg_log_likelihood = "Tensor", log_alpha = "Tensor", blank = "int64_t", 
    zero_infinity = "bool")
nd_args <- c("out", "grad", "log_probs", "targets", "input_lengths", "target_lengths", 
"neg_log_likelihood", "log_alpha", "blank")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_ctc_loss_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__ctc_loss_out
torch__ctc_loss_out <- function(out0, out1, log_probs, targets, input_lengths, target_lengths, blank = 0L, zero_infinity = FALSE) {
  args <- mget(x = c("out0", "out1", "log_probs", "targets", "input_lengths", "target_lengths", "blank", "zero_infinity"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", log_probs = "Tensor", 
    targets = "Tensor", input_lengths = c("IntArrayRef", "Tensor"
    ), target_lengths = c("IntArrayRef", "Tensor"), blank = "int64_t", 
    zero_infinity = "bool")
nd_args <- c("out0", "out1", "log_probs", "targets", "input_lengths", "target_lengths"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_ctc_loss_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_ctc_loss
torch__cudnn_ctc_loss <- function(log_probs, targets, input_lengths, target_lengths, blank, deterministic, zero_infinity) {
  args <- mget(x = c("log_probs", "targets", "input_lengths", "target_lengths", "blank", "deterministic", "zero_infinity"))
expected_types <- list(log_probs = "Tensor", targets = "Tensor", input_lengths = c("IntArrayRef", 
"Tensor"), target_lengths = c("IntArrayRef", "Tensor"), blank = "int64_t", 
    deterministic = "bool", zero_infinity = "bool")
nd_args <- c("log_probs", "targets", "input_lengths", "target_lengths", 
"blank", "deterministic", "zero_infinity")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_cudnn_ctc_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_ctc_loss_out
torch__cudnn_ctc_loss_out <- function(out0, out1, log_probs, targets, input_lengths, target_lengths, blank, deterministic, zero_infinity) {
  args <- mget(x = c("out0", "out1", "log_probs", "targets", "input_lengths", "target_lengths", "blank", "deterministic", "zero_infinity"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", log_probs = "Tensor", 
    targets = "Tensor", input_lengths = "IntArrayRef", target_lengths = "IntArrayRef", 
    blank = "int64_t", deterministic = "bool", zero_infinity = "bool")
nd_args <- c("out0", "out1", "log_probs", "targets", "input_lengths", "target_lengths", 
"blank", "deterministic", "zero_infinity")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_cudnn_ctc_loss_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_init_dropout_state
torch__cudnn_init_dropout_state <- function(dropout, train, dropout_seed, options) {
  args <- mget(x = c("dropout", "train", "dropout_seed", "options"))
expected_types <- list(dropout = "double", train = "bool", dropout_seed = "int64_t", 
    options = "TensorOptions")
nd_args <- c("dropout", "train", "dropout_seed", "options")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cudnn_init_dropout_state',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_init_dropout_state_out
torch__cudnn_init_dropout_state_out <- function(out, dropout, train, dropout_seed) {
  args <- mget(x = c("out", "dropout", "train", "dropout_seed"))
expected_types <- list(out = "Tensor", dropout = "double", train = "bool", dropout_seed = "int64_t")
nd_args <- c("out", "dropout", "train", "dropout_seed")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cudnn_init_dropout_state_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_rnn
torch__cudnn_rnn <- function(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state) {
  args <- mget(x = c("input", "weight", "weight_stride0", "weight_buf", "hx", "cx", "mode", "hidden_size", "proj_size", "num_layers", "batch_first", "dropout", "train", "bidirectional", "batch_sizes", "dropout_state"))
expected_types <- list(input = "Tensor", weight = "TensorList", weight_stride0 = "int64_t", 
    weight_buf = "Tensor", hx = "Tensor", cx = "Tensor", mode = "int64_t", 
    hidden_size = "int64_t", proj_size = "int64_t", num_layers = "int64_t", 
    batch_first = "bool", dropout = "double", train = "bool", 
    bidirectional = "bool", batch_sizes = "IntArrayRef", dropout_state = "Tensor")
nd_args <- c("input", "weight", "weight_stride0", "weight_buf", "hx", "cx", 
"mode", "hidden_size", "proj_size", "num_layers", "batch_first", 
"dropout", "train", "bidirectional", "batch_sizes", "dropout_state"
)
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_cudnn_rnn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_rnn_backward
torch__cudnn_rnn_backward <- function(input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, reserve, output_mask) {
  args <- mget(x = c("input", "weight", "weight_stride0", "weight_buf", "hx", "cx", "output", "grad_output", "grad_hy", "grad_cy", "mode", "hidden_size", "proj_size", "num_layers", "batch_first", "dropout", "train", "bidirectional", "batch_sizes", "dropout_state", "reserve", "output_mask"))
expected_types <- list(input = "Tensor", weight = "TensorList", weight_stride0 = "int64_t", 
    weight_buf = "Tensor", hx = "Tensor", cx = "Tensor", output = "Tensor", 
    grad_output = "Tensor", grad_hy = "Tensor", grad_cy = "Tensor", 
    mode = "int64_t", hidden_size = "int64_t", proj_size = "int64_t", 
    num_layers = "int64_t", batch_first = "bool", dropout = "double", 
    train = "bool", bidirectional = "bool", batch_sizes = "IntArrayRef", 
    dropout_state = "Tensor", reserve = "Tensor", output_mask = "::std::array<bool,4>")
nd_args <- c("input", "weight", "weight_stride0", "weight_buf", "hx", "cx", 
"output", "grad_output", "grad_hy", "grad_cy", "mode", "hidden_size", 
"proj_size", "num_layers", "batch_first", "dropout", "train", 
"bidirectional", "batch_sizes", "dropout_state", "reserve", "output_mask"
)
return_types <- list(list("Tensor", "Tensor", "Tensor", "TensorList"))
call_c_function(
fun_name = '_cudnn_rnn_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_rnn_backward_out
torch__cudnn_rnn_backward_out <- function(out0, out1, out2, out3, input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, reserve, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "input", "weight", "weight_stride0", "weight_buf", "hx", "cx", "output", "grad_output", "grad_hy", "grad_cy", "mode", "hidden_size", "proj_size", "num_layers", "batch_first", "dropout", "train", "bidirectional", "batch_sizes", "dropout_state", "reserve", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "TensorList", 
    input = "Tensor", weight = "TensorList", weight_stride0 = "int64_t", 
    weight_buf = "Tensor", hx = "Tensor", cx = "Tensor", output = "Tensor", 
    grad_output = "Tensor", grad_hy = "Tensor", grad_cy = "Tensor", 
    mode = "int64_t", hidden_size = "int64_t", proj_size = "int64_t", 
    num_layers = "int64_t", batch_first = "bool", dropout = "double", 
    train = "bool", bidirectional = "bool", batch_sizes = "IntArrayRef", 
    dropout_state = "Tensor", reserve = "Tensor", output_mask = "::std::array<bool,4>")
nd_args <- c("out0", "out1", "out2", "out3", "input", "weight", "weight_stride0", 
"weight_buf", "hx", "cx", "output", "grad_output", "grad_hy", 
"grad_cy", "mode", "hidden_size", "proj_size", "num_layers", 
"batch_first", "dropout", "train", "bidirectional", "batch_sizes", 
"dropout_state", "reserve", "output_mask")
return_types <- list(list("void"))
call_c_function(
fun_name = '_cudnn_rnn_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_rnn_flatten_weight
torch__cudnn_rnn_flatten_weight <- function(weight_arr, weight_stride0, input_size, mode, hidden_size, proj_size, num_layers, batch_first, bidirectional) {
  args <- mget(x = c("weight_arr", "weight_stride0", "input_size", "mode", "hidden_size", "proj_size", "num_layers", "batch_first", "bidirectional"))
expected_types <- list(weight_arr = "TensorList", weight_stride0 = "int64_t", input_size = "int64_t", 
    mode = "int64_t", hidden_size = "int64_t", proj_size = "int64_t", 
    num_layers = "int64_t", batch_first = "bool", bidirectional = "bool")
nd_args <- c("weight_arr", "weight_stride0", "input_size", "mode", "hidden_size", 
"proj_size", "num_layers", "batch_first", "bidirectional")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cudnn_rnn_flatten_weight',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_rnn_flatten_weight_out
torch__cudnn_rnn_flatten_weight_out <- function(out, weight_arr, weight_stride0, input_size, mode, hidden_size, proj_size, num_layers, batch_first, bidirectional) {
  args <- mget(x = c("out", "weight_arr", "weight_stride0", "input_size", "mode", "hidden_size", "proj_size", "num_layers", "batch_first", "bidirectional"))
expected_types <- list(out = "Tensor", weight_arr = "TensorList", weight_stride0 = "int64_t", 
    input_size = "int64_t", mode = "int64_t", hidden_size = "int64_t", 
    proj_size = "int64_t", num_layers = "int64_t", batch_first = "bool", 
    bidirectional = "bool")
nd_args <- c("out", "weight_arr", "weight_stride0", "input_size", "mode", 
"hidden_size", "proj_size", "num_layers", "batch_first", "bidirectional"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_cudnn_rnn_flatten_weight_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cudnn_rnn_out
torch__cudnn_rnn_out <- function(out0, out1, out2, out3, out4, input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "out4", "input", "weight", "weight_stride0", "weight_buf", "hx", "cx", "mode", "hidden_size", "proj_size", "num_layers", "batch_first", "dropout", "train", "bidirectional", "batch_sizes", "dropout_state"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    out4 = "Tensor", input = "Tensor", weight = "TensorList", 
    weight_stride0 = "int64_t", weight_buf = "Tensor", hx = "Tensor", 
    cx = "Tensor", mode = "int64_t", hidden_size = "int64_t", 
    proj_size = "int64_t", num_layers = "int64_t", batch_first = "bool", 
    dropout = "double", train = "bool", bidirectional = "bool", 
    batch_sizes = "IntArrayRef", dropout_state = "Tensor")
nd_args <- c("out0", "out1", "out2", "out3", "out4", "input", "weight", 
"weight_stride0", "weight_buf", "hx", "cx", "mode", "hidden_size", 
"proj_size", "num_layers", "batch_first", "dropout", "train", 
"bidirectional", "batch_sizes", "dropout_state")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_cudnn_rnn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cufft_clear_plan_cache
torch__cufft_clear_plan_cache <- function(device_index) {
  args <- mget(x = c("device_index"))
expected_types <- list(device_index = "int64_t")
nd_args <- "device_index"
return_types <- list(list("void"))
call_c_function(
fun_name = '_cufft_clear_plan_cache',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cufft_get_plan_cache_max_size
torch__cufft_get_plan_cache_max_size <- function(device_index) {
  args <- mget(x = c("device_index"))
expected_types <- list(device_index = "int64_t")
nd_args <- "device_index"
return_types <- list(list('int64_t'))
call_c_function(
fun_name = '_cufft_get_plan_cache_max_size',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cufft_get_plan_cache_size
torch__cufft_get_plan_cache_size <- function(device_index) {
  args <- mget(x = c("device_index"))
expected_types <- list(device_index = "int64_t")
nd_args <- "device_index"
return_types <- list(list('int64_t'))
call_c_function(
fun_name = '_cufft_get_plan_cache_size',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cufft_set_plan_cache_max_size
torch__cufft_set_plan_cache_max_size <- function(device_index, max_size) {
  args <- mget(x = c("device_index", "max_size"))
expected_types <- list(device_index = "int64_t", max_size = "int64_t")
nd_args <- c("device_index", "max_size")
return_types <- list(list("void"))
call_c_function(
fun_name = '_cufft_set_plan_cache_max_size',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cummax_helper
torch__cummax_helper <- function(self, values, indices, dim) {
  args <- mget(x = c("self", "values", "indices", "dim"))
expected_types <- list(self = "Tensor", values = "Tensor", indices = "Tensor", 
    dim = "int64_t")
nd_args <- c("self", "values", "indices", "dim")
return_types <- list(list("void"))
call_c_function(
fun_name = '_cummax_helper',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__cummin_helper
torch__cummin_helper <- function(self, values, indices, dim) {
  args <- mget(x = c("self", "values", "indices", "dim"))
expected_types <- list(self = "Tensor", values = "Tensor", indices = "Tensor", 
    dim = "int64_t")
nd_args <- c("self", "values", "indices", "dim")
return_types <- list(list("void"))
call_c_function(
fun_name = '_cummin_helper',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__debug_has_internal_overlap
torch__debug_has_internal_overlap <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('int64_t'))
call_c_function(
fun_name = '_debug_has_internal_overlap',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__dim_arange
torch__dim_arange <- function(like, dim) {
  args <- mget(x = c("like", "dim"))
expected_types <- list(like = "Tensor", dim = "int64_t")
nd_args <- c("like", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_dim_arange',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__dirichlet_grad
torch__dirichlet_grad <- function(x, alpha, total) {
  args <- mget(x = c("x", "alpha", "total"))
expected_types <- list(x = "Tensor", alpha = "Tensor", total = "Tensor")
nd_args <- c("x", "alpha", "total")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_dirichlet_grad',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__dirichlet_grad_out
torch__dirichlet_grad_out <- function(out, x, alpha, total) {
  args <- mget(x = c("out", "x", "alpha", "total"))
expected_types <- list(out = "Tensor", x = "Tensor", alpha = "Tensor", total = "Tensor")
nd_args <- c("out", "x", "alpha", "total")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_dirichlet_grad_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__efficient_attention_backward
torch__efficient_attention_backward <- function(grad_out_, query, key, value, out, logsumexp, is_causal = FALSE, chunk_grad_outputs = FALSE) {
  args <- mget(x = c("grad_out_", "query", "key", "value", "out", "logsumexp", "is_causal", "chunk_grad_outputs"))
expected_types <- list(grad_out_ = "Tensor", query = "Tensor", key = "Tensor", 
    value = "Tensor", out = "Tensor", logsumexp = "Tensor", is_causal = "bool", 
    chunk_grad_outputs = "bool")
nd_args <- c("grad_out_", "query", "key", "value", "out", "logsumexp")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_efficient_attention_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__efficient_attention_forward
torch__efficient_attention_forward <- function(query, key, value, cu_seqlens_q, cu_seqlens_k, max_seqlen_q, compute_log_sumexp = FALSE, causal = FALSE) {
  args <- mget(x = c("query", "key", "value", "cu_seqlens_q", "cu_seqlens_k", "max_seqlen_q", "compute_log_sumexp", "causal"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", cu_seqlens_q = "Tensor", 
    cu_seqlens_k = "Tensor", max_seqlen_q = "int64_t", compute_log_sumexp = "bool", 
    causal = "bool")
nd_args <- c("query", "key", "value", "cu_seqlens_q", "cu_seqlens_k", "max_seqlen_q"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_efficient_attention_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__efficientzerotensor
torch__efficientzerotensor <- function(size, options = list()) {
  args <- mget(x = c("size", "options"))
expected_types <- list(size = "IntArrayRef", options = "TensorOptions")
nd_args <- "size"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_efficientzerotensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__efficientzerotensor_out
torch__efficientzerotensor_out <- function(out, size) {
  args <- mget(x = c("out", "size"))
expected_types <- list(out = "Tensor", size = "IntArrayRef")
nd_args <- c("out", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_efficientzerotensor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag
torch__embedding_bag <- function(weight, indices, offsets, scale_grad_by_freq = FALSE, mode = 0L, sparse = FALSE, per_sample_weights = list(), include_last_offset = FALSE, padding_idx = -1L) {
  args <- mget(x = c("weight", "indices", "offsets", "scale_grad_by_freq", "mode", "sparse", "per_sample_weights", "include_last_offset", "padding_idx"))
expected_types <- list(weight = "Tensor", indices = "Tensor", offsets = "Tensor", 
    scale_grad_by_freq = "bool", mode = "int64_t", sparse = "bool", 
    per_sample_weights = "Tensor", include_last_offset = "bool", 
    padding_idx = "int64_t")
nd_args <- c("weight", "indices", "offsets")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_embedding_bag',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag_backward
torch__embedding_bag_backward <- function(grad, indices, offsets, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, sparse, per_sample_weights, padding_idx = -1L) {
  args <- mget(x = c("grad", "indices", "offsets", "offset2bag", "bag_size", "maximum_indices", "num_weights", "scale_grad_by_freq", "mode", "sparse", "per_sample_weights", "padding_idx"))
expected_types <- list(grad = "Tensor", indices = "Tensor", offsets = "Tensor", 
    offset2bag = "Tensor", bag_size = "Tensor", maximum_indices = "Tensor", 
    num_weights = "int64_t", scale_grad_by_freq = "bool", mode = "int64_t", 
    sparse = "bool", per_sample_weights = "Tensor", padding_idx = "int64_t")
nd_args <- c("grad", "indices", "offsets", "offset2bag", "bag_size", "maximum_indices", 
"num_weights", "scale_grad_by_freq", "mode", "sparse", "per_sample_weights"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_embedding_bag_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag_dense_backward
torch__embedding_bag_dense_backward <- function(grad, indices, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, per_sample_weights, padding_idx = -1L) {
  args <- mget(x = c("grad", "indices", "offset2bag", "bag_size", "maximum_indices", "num_weights", "scale_grad_by_freq", "mode", "per_sample_weights", "padding_idx"))
expected_types <- list(grad = "Tensor", indices = "Tensor", offset2bag = "Tensor", 
    bag_size = "Tensor", maximum_indices = "Tensor", num_weights = "int64_t", 
    scale_grad_by_freq = "bool", mode = "int64_t", per_sample_weights = "Tensor", 
    padding_idx = "int64_t")
nd_args <- c("grad", "indices", "offset2bag", "bag_size", "maximum_indices", 
"num_weights", "scale_grad_by_freq", "mode", "per_sample_weights"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_embedding_bag_dense_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag_dense_backward_out
torch__embedding_bag_dense_backward_out <- function(out, grad, indices, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, per_sample_weights, padding_idx = -1L) {
  args <- mget(x = c("out", "grad", "indices", "offset2bag", "bag_size", "maximum_indices", "num_weights", "scale_grad_by_freq", "mode", "per_sample_weights", "padding_idx"))
expected_types <- list(out = "Tensor", grad = "Tensor", indices = "Tensor", offset2bag = "Tensor", 
    bag_size = "Tensor", maximum_indices = "Tensor", num_weights = "int64_t", 
    scale_grad_by_freq = "bool", mode = "int64_t", per_sample_weights = "Tensor", 
    padding_idx = "int64_t")
nd_args <- c("out", "grad", "indices", "offset2bag", "bag_size", "maximum_indices", 
"num_weights", "scale_grad_by_freq", "mode", "per_sample_weights"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_embedding_bag_dense_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag_forward_only
torch__embedding_bag_forward_only <- function(weight, indices, offsets, scale_grad_by_freq = FALSE, mode = 0L, sparse = FALSE, per_sample_weights = list(), include_last_offset = FALSE, padding_idx = -1L) {
  args <- mget(x = c("weight", "indices", "offsets", "scale_grad_by_freq", "mode", "sparse", "per_sample_weights", "include_last_offset", "padding_idx"))
expected_types <- list(weight = "Tensor", indices = "Tensor", offsets = "Tensor", 
    scale_grad_by_freq = "bool", mode = "int64_t", sparse = "bool", 
    per_sample_weights = "Tensor", include_last_offset = "bool", 
    padding_idx = "int64_t")
nd_args <- c("weight", "indices", "offsets")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_embedding_bag_forward_only',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag_forward_only_out
torch__embedding_bag_forward_only_out <- function(out0, out1, out2, out3, weight, indices, offsets, scale_grad_by_freq = FALSE, mode = 0L, sparse = FALSE, per_sample_weights = list(), include_last_offset = FALSE, padding_idx = -1L) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "weight", "indices", "offsets", "scale_grad_by_freq", "mode", "sparse", "per_sample_weights", "include_last_offset", "padding_idx"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    weight = "Tensor", indices = "Tensor", offsets = "Tensor", 
    scale_grad_by_freq = "bool", mode = "int64_t", sparse = "bool", 
    per_sample_weights = "Tensor", include_last_offset = "bool", 
    padding_idx = "int64_t")
nd_args <- c("out0", "out1", "out2", "out3", "weight", "indices", "offsets"
)
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_embedding_bag_forward_only_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag_out
torch__embedding_bag_out <- function(out0, out1, out2, out3, weight, indices, offsets, scale_grad_by_freq = FALSE, mode = 0L, sparse = FALSE, per_sample_weights = list(), include_last_offset = FALSE, padding_idx = -1L) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "weight", "indices", "offsets", "scale_grad_by_freq", "mode", "sparse", "per_sample_weights", "include_last_offset", "padding_idx"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    weight = "Tensor", indices = "Tensor", offsets = "Tensor", 
    scale_grad_by_freq = "bool", mode = "int64_t", sparse = "bool", 
    per_sample_weights = "Tensor", include_last_offset = "bool", 
    padding_idx = "int64_t")
nd_args <- c("out0", "out1", "out2", "out3", "weight", "indices", "offsets"
)
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_embedding_bag_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag_per_sample_weights_backward
torch__embedding_bag_per_sample_weights_backward <- function(grad, weight, indices, offsets, offset2bag, mode, padding_idx = -1L) {
  args <- mget(x = c("grad", "weight", "indices", "offsets", "offset2bag", "mode", "padding_idx"))
expected_types <- list(grad = "Tensor", weight = "Tensor", indices = "Tensor", 
    offsets = "Tensor", offset2bag = "Tensor", mode = "int64_t", 
    padding_idx = "int64_t")
nd_args <- c("grad", "weight", "indices", "offsets", "offset2bag", "mode"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_embedding_bag_per_sample_weights_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag_per_sample_weights_backward_out
torch__embedding_bag_per_sample_weights_backward_out <- function(out, grad, weight, indices, offsets, offset2bag, mode, padding_idx = -1L) {
  args <- mget(x = c("out", "grad", "weight", "indices", "offsets", "offset2bag", "mode", "padding_idx"))
expected_types <- list(out = "Tensor", grad = "Tensor", weight = "Tensor", indices = "Tensor", 
    offsets = "Tensor", offset2bag = "Tensor", mode = "int64_t", 
    padding_idx = "int64_t")
nd_args <- c("out", "grad", "weight", "indices", "offsets", "offset2bag", 
"mode")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_embedding_bag_per_sample_weights_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__embedding_bag_sparse_backward
torch__embedding_bag_sparse_backward <- function(grad, indices, offsets, offset2bag, bag_size, num_weights, scale_grad_by_freq, mode, per_sample_weights, padding_idx = -1L) {
  args <- mget(x = c("grad", "indices", "offsets", "offset2bag", "bag_size", "num_weights", "scale_grad_by_freq", "mode", "per_sample_weights", "padding_idx"))
expected_types <- list(grad = "Tensor", indices = "Tensor", offsets = "Tensor", 
    offset2bag = "Tensor", bag_size = "Tensor", num_weights = "int64_t", 
    scale_grad_by_freq = "bool", mode = "int64_t", per_sample_weights = "Tensor", 
    padding_idx = "int64_t")
nd_args <- c("grad", "indices", "offsets", "offset2bag", "bag_size", "num_weights", 
"scale_grad_by_freq", "mode", "per_sample_weights")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_embedding_bag_sparse_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__empty_affine_quantized
torch__empty_affine_quantized <- function(size, options = list(), scale = 1L, zero_point = 0L, memory_format = torch_contiguous_format()) {
  args <- mget(x = c("size", "options", "scale", "zero_point", "memory_format"))
expected_types <- list(size = "IntArrayRef", options = "TensorOptions", scale = "double", 
    zero_point = "int64_t", memory_format = "MemoryFormat")
nd_args <- "size"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_empty_affine_quantized',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__empty_affine_quantized_out
torch__empty_affine_quantized_out <- function(out, size, scale = 1L, zero_point = 0L, memory_format = torch_contiguous_format()) {
  args <- mget(x = c("out", "size", "scale", "zero_point", "memory_format"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", scale = "double", 
    zero_point = "int64_t", memory_format = "MemoryFormat")
nd_args <- c("out", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_empty_affine_quantized_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__empty_per_channel_affine_quantized
torch__empty_per_channel_affine_quantized <- function(size, scales, zero_points, axis, options = list(), memory_format = torch_contiguous_format()) {
  args <- mget(x = c("size", "scales", "zero_points", "axis", "options", "memory_format"))
expected_types <- list(size = "IntArrayRef", scales = "Tensor", zero_points = "Tensor", 
    axis = "int64_t", options = "TensorOptions", memory_format = "MemoryFormat")
nd_args <- c("size", "scales", "zero_points", "axis")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_empty_per_channel_affine_quantized',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__empty_per_channel_affine_quantized_out
torch__empty_per_channel_affine_quantized_out <- function(out, size, scales, zero_points, axis, memory_format = torch_contiguous_format()) {
  args <- mget(x = c("out", "size", "scales", "zero_points", "axis", "memory_format"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", scales = "Tensor", 
    zero_points = "Tensor", axis = "int64_t", memory_format = "MemoryFormat")
nd_args <- c("out", "size", "scales", "zero_points", "axis")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_empty_per_channel_affine_quantized_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__euclidean_dist
torch__euclidean_dist <- function(x1, x2) {
  args <- mget(x = c("x1", "x2"))
expected_types <- list(x1 = "Tensor", x2 = "Tensor")
nd_args <- c("x1", "x2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_euclidean_dist',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__euclidean_dist_out
torch__euclidean_dist_out <- function(out, x1, x2) {
  args <- mget(x = c("out", "x1", "x2"))
expected_types <- list(out = "Tensor", x1 = "Tensor", x2 = "Tensor")
nd_args <- c("out", "x1", "x2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_euclidean_dist_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fake_quantize_learnable_per_channel_affine
torch__fake_quantize_learnable_per_channel_affine <- function(self, scale, zero_point, axis, quant_min, quant_max, grad_factor = 1L) {
  args <- mget(x = c("self", "scale", "zero_point", "axis", "quant_min", "quant_max", "grad_factor"))
expected_types <- list(self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    axis = "int64_t", quant_min = "int64_t", quant_max = "int64_t", 
    grad_factor = "double")
nd_args <- c("self", "scale", "zero_point", "axis", "quant_min", "quant_max"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fake_quantize_learnable_per_channel_affine',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fake_quantize_learnable_per_channel_affine_backward
torch__fake_quantize_learnable_per_channel_affine_backward <- function(grad, self, scale, zero_point, axis, quant_min, quant_max, grad_factor = 1L) {
  args <- mget(x = c("grad", "self", "scale", "zero_point", "axis", "quant_min", "quant_max", "grad_factor"))
expected_types <- list(grad = "Tensor", self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    axis = "int64_t", quant_min = "int64_t", quant_max = "int64_t", 
    grad_factor = "double")
nd_args <- c("grad", "self", "scale", "zero_point", "axis", "quant_min", 
"quant_max")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_fake_quantize_learnable_per_channel_affine_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fake_quantize_learnable_per_channel_affine_out
torch__fake_quantize_learnable_per_channel_affine_out <- function(out, self, scale, zero_point, axis, quant_min, quant_max, grad_factor = 1L) {
  args <- mget(x = c("out", "self", "scale", "zero_point", "axis", "quant_min", "quant_max", "grad_factor"))
expected_types <- list(out = "Tensor", self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    axis = "int64_t", quant_min = "int64_t", quant_max = "int64_t", 
    grad_factor = "double")
nd_args <- c("out", "self", "scale", "zero_point", "axis", "quant_min", 
"quant_max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fake_quantize_learnable_per_channel_affine_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fake_quantize_learnable_per_tensor_affine
torch__fake_quantize_learnable_per_tensor_affine <- function(self, scale, zero_point, quant_min, quant_max, grad_factor = 1L) {
  args <- mget(x = c("self", "scale", "zero_point", "quant_min", "quant_max", "grad_factor"))
expected_types <- list(self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    quant_min = "int64_t", quant_max = "int64_t", grad_factor = "double")
nd_args <- c("self", "scale", "zero_point", "quant_min", "quant_max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fake_quantize_learnable_per_tensor_affine',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fake_quantize_learnable_per_tensor_affine_backward
torch__fake_quantize_learnable_per_tensor_affine_backward <- function(grad, self, scale, zero_point, quant_min, quant_max, grad_factor = 1L) {
  args <- mget(x = c("grad", "self", "scale", "zero_point", "quant_min", "quant_max", "grad_factor"))
expected_types <- list(grad = "Tensor", self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    quant_min = "int64_t", quant_max = "int64_t", grad_factor = "double")
nd_args <- c("grad", "self", "scale", "zero_point", "quant_min", "quant_max"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_fake_quantize_learnable_per_tensor_affine_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fake_quantize_learnable_per_tensor_affine_out
torch__fake_quantize_learnable_per_tensor_affine_out <- function(out, self, scale, zero_point, quant_min, quant_max, grad_factor = 1L) {
  args <- mget(x = c("out", "self", "scale", "zero_point", "quant_min", "quant_max", "grad_factor"))
expected_types <- list(out = "Tensor", self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    quant_min = "int64_t", quant_max = "int64_t", grad_factor = "double")
nd_args <- c("out", "self", "scale", "zero_point", "quant_min", "quant_max"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fake_quantize_learnable_per_tensor_affine_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fake_quantize_per_tensor_affine_cachemask_tensor_qparams
torch__fake_quantize_per_tensor_affine_cachemask_tensor_qparams <- function(self, scale, zero_point, fake_quant_enabled, quant_min, quant_max) {
  args <- mget(x = c("self", "scale", "zero_point", "fake_quant_enabled", "quant_min", "quant_max"))
expected_types <- list(self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    fake_quant_enabled = "Tensor", quant_min = "int64_t", quant_max = "int64_t")
nd_args <- c("self", "scale", "zero_point", "fake_quant_enabled", "quant_min", 
"quant_max")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_fake_quantize_per_tensor_affine_cachemask_tensor_qparams',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out
torch__fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out <- function(out0, out1, self, scale, zero_point, fake_quant_enabled, quant_min, quant_max) {
  args <- mget(x = c("out0", "out1", "self", "scale", "zero_point", "fake_quant_enabled", "quant_min", "quant_max"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", self = "Tensor", scale = "Tensor", 
    zero_point = "Tensor", fake_quant_enabled = "Tensor", quant_min = "int64_t", 
    quant_max = "int64_t")
nd_args <- c("out0", "out1", "self", "scale", "zero_point", "fake_quant_enabled", 
"quant_min", "quant_max")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fft_c2c
torch__fft_c2c <- function(self, dim, normalization, forward) {
  args <- mget(x = c("self", "dim", "normalization", "forward"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", normalization = "int64_t", 
    forward = "bool")
nd_args <- c("self", "dim", "normalization", "forward")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fft_c2c',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fft_c2c_out
torch__fft_c2c_out <- function(out, self, dim, normalization, forward) {
  args <- mget(x = c("out", "self", "dim", "normalization", "forward"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", normalization = "int64_t", 
    forward = "bool")
nd_args <- c("out", "self", "dim", "normalization", "forward")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fft_c2c_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fft_c2r
torch__fft_c2r <- function(self, dim, normalization, last_dim_size) {
  args <- mget(x = c("self", "dim", "normalization", "last_dim_size"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", normalization = "int64_t", 
    last_dim_size = "int64_t")
nd_args <- c("self", "dim", "normalization", "last_dim_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fft_c2r',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fft_c2r_out
torch__fft_c2r_out <- function(out, self, dim, normalization, last_dim_size) {
  args <- mget(x = c("out", "self", "dim", "normalization", "last_dim_size"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", normalization = "int64_t", 
    last_dim_size = "int64_t")
nd_args <- c("out", "self", "dim", "normalization", "last_dim_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fft_c2r_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fft_r2c
torch__fft_r2c <- function(self, dim, normalization, onesided) {
  args <- mget(x = c("self", "dim", "normalization", "onesided"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", normalization = "int64_t", 
    onesided = "bool")
nd_args <- c("self", "dim", "normalization", "onesided")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fft_r2c',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fft_r2c_out
torch__fft_r2c_out <- function(out, self, dim, normalization, onesided) {
  args <- mget(x = c("out", "self", "dim", "normalization", "onesided"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", normalization = "int64_t", 
    onesided = "bool")
nd_args <- c("out", "self", "dim", "normalization", "onesided")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fft_r2c_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__flash_attention_backward
torch__flash_attention_backward <- function(grad_out, query, key, value, out, logsumexp, cum_seq_q, cum_seq_k, max_q, max_k, dropout_p, is_causal, philox_seed, philox_offset) {
  args <- mget(x = c("grad_out", "query", "key", "value", "out", "logsumexp", "cum_seq_q", "cum_seq_k", "max_q", "max_k", "dropout_p", "is_causal", "philox_seed", "philox_offset"))
expected_types <- list(grad_out = "Tensor", query = "Tensor", key = "Tensor", value = "Tensor", 
    out = "Tensor", logsumexp = "Tensor", cum_seq_q = "Tensor", 
    cum_seq_k = "Tensor", max_q = "int64_t", max_k = "int64_t", 
    dropout_p = "double", is_causal = "bool", philox_seed = "int64_t", 
    philox_offset = "int64_t")
nd_args <- c("grad_out", "query", "key", "value", "out", "logsumexp", "cum_seq_q", 
"cum_seq_k", "max_q", "max_k", "dropout_p", "is_causal", "philox_seed", 
"philox_offset")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_flash_attention_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__flash_attention_forward
torch__flash_attention_forward <- function(query, key, value, cum_seq_q, cum_seq_k, max_q, max_k, dropout_p, is_causal, return_debug_mask) {
  args <- mget(x = c("query", "key", "value", "cum_seq_q", "cum_seq_k", "max_q", "max_k", "dropout_p", "is_causal", "return_debug_mask"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", cum_seq_q = "Tensor", 
    cum_seq_k = "Tensor", max_q = "int64_t", max_k = "int64_t", 
    dropout_p = "double", is_causal = "bool", return_debug_mask = "bool")
nd_args <- c("query", "key", "value", "cum_seq_q", "cum_seq_k", "max_q", 
"max_k", "dropout_p", "is_causal", "return_debug_mask")
return_types <- list(list("Tensor", "Tensor", "int64_t", "int64_t", "Tensor"))
call_c_function(
fun_name = '_flash_attention_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foobar
torch__foobar <- function(self, arg1 = TRUE, arg2 = TRUE, arg3 = TRUE) {
  args <- mget(x = c("self", "arg1", "arg2", "arg3"))
expected_types <- list(self = "Tensor", arg1 = "bool", arg2 = "bool", arg3 = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_foobar',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foobar_out
torch__foobar_out <- function(out, self, arg1 = TRUE, arg2 = TRUE, arg3 = TRUE) {
  args <- mget(x = c("out", "self", "arg1", "arg2", "arg3"))
expected_types <- list(out = "Tensor", self = "Tensor", arg1 = "bool", arg2 = "bool", 
    arg3 = "bool")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_foobar_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_abs
torch__foreach_abs <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_abs',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_abs_
torch__foreach_abs_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_abs_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_abs_out
torch__foreach_abs_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_abs_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_acos
torch__foreach_acos <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_acos',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_acos_
torch__foreach_acos_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_acos_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_acos_out
torch__foreach_acos_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_acos_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_add
torch__foreach_add <- function(self, other, scalar, scalars, alpha = 1L) {
  args <- mget(x = c("self", "other", "scalar", "scalars", "alpha"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>", alpha = "Scalar")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_add',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_add_
torch__foreach_add_ <- function(self, other, scalar, scalars, alpha = 1L) {
  args <- mget(x = c("self", "other", "scalar", "scalars", "alpha"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>", alpha = "Scalar")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_add_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_add_out
torch__foreach_add_out <- function(out, self, other, scalar, scalars, alpha = 1L) {
  args <- mget(x = c("out", "self", "other", "scalar", "scalars", "alpha"))
expected_types <- list(out = "TensorList", self = "TensorList", other = "TensorList", 
    scalar = "Scalar", scalars = "ArrayRef<Scalar>", alpha = "Scalar")
nd_args <- c("out", "self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_add_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_addcdiv
torch__foreach_addcdiv <- function(self, tensor1, tensor2, scalars, value = 1L) {
  args <- mget(x = c("self", "tensor1", "tensor2", "scalars", "value"))
expected_types <- list(self = "TensorList", tensor1 = "TensorList", tensor2 = "TensorList", 
    scalars = c("ArrayRef<Scalar>", "Tensor"), value = "Scalar")
nd_args <- c("self", "tensor1", "tensor2", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_addcdiv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_addcdiv_
torch__foreach_addcdiv_ <- function(self, tensor1, tensor2, scalars, value = 1L) {
  args <- mget(x = c("self", "tensor1", "tensor2", "scalars", "value"))
expected_types <- list(self = "TensorList", tensor1 = "TensorList", tensor2 = "TensorList", 
    scalars = c("ArrayRef<Scalar>", "Tensor"), value = "Scalar")
nd_args <- c("self", "tensor1", "tensor2", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_addcdiv_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_addcdiv_out
torch__foreach_addcdiv_out <- function(out, self, tensor1, tensor2, scalars, value = 1L) {
  args <- mget(x = c("out", "self", "tensor1", "tensor2", "scalars", "value"))
expected_types <- list(out = "TensorList", self = "TensorList", tensor1 = "TensorList", 
    tensor2 = "TensorList", scalars = c("ArrayRef<Scalar>", "Tensor"
    ), value = "Scalar")
nd_args <- c("out", "self", "tensor1", "tensor2", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_addcdiv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_addcmul
torch__foreach_addcmul <- function(self, tensor1, tensor2, scalars, value = 1L) {
  args <- mget(x = c("self", "tensor1", "tensor2", "scalars", "value"))
expected_types <- list(self = "TensorList", tensor1 = "TensorList", tensor2 = "TensorList", 
    scalars = c("ArrayRef<Scalar>", "Tensor"), value = "Scalar")
nd_args <- c("self", "tensor1", "tensor2", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_addcmul',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_addcmul_
torch__foreach_addcmul_ <- function(self, tensor1, tensor2, scalars, value = 1L) {
  args <- mget(x = c("self", "tensor1", "tensor2", "scalars", "value"))
expected_types <- list(self = "TensorList", tensor1 = "TensorList", tensor2 = "TensorList", 
    scalars = c("ArrayRef<Scalar>", "Tensor"), value = "Scalar")
nd_args <- c("self", "tensor1", "tensor2", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_addcmul_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_addcmul_out
torch__foreach_addcmul_out <- function(out, self, tensor1, tensor2, scalars, value = 1L) {
  args <- mget(x = c("out", "self", "tensor1", "tensor2", "scalars", "value"))
expected_types <- list(out = "TensorList", self = "TensorList", tensor1 = "TensorList", 
    tensor2 = "TensorList", scalars = c("ArrayRef<Scalar>", "Tensor"
    ), value = "Scalar")
nd_args <- c("out", "self", "tensor1", "tensor2", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_addcmul_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_asin
torch__foreach_asin <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_asin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_asin_
torch__foreach_asin_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_asin_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_asin_out
torch__foreach_asin_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_asin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_atan
torch__foreach_atan <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_atan',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_atan_
torch__foreach_atan_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_atan_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_atan_out
torch__foreach_atan_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_atan_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_ceil
torch__foreach_ceil <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_ceil',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_ceil_
torch__foreach_ceil_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_ceil_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_ceil_out
torch__foreach_ceil_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_ceil_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_clamp_max
torch__foreach_clamp_max <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_clamp_max',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_clamp_max_
torch__foreach_clamp_max_ <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_clamp_max_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_clamp_max_out
torch__foreach_clamp_max_out <- function(out, self, other, scalar, scalars) {
  args <- mget(x = c("out", "self", "other", "scalar", "scalars"))
expected_types <- list(out = "TensorList", self = "TensorList", other = "TensorList", 
    scalar = "Scalar", scalars = "ArrayRef<Scalar>")
nd_args <- c("out", "self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_clamp_max_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_clamp_min
torch__foreach_clamp_min <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_clamp_min',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_clamp_min_
torch__foreach_clamp_min_ <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_clamp_min_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_clamp_min_out
torch__foreach_clamp_min_out <- function(out, self, other, scalar, scalars) {
  args <- mget(x = c("out", "self", "other", "scalar", "scalars"))
expected_types <- list(out = "TensorList", self = "TensorList", other = "TensorList", 
    scalar = "Scalar", scalars = "ArrayRef<Scalar>")
nd_args <- c("out", "self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_clamp_min_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_cos
torch__foreach_cos <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_cos',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_cos_
torch__foreach_cos_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_cos_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_cos_out
torch__foreach_cos_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_cos_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_cosh
torch__foreach_cosh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_cosh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_cosh_
torch__foreach_cosh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_cosh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_cosh_out
torch__foreach_cosh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_cosh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_div
torch__foreach_div <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_div',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_div_
torch__foreach_div_ <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_div_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_div_out
torch__foreach_div_out <- function(out, self, other, scalar, scalars) {
  args <- mget(x = c("out", "self", "other", "scalar", "scalars"))
expected_types <- list(out = "TensorList", self = "TensorList", other = "TensorList", 
    scalar = "Scalar", scalars = "ArrayRef<Scalar>")
nd_args <- c("out", "self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_div_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_erf
torch__foreach_erf <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_erf',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_erf_
torch__foreach_erf_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_erf_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_erf_out
torch__foreach_erf_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_erf_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_erfc
torch__foreach_erfc <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_erfc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_erfc_
torch__foreach_erfc_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_erfc_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_erfc_out
torch__foreach_erfc_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_erfc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_exp
torch__foreach_exp <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_exp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_exp_
torch__foreach_exp_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_exp_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_exp_out
torch__foreach_exp_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_exp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_expm1
torch__foreach_expm1 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_expm1',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_expm1_
torch__foreach_expm1_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_expm1_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_expm1_out
torch__foreach_expm1_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_expm1_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_floor
torch__foreach_floor <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_floor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_floor_
torch__foreach_floor_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_floor_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_floor_out
torch__foreach_floor_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_floor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_frac
torch__foreach_frac <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_frac',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_frac_
torch__foreach_frac_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_frac_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_frac_out
torch__foreach_frac_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_frac_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_lerp
torch__foreach_lerp <- function(self, tensors1, weight, weights) {
  args <- mget(x = c("self", "tensors1", "weight", "weights"))
expected_types <- list(self = "TensorList", tensors1 = "TensorList", weight = "Scalar", 
    weights = "TensorList")
nd_args <- c("self", "tensors1", "weight", "weights")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_lerp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_lerp_
torch__foreach_lerp_ <- function(self, tensors1, weight, weights) {
  args <- mget(x = c("self", "tensors1", "weight", "weights"))
expected_types <- list(self = "TensorList", tensors1 = "TensorList", weight = "Scalar", 
    weights = "TensorList")
nd_args <- c("self", "tensors1", "weight", "weights")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_lerp_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_lerp_out
torch__foreach_lerp_out <- function(out, self, tensors1, weight, weights) {
  args <- mget(x = c("out", "self", "tensors1", "weight", "weights"))
expected_types <- list(out = "TensorList", self = "TensorList", tensors1 = "TensorList", 
    weight = "Scalar", weights = "TensorList")
nd_args <- c("out", "self", "tensors1", "weight", "weights")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_lerp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_lgamma
torch__foreach_lgamma <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_lgamma',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_lgamma_
torch__foreach_lgamma_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_lgamma_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_lgamma_out
torch__foreach_lgamma_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_lgamma_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log
torch__foreach_log <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_log',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log_
torch__foreach_log_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_log_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log_out
torch__foreach_log_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_log_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log10
torch__foreach_log10 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_log10',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log10_
torch__foreach_log10_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_log10_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log10_out
torch__foreach_log10_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_log10_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log1p
torch__foreach_log1p <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_log1p',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log1p_
torch__foreach_log1p_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_log1p_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log1p_out
torch__foreach_log1p_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_log1p_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log2
torch__foreach_log2 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_log2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log2_
torch__foreach_log2_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_log2_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_log2_out
torch__foreach_log2_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_log2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_maximum
torch__foreach_maximum <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_maximum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_maximum_
torch__foreach_maximum_ <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_maximum_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_maximum_out
torch__foreach_maximum_out <- function(out, self, other, scalar, scalars) {
  args <- mget(x = c("out", "self", "other", "scalar", "scalars"))
expected_types <- list(out = "TensorList", self = "TensorList", other = "TensorList", 
    scalar = "Scalar", scalars = "ArrayRef<Scalar>")
nd_args <- c("out", "self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_maximum_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_minimum
torch__foreach_minimum <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_minimum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_minimum_
torch__foreach_minimum_ <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_minimum_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_minimum_out
torch__foreach_minimum_out <- function(out, self, other, scalar, scalars) {
  args <- mget(x = c("out", "self", "other", "scalar", "scalars"))
expected_types <- list(out = "TensorList", self = "TensorList", other = "TensorList", 
    scalar = "Scalar", scalars = "ArrayRef<Scalar>")
nd_args <- c("out", "self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_minimum_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_mul
torch__foreach_mul <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_mul',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_mul_
torch__foreach_mul_ <- function(self, other, scalar, scalars) {
  args <- mget(x = c("self", "other", "scalar", "scalars"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_mul_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_mul_out
torch__foreach_mul_out <- function(out, self, other, scalar, scalars) {
  args <- mget(x = c("out", "self", "other", "scalar", "scalars"))
expected_types <- list(out = "TensorList", self = "TensorList", other = "TensorList", 
    scalar = "Scalar", scalars = "ArrayRef<Scalar>")
nd_args <- c("out", "self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_mul_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_neg
torch__foreach_neg <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_neg',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_neg_
torch__foreach_neg_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_neg_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_neg_out
torch__foreach_neg_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_neg_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_norm
torch__foreach_norm <- function(self, ord = 2L) {
  args <- mget(x = c("self", "ord"))
expected_types <- list(self = "TensorList", ord = "Scalar")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_norm_out
torch__foreach_norm_out <- function(out, self, ord = 2L) {
  args <- mget(x = c("out", "self", "ord"))
expected_types <- list(out = "TensorList", self = "TensorList", ord = "Scalar")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_reciprocal
torch__foreach_reciprocal <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_reciprocal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_reciprocal_
torch__foreach_reciprocal_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_reciprocal_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_reciprocal_out
torch__foreach_reciprocal_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_reciprocal_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_round
torch__foreach_round <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_round',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_round_
torch__foreach_round_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_round_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_round_out
torch__foreach_round_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_round_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sigmoid
torch__foreach_sigmoid <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_sigmoid',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sigmoid_
torch__foreach_sigmoid_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sigmoid_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sigmoid_out
torch__foreach_sigmoid_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sigmoid_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sin
torch__foreach_sin <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_sin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sin_
torch__foreach_sin_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sin_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sin_out
torch__foreach_sin_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sinh
torch__foreach_sinh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_sinh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sinh_
torch__foreach_sinh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sinh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sinh_out
torch__foreach_sinh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sinh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sqrt
torch__foreach_sqrt <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_sqrt',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sqrt_
torch__foreach_sqrt_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sqrt_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sqrt_out
torch__foreach_sqrt_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sqrt_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sub
torch__foreach_sub <- function(self, other, scalar, scalars, alpha = 1L) {
  args <- mget(x = c("self", "other", "scalar", "scalars", "alpha"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>", alpha = "Scalar")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_sub',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sub_
torch__foreach_sub_ <- function(self, other, scalar, scalars, alpha = 1L) {
  args <- mget(x = c("self", "other", "scalar", "scalars", "alpha"))
expected_types <- list(self = "TensorList", other = "TensorList", scalar = "Scalar", 
    scalars = "ArrayRef<Scalar>", alpha = "Scalar")
nd_args <- c("self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sub_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_sub_out
torch__foreach_sub_out <- function(out, self, other, scalar, scalars, alpha = 1L) {
  args <- mget(x = c("out", "self", "other", "scalar", "scalars", "alpha"))
expected_types <- list(out = "TensorList", self = "TensorList", other = "TensorList", 
    scalar = "Scalar", scalars = "ArrayRef<Scalar>", alpha = "Scalar")
nd_args <- c("out", "self", "other", "scalar", "scalars")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_sub_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_tan
torch__foreach_tan <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_tan',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_tan_
torch__foreach_tan_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_tan_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_tan_out
torch__foreach_tan_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_tan_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_tanh
torch__foreach_tanh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_tanh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_tanh_
torch__foreach_tanh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_tanh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_tanh_out
torch__foreach_tanh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_tanh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_trunc
torch__foreach_trunc <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_trunc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_trunc_
torch__foreach_trunc_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_trunc_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_trunc_out
torch__foreach_trunc_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_trunc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_zero
torch__foreach_zero <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_foreach_zero',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_zero_
torch__foreach_zero_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "TensorList")
nd_args <- "self"
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_zero_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__foreach_zero_out
torch__foreach_zero_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "TensorList", self = "TensorList")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = '_foreach_zero_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_adam
torch__fused_adam <- function(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale = list(), found_inf = list()) {
  args <- mget(x = c("self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", "state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", "amsgrad", "maximize", "grad_scale", "found_inf"))
expected_types <- list(self = "TensorList", grads = "TensorList", exp_avgs = "TensorList", 
    exp_avg_sqs = "TensorList", max_exp_avg_sqs = "TensorList", 
    state_steps = "TensorList", lr = "double", beta1 = "double", 
    beta2 = "double", weight_decay = "double", eps = "double", 
    amsgrad = "bool", maximize = "bool", grad_scale = "Tensor", 
    found_inf = "Tensor")
nd_args <- c("self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", 
"state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", 
"amsgrad", "maximize")
return_types <- list(list("TensorList", "TensorList", "TensorList", "TensorList",     "TensorList"))
call_c_function(
fun_name = '_fused_adam',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_adam_
torch__fused_adam_ <- function(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale = list(), found_inf = list()) {
  args <- mget(x = c("self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", "state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", "amsgrad", "maximize", "grad_scale", "found_inf"))
expected_types <- list(self = "TensorList", grads = "TensorList", exp_avgs = "TensorList", 
    exp_avg_sqs = "TensorList", max_exp_avg_sqs = "TensorList", 
    state_steps = "TensorList", lr = "double", beta1 = "double", 
    beta2 = "double", weight_decay = "double", eps = "double", 
    amsgrad = "bool", maximize = "bool", grad_scale = "Tensor", 
    found_inf = "Tensor")
nd_args <- c("self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", 
"state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", 
"amsgrad", "maximize")
return_types <- list(list("void"))
call_c_function(
fun_name = '_fused_adam_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_adam_out
torch__fused_adam_out <- function(out, self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale = list(), found_inf = list()) {
  args <- mget(x = c("out", "self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", "state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", "amsgrad", "maximize", "grad_scale", "found_inf"))
expected_types <- list(out = "TensorList", self = "TensorList", grads = "TensorList", 
    exp_avgs = "TensorList", exp_avg_sqs = "TensorList", max_exp_avg_sqs = "TensorList", 
    state_steps = "TensorList", lr = "double", beta1 = "double", 
    beta2 = "double", weight_decay = "double", eps = "double", 
    amsgrad = "bool", maximize = "bool", grad_scale = "Tensor", 
    found_inf = "Tensor")
nd_args <- c("out", "self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", 
"state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", 
"amsgrad", "maximize")
return_types <- list(list("void"))
call_c_function(
fun_name = '_fused_adam_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_adamw
torch__fused_adamw <- function(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale = list(), found_inf = list()) {
  args <- mget(x = c("self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", "state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", "amsgrad", "maximize", "grad_scale", "found_inf"))
expected_types <- list(self = "TensorList", grads = "TensorList", exp_avgs = "TensorList", 
    exp_avg_sqs = "TensorList", max_exp_avg_sqs = "TensorList", 
    state_steps = "TensorList", lr = "double", beta1 = "double", 
    beta2 = "double", weight_decay = "double", eps = "double", 
    amsgrad = "bool", maximize = "bool", grad_scale = "Tensor", 
    found_inf = "Tensor")
nd_args <- c("self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", 
"state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", 
"amsgrad", "maximize")
return_types <- list(list("TensorList", "TensorList", "TensorList", "TensorList",     "TensorList"))
call_c_function(
fun_name = '_fused_adamw',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_adamw_
torch__fused_adamw_ <- function(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale = list(), found_inf = list()) {
  args <- mget(x = c("self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", "state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", "amsgrad", "maximize", "grad_scale", "found_inf"))
expected_types <- list(self = "TensorList", grads = "TensorList", exp_avgs = "TensorList", 
    exp_avg_sqs = "TensorList", max_exp_avg_sqs = "TensorList", 
    state_steps = "TensorList", lr = "double", beta1 = "double", 
    beta2 = "double", weight_decay = "double", eps = "double", 
    amsgrad = "bool", maximize = "bool", grad_scale = "Tensor", 
    found_inf = "Tensor")
nd_args <- c("self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", 
"state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", 
"amsgrad", "maximize")
return_types <- list(list("void"))
call_c_function(
fun_name = '_fused_adamw_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_adamw_out
torch__fused_adamw_out <- function(out, self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale = list(), found_inf = list()) {
  args <- mget(x = c("out", "self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", "state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", "amsgrad", "maximize", "grad_scale", "found_inf"))
expected_types <- list(out = "TensorList", self = "TensorList", grads = "TensorList", 
    exp_avgs = "TensorList", exp_avg_sqs = "TensorList", max_exp_avg_sqs = "TensorList", 
    state_steps = "TensorList", lr = "double", beta1 = "double", 
    beta2 = "double", weight_decay = "double", eps = "double", 
    amsgrad = "bool", maximize = "bool", grad_scale = "Tensor", 
    found_inf = "Tensor")
nd_args <- c("out", "self", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", 
"state_steps", "lr", "beta1", "beta2", "weight_decay", "eps", 
"amsgrad", "maximize")
return_types <- list(list("void"))
call_c_function(
fun_name = '_fused_adamw_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_dropout
torch__fused_dropout <- function(self, p, generator = NULL) {
  args <- mget(x = c("self", "p", "generator"))
expected_types <- list(self = "Tensor", p = "double", generator = "Generator")
nd_args <- c("self", "p")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_fused_dropout',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_dropout_out
torch__fused_dropout_out <- function(out0, out1, self, p, generator = NULL) {
  args <- mget(x = c("out0", "out1", "self", "p", "generator"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", self = "Tensor", p = "double", 
    generator = "Generator")
nd_args <- c("out0", "out1", "self", "p")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_fused_dropout_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_moving_avg_obs_fq_helper
torch__fused_moving_avg_obs_fq_helper <- function(self, observer_on, fake_quant_on, running_min, running_max, scale, zero_point, averaging_const, quant_min, quant_max, ch_axis, per_row_fake_quant = FALSE, symmetric_quant = FALSE) {
  args <- mget(x = c("self", "observer_on", "fake_quant_on", "running_min", "running_max", "scale", "zero_point", "averaging_const", "quant_min", "quant_max", "ch_axis", "per_row_fake_quant", "symmetric_quant"))
expected_types <- list(self = "Tensor", observer_on = "Tensor", fake_quant_on = "Tensor", 
    running_min = "Tensor", running_max = "Tensor", scale = "Tensor", 
    zero_point = "Tensor", averaging_const = "double", quant_min = "int64_t", 
    quant_max = "int64_t", ch_axis = "int64_t", per_row_fake_quant = "bool", 
    symmetric_quant = "bool")
nd_args <- c("self", "observer_on", "fake_quant_on", "running_min", "running_max", 
"scale", "zero_point", "averaging_const", "quant_min", "quant_max", 
"ch_axis")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_fused_moving_avg_obs_fq_helper',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_moving_avg_obs_fq_helper_functional
torch__fused_moving_avg_obs_fq_helper_functional <- function(self, observer_on, fake_quant_on, running_min, running_max, scale, zero_point, averaging_const, quant_min, quant_max, ch_axis, per_row_fake_quant = FALSE, symmetric_quant = FALSE) {
  args <- mget(x = c("self", "observer_on", "fake_quant_on", "running_min", "running_max", "scale", "zero_point", "averaging_const", "quant_min", "quant_max", "ch_axis", "per_row_fake_quant", "symmetric_quant"))
expected_types <- list(self = "Tensor", observer_on = "Tensor", fake_quant_on = "Tensor", 
    running_min = "Tensor", running_max = "Tensor", scale = "Tensor", 
    zero_point = "Tensor", averaging_const = "double", quant_min = "int64_t", 
    quant_max = "int64_t", ch_axis = "int64_t", per_row_fake_quant = "bool", 
    symmetric_quant = "bool")
nd_args <- c("self", "observer_on", "fake_quant_on", "running_min", "running_max", 
"scale", "zero_point", "averaging_const", "quant_min", "quant_max", 
"ch_axis")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_fused_moving_avg_obs_fq_helper_functional',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_moving_avg_obs_fq_helper_out
torch__fused_moving_avg_obs_fq_helper_out <- function(out0, out1, self, observer_on, fake_quant_on, running_min, running_max, scale, zero_point, averaging_const, quant_min, quant_max, ch_axis, per_row_fake_quant = FALSE, symmetric_quant = FALSE) {
  args <- mget(x = c("out0", "out1", "self", "observer_on", "fake_quant_on", "running_min", "running_max", "scale", "zero_point", "averaging_const", "quant_min", "quant_max", "ch_axis", "per_row_fake_quant", "symmetric_quant"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", self = "Tensor", observer_on = "Tensor", 
    fake_quant_on = "Tensor", running_min = "Tensor", running_max = "Tensor", 
    scale = "Tensor", zero_point = "Tensor", averaging_const = "double", 
    quant_min = "int64_t", quant_max = "int64_t", ch_axis = "int64_t", 
    per_row_fake_quant = "bool", symmetric_quant = "bool")
nd_args <- c("out0", "out1", "self", "observer_on", "fake_quant_on", "running_min", 
"running_max", "scale", "zero_point", "averaging_const", "quant_min", 
"quant_max", "ch_axis")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_fused_moving_avg_obs_fq_helper_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fused_sdp_choice
torch__fused_sdp_choice <- function(query, key, value, attn_mask = list(), dropout_p = 0L, is_causal = FALSE) {
  args <- mget(x = c("query", "key", "value", "attn_mask", "dropout_p", "is_causal"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", attn_mask = "Tensor", 
    dropout_p = "double", is_causal = "bool")
nd_args <- c("query", "key", "value")
return_types <- list(list('int64_t'))
call_c_function(
fun_name = '_fused_sdp_choice',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fw_primal_copy
torch__fw_primal_copy <- function(self, level) {
  args <- mget(x = c("self", "level"))
expected_types <- list(self = "Tensor", level = "int64_t")
nd_args <- c("self", "level")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fw_primal_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__fw_primal_copy_out
torch__fw_primal_copy_out <- function(out, self, level) {
  args <- mget(x = c("out", "self", "level"))
expected_types <- list(out = "Tensor", self = "Tensor", level = "int64_t")
nd_args <- c("out", "self", "level")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_fw_primal_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__gather_sparse_backward
torch__gather_sparse_backward <- function(self, dim, index, grad) {
  args <- mget(x = c("self", "dim", "index", "grad"))
expected_types <- list(self = "Tensor", dim = "int64_t", index = "Tensor", grad = "Tensor")
nd_args <- c("self", "dim", "index", "grad")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_gather_sparse_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__grid_sampler_2d_cpu_fallback
torch__grid_sampler_2d_cpu_fallback <- function(input, grid, interpolation_mode, padding_mode, align_corners) {
  args <- mget(x = c("input", "grid", "interpolation_mode", "padding_mode", "align_corners"))
expected_types <- list(input = "Tensor", grid = "Tensor", interpolation_mode = "int64_t", 
    padding_mode = "int64_t", align_corners = "bool")
nd_args <- c("input", "grid", "interpolation_mode", "padding_mode", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_grid_sampler_2d_cpu_fallback',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__grid_sampler_2d_cpu_fallback_backward
torch__grid_sampler_2d_cpu_fallback_backward <- function(grad_output, input, grid, interpolation_mode, padding_mode, align_corners) {
  args <- mget(x = c("grad_output", "input", "grid", "interpolation_mode", "padding_mode", "align_corners"))
expected_types <- list(grad_output = "Tensor", input = "Tensor", grid = "Tensor", 
    interpolation_mode = "int64_t", padding_mode = "int64_t", 
    align_corners = "bool")
nd_args <- c("grad_output", "input", "grid", "interpolation_mode", "padding_mode", 
"align_corners")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_grid_sampler_2d_cpu_fallback_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__grid_sampler_2d_cpu_fallback_out
torch__grid_sampler_2d_cpu_fallback_out <- function(out, input, grid, interpolation_mode, padding_mode, align_corners) {
  args <- mget(x = c("out", "input", "grid", "interpolation_mode", "padding_mode", "align_corners"))
expected_types <- list(out = "Tensor", input = "Tensor", grid = "Tensor", interpolation_mode = "int64_t", 
    padding_mode = "int64_t", align_corners = "bool")
nd_args <- c("out", "input", "grid", "interpolation_mode", "padding_mode", 
"align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_grid_sampler_2d_cpu_fallback_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__has_compatible_shallow_copy_type
torch__has_compatible_shallow_copy_type <- function(self, from) {
  args <- mget(x = c("self", "from"))
expected_types <- list(self = "Tensor", from = "Tensor")
nd_args <- c("self", "from")
return_types <- list(list('bool'))
call_c_function(
fun_name = '_has_compatible_shallow_copy_type',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__has_same_storage_numel
torch__has_same_storage_numel <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('bool'))
call_c_function(
fun_name = '_has_same_storage_numel',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__histogramdd_bin_edges
torch__histogramdd_bin_edges <- function(self, bins, range = NULL, weight = list(), density = FALSE) {
  args <- mget(x = c("self", "bins", "range", "weight", "density"))
expected_types <- list(self = "Tensor", bins = "IntArrayRef", range = "ArrayRef<double>", 
    weight = "Tensor", density = "bool")
nd_args <- c("self", "bins")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_histogramdd_bin_edges',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__histogramdd_bin_edges_out
torch__histogramdd_bin_edges_out <- function(out, self, bins, range = NULL, weight = list(), density = FALSE) {
  args <- mget(x = c("out", "self", "bins", "range", "weight", "density"))
expected_types <- list(out = "TensorList", self = "Tensor", bins = "IntArrayRef", 
    range = "ArrayRef<double>", weight = "Tensor", density = "bool")
nd_args <- c("out", "self", "bins")
return_types <- list(list("void"))
call_c_function(
fun_name = '_histogramdd_bin_edges_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__histogramdd_from_bin_cts
torch__histogramdd_from_bin_cts <- function(self, bins, range = NULL, weight = list(), density = FALSE) {
  args <- mget(x = c("self", "bins", "range", "weight", "density"))
expected_types <- list(self = "Tensor", bins = "IntArrayRef", range = "ArrayRef<double>", 
    weight = "Tensor", density = "bool")
nd_args <- c("self", "bins")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_histogramdd_from_bin_cts',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__histogramdd_from_bin_cts_out
torch__histogramdd_from_bin_cts_out <- function(out, self, bins, range = NULL, weight = list(), density = FALSE) {
  args <- mget(x = c("out", "self", "bins", "range", "weight", "density"))
expected_types <- list(out = "Tensor", self = "Tensor", bins = "IntArrayRef", range = "ArrayRef<double>", 
    weight = "Tensor", density = "bool")
nd_args <- c("out", "self", "bins")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_histogramdd_from_bin_cts_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__histogramdd_from_bin_tensors
torch__histogramdd_from_bin_tensors <- function(self, bins, weight = list(), density = FALSE) {
  args <- mget(x = c("self", "bins", "weight", "density"))
expected_types <- list(self = "Tensor", bins = "TensorList", weight = "Tensor", 
    density = "bool")
nd_args <- c("self", "bins")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_histogramdd_from_bin_tensors',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__histogramdd_from_bin_tensors_out
torch__histogramdd_from_bin_tensors_out <- function(out, self, bins, weight = list(), density = FALSE) {
  args <- mget(x = c("out", "self", "bins", "weight", "density"))
expected_types <- list(out = "Tensor", self = "Tensor", bins = "TensorList", weight = "Tensor", 
    density = "bool")
nd_args <- c("out", "self", "bins")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_histogramdd_from_bin_tensors_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__index_put_impl
torch__index_put_impl <- function(self, indices, values, accumulate = FALSE, unsafe = FALSE) {
  args <- mget(x = c("self", "indices", "values", "accumulate", "unsafe"))
expected_types <- list(self = "Tensor", indices = "const c10::List<c10::optional<Tensor>> &", 
    values = "Tensor", accumulate = "bool", unsafe = "bool")
nd_args <- c("self", "indices", "values")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_index_put_impl',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__index_put_impl_
torch__index_put_impl_ <- function(self, indices, values, accumulate = FALSE, unsafe = FALSE) {
  args <- mget(x = c("self", "indices", "values", "accumulate", "unsafe"))
expected_types <- list(self = "Tensor", indices = "const c10::List<c10::optional<Tensor>> &", 
    values = "Tensor", accumulate = "bool", unsafe = "bool")
nd_args <- c("self", "indices", "values")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_index_put_impl_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__index_put_impl_out
torch__index_put_impl_out <- function(out, self, indices, values, accumulate = FALSE, unsafe = FALSE) {
  args <- mget(x = c("out", "self", "indices", "values", "accumulate", "unsafe"))
expected_types <- list(out = "Tensor", self = "Tensor", indices = "const c10::List<c10::optional<Tensor>> &", 
    values = "Tensor", accumulate = "bool", unsafe = "bool")
nd_args <- c("out", "self", "indices", "values")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_index_put_impl_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__indices_copy
torch__indices_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_indices_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__indices_copy_out
torch__indices_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_indices_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__is_all_true
torch__is_all_true <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_is_all_true',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__is_any_true
torch__is_any_true <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_is_any_true',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__is_zerotensor
torch__is_zerotensor <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = '_is_zerotensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_check_errors
torch__linalg_check_errors <- function(info, api_name, is_matrix) {
  args <- mget(x = c("info", "api_name", "is_matrix"))
expected_types <- list(info = "Tensor", api_name = "c10::string_view", is_matrix = "bool")
nd_args <- c("info", "api_name", "is_matrix")
return_types <- list(list("void"))
call_c_function(
fun_name = '_linalg_check_errors',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_det
torch__linalg_det <- function(A) {
  args <- mget(x = c("A"))
expected_types <- list(A = "Tensor")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_det',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_det_out
torch__linalg_det_out <- function(result, LU, pivots, A) {
  args <- mget(x = c("result", "LU", "pivots", "A"))
expected_types <- list(result = "Tensor", LU = "Tensor", pivots = "Tensor", A = "Tensor")
nd_args <- c("result", "LU", "pivots", "A")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_det_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_eigh
torch__linalg_eigh <- function(A, UPLO = "L", compute_v = TRUE) {
  args <- mget(x = c("A", "UPLO", "compute_v"))
expected_types <- list(A = "Tensor", UPLO = "c10::string_view", compute_v = "bool")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_eigh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_eigh_out
torch__linalg_eigh_out <- function(eigenvalues, eigenvectors, A, UPLO = "L", compute_v = TRUE) {
  args <- mget(x = c("eigenvalues", "eigenvectors", "A", "UPLO", "compute_v"))
expected_types <- list(eigenvalues = "Tensor", eigenvectors = "Tensor", A = "Tensor", 
    UPLO = "c10::string_view", compute_v = "bool")
nd_args <- c("eigenvalues", "eigenvectors", "A")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_eigh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_slogdet
torch__linalg_slogdet <- function(A) {
  args <- mget(x = c("A"))
expected_types <- list(A = "Tensor")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_slogdet',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_slogdet_out
torch__linalg_slogdet_out <- function(sign, logabsdet, LU, pivots, A) {
  args <- mget(x = c("sign", "logabsdet", "LU", "pivots", "A"))
expected_types <- list(sign = "Tensor", logabsdet = "Tensor", LU = "Tensor", pivots = "Tensor", 
    A = "Tensor")
nd_args <- c("sign", "logabsdet", "LU", "pivots", "A")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_slogdet_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_solve_ex
torch__linalg_solve_ex <- function(A, B, left = TRUE, check_errors = FALSE) {
  args <- mget(x = c("A", "B", "left", "check_errors"))
expected_types <- list(A = "Tensor", B = "Tensor", left = "bool", check_errors = "bool")
nd_args <- c("A", "B")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_solve_ex',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_solve_ex_out
torch__linalg_solve_ex_out <- function(result, LU, pivots, info, A, B, left = TRUE, check_errors = FALSE) {
  args <- mget(x = c("result", "LU", "pivots", "info", "A", "B", "left", "check_errors"))
expected_types <- list(result = "Tensor", LU = "Tensor", pivots = "Tensor", info = "Tensor", 
    A = "Tensor", B = "Tensor", left = "bool", check_errors = "bool")
nd_args <- c("result", "LU", "pivots", "info", "A", "B")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_solve_ex_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_svd
torch__linalg_svd <- function(A, full_matrices = FALSE, compute_uv = TRUE, driver = NULL) {
  args <- mget(x = c("A", "full_matrices", "compute_uv", "driver"))
expected_types <- list(A = "Tensor", full_matrices = "bool", compute_uv = "bool", 
    driver = "c10::string_view")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_svd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__linalg_svd_out
torch__linalg_svd_out <- function(U, S, Vh, A, full_matrices = FALSE, compute_uv = TRUE, driver = NULL) {
  args <- mget(x = c("U", "S", "Vh", "A", "full_matrices", "compute_uv", "driver"))
expected_types <- list(U = "Tensor", S = "Tensor", Vh = "Tensor", A = "Tensor", 
    full_matrices = "bool", compute_uv = "bool", driver = "c10::string_view")
nd_args <- c("U", "S", "Vh", "A")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_linalg_svd_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__local_scalar_dense
torch__local_scalar_dense <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Scalar'))
call_c_function(
fun_name = '_local_scalar_dense',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__log_softmax
torch__log_softmax <- function(self, dim, half_to_float) {
  args <- mget(x = c("self", "dim", "half_to_float"))
expected_types <- list(self = "Tensor", dim = "int64_t", half_to_float = "bool")
nd_args <- c("self", "dim", "half_to_float")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_log_softmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__log_softmax_backward_data
torch__log_softmax_backward_data <- function(grad_output, output, dim, input_dtype) {
  args <- mget(x = c("grad_output", "output", "dim", "input_dtype"))
expected_types <- list(grad_output = "Tensor", output = "Tensor", dim = "int64_t", 
    input_dtype = "ScalarType")
nd_args <- c("grad_output", "output", "dim", "input_dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_log_softmax_backward_data',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__log_softmax_backward_data_out
torch__log_softmax_backward_data_out <- function(out, grad_output, output, dim, input_dtype) {
  args <- mget(x = c("out", "grad_output", "output", "dim", "input_dtype"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", output = "Tensor", 
    dim = "int64_t", input_dtype = "ScalarType")
nd_args <- c("out", "grad_output", "output", "dim", "input_dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_log_softmax_backward_data_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__log_softmax_out
torch__log_softmax_out <- function(out, self, dim, half_to_float) {
  args <- mget(x = c("out", "self", "dim", "half_to_float"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", half_to_float = "bool")
nd_args <- c("out", "self", "dim", "half_to_float")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_log_softmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__logcumsumexp
torch__logcumsumexp <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = "int64_t")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_logcumsumexp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__logcumsumexp_out
torch__logcumsumexp_out <- function(out, self, dim) {
  args <- mget(x = c("out", "self", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_logcumsumexp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__lstm_mps
torch__lstm_mps <- function(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first) {
  args <- mget(x = c("input", "hx", "params", "has_biases", "num_layers", "dropout", "train", "bidirectional", "batch_first"))
expected_types <- list(input = "Tensor", hx = "TensorList", params = "TensorList", 
    has_biases = "bool", num_layers = "int64_t", dropout = "double", 
    train = "bool", bidirectional = "bool", batch_first = "bool")
nd_args <- c("input", "hx", "params", "has_biases", "num_layers", "dropout", 
"train", "bidirectional", "batch_first")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_lstm_mps',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__lstm_mps_out
torch__lstm_mps_out <- function(out0, out1, out2, out3, out4, out5, input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "out4", "out5", "input", "hx", "params", "has_biases", "num_layers", "dropout", "train", "bidirectional", "batch_first"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    out4 = "Tensor", out5 = "Tensor", input = "Tensor", hx = "TensorList", 
    params = "TensorList", has_biases = "bool", num_layers = "int64_t", 
    dropout = "double", train = "bool", bidirectional = "bool", 
    batch_first = "bool")
nd_args <- c("out0", "out1", "out2", "out3", "out4", "out5", "input", "hx", 
"params", "has_biases", "num_layers", "dropout", "train", "bidirectional", 
"batch_first")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_lstm_mps_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__lu_with_info
torch__lu_with_info <- function(self, pivot = TRUE, check_errors = TRUE) {
  args <- mget(x = c("self", "pivot", "check_errors"))
expected_types <- list(self = "Tensor", pivot = "bool", check_errors = "bool")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_lu_with_info',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__make_dual
torch__make_dual <- function(primal, tangent, level) {
  args <- mget(x = c("primal", "tangent", "level"))
expected_types <- list(primal = "Tensor", tangent = "Tensor", level = "int64_t")
nd_args <- c("primal", "tangent", "level")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_make_dual',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__make_dual_copy
torch__make_dual_copy <- function(primal, tangent, level) {
  args <- mget(x = c("primal", "tangent", "level"))
expected_types <- list(primal = "Tensor", tangent = "Tensor", level = "int64_t")
nd_args <- c("primal", "tangent", "level")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_make_dual_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__make_dual_copy_out
torch__make_dual_copy_out <- function(out, primal, tangent, level) {
  args <- mget(x = c("out", "primal", "tangent", "level"))
expected_types <- list(out = "Tensor", primal = "Tensor", tangent = "Tensor", level = "int64_t")
nd_args <- c("out", "primal", "tangent", "level")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_make_dual_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__make_per_channel_quantized_tensor
torch__make_per_channel_quantized_tensor <- function(self, scale, zero_point, axis) {
  args <- mget(x = c("self", "scale", "zero_point", "axis"))
expected_types <- list(self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    axis = "int64_t")
nd_args <- c("self", "scale", "zero_point", "axis")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_make_per_channel_quantized_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__make_per_channel_quantized_tensor_out
torch__make_per_channel_quantized_tensor_out <- function(out, self, scale, zero_point, axis) {
  args <- mget(x = c("out", "self", "scale", "zero_point", "axis"))
expected_types <- list(out = "Tensor", self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    axis = "int64_t")
nd_args <- c("out", "self", "scale", "zero_point", "axis")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_make_per_channel_quantized_tensor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__make_per_tensor_quantized_tensor
torch__make_per_tensor_quantized_tensor <- function(self, scale, zero_point) {
  args <- mget(x = c("self", "scale", "zero_point"))
expected_types <- list(self = "Tensor", scale = "double", zero_point = "int64_t")
nd_args <- c("self", "scale", "zero_point")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_make_per_tensor_quantized_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__make_per_tensor_quantized_tensor_out
torch__make_per_tensor_quantized_tensor_out <- function(out, self, scale, zero_point) {
  args <- mget(x = c("out", "self", "scale", "zero_point"))
expected_types <- list(out = "Tensor", self = "Tensor", scale = "double", zero_point = "int64_t")
nd_args <- c("out", "self", "scale", "zero_point")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_make_per_tensor_quantized_tensor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__masked_scale
torch__masked_scale <- function(self, mask, scale) {
  args <- mget(x = c("self", "mask", "scale"))
expected_types <- list(self = "Tensor", mask = "Tensor", scale = "double")
nd_args <- c("self", "mask", "scale")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_masked_scale',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__masked_scale_out
torch__masked_scale_out <- function(out, self, mask, scale) {
  args <- mget(x = c("out", "self", "mask", "scale"))
expected_types <- list(out = "Tensor", self = "Tensor", mask = "Tensor", scale = "double")
nd_args <- c("out", "self", "mask", "scale")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_masked_scale_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__masked_softmax
torch__masked_softmax <- function(self, mask, dim = NULL, mask_type = NULL) {
  args <- mget(x = c("self", "mask", "dim", "mask_type"))
expected_types <- list(self = "Tensor", mask = "Tensor", dim = "int64_t", mask_type = "int64_t")
nd_args <- c("self", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_masked_softmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__masked_softmax_backward
torch__masked_softmax_backward <- function(grad_output, output, mask, dim = NULL) {
  args <- mget(x = c("grad_output", "output", "mask", "dim"))
expected_types <- list(grad_output = "Tensor", output = "Tensor", mask = "Tensor", 
    dim = "int64_t")
nd_args <- c("grad_output", "output", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_masked_softmax_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__masked_softmax_backward_out
torch__masked_softmax_backward_out <- function(out, grad_output, output, mask, dim = NULL) {
  args <- mget(x = c("out", "grad_output", "output", "mask", "dim"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", output = "Tensor", 
    mask = "Tensor", dim = "int64_t")
nd_args <- c("out", "grad_output", "output", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_masked_softmax_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__masked_softmax_out
torch__masked_softmax_out <- function(out, self, mask, dim = NULL, mask_type = NULL) {
  args <- mget(x = c("out", "self", "mask", "dim", "mask_type"))
expected_types <- list(out = "Tensor", self = "Tensor", mask = "Tensor", dim = "int64_t", 
    mask_type = "int64_t")
nd_args <- c("out", "self", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_masked_softmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__mkldnn_reshape
torch__mkldnn_reshape <- function(self, shape) {
  args <- mget(x = c("self", "shape"))
expected_types <- list(self = "Tensor", shape = "IntArrayRef")
nd_args <- c("self", "shape")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_mkldnn_reshape',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__mkldnn_reshape_out
torch__mkldnn_reshape_out <- function(out, self, shape) {
  args <- mget(x = c("out", "self", "shape"))
expected_types <- list(out = "Tensor", self = "Tensor", shape = "IntArrayRef")
nd_args <- c("out", "self", "shape")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_mkldnn_reshape_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__mkldnn_transpose
torch__mkldnn_transpose <- function(self, dim0, dim1) {
  args <- mget(x = c("self", "dim0", "dim1"))
expected_types <- list(self = "Tensor", dim0 = "int64_t", dim1 = "int64_t")
nd_args <- c("self", "dim0", "dim1")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_mkldnn_transpose',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__mkldnn_transpose_
torch__mkldnn_transpose_ <- function(self, dim0, dim1) {
  args <- mget(x = c("self", "dim0", "dim1"))
expected_types <- list(self = "Tensor", dim0 = "int64_t", dim1 = "int64_t")
nd_args <- c("self", "dim0", "dim1")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_mkldnn_transpose_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__mkldnn_transpose_out
torch__mkldnn_transpose_out <- function(out, self, dim0, dim1) {
  args <- mget(x = c("out", "self", "dim0", "dim1"))
expected_types <- list(out = "Tensor", self = "Tensor", dim0 = "int64_t", dim1 = "int64_t")
nd_args <- c("out", "self", "dim0", "dim1")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_mkldnn_transpose_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__mps_convolution
torch__mps_convolution <- function(self, weight, bias, padding, stride, dilation, groups) {
  args <- mget(x = c("self", "weight", "bias", "padding", "stride", "dilation", "groups"))
expected_types <- list(self = "Tensor", weight = "Tensor", bias = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t")
nd_args <- c("self", "weight", "bias", "padding", "stride", "dilation", 
"groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_mps_convolution',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__mps_convolution_out
torch__mps_convolution_out <- function(out, self, weight, bias, padding, stride, dilation, groups) {
  args <- mget(x = c("out", "self", "weight", "bias", "padding", "stride", "dilation", "groups"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", bias = "Tensor", 
    padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t")
nd_args <- c("out", "self", "weight", "bias", "padding", "stride", "dilation", 
"groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_mps_convolution_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__mps_convolution_transpose
torch__mps_convolution_transpose <- function(self, weight, padding, output_padding, stride, dilation, groups) {
  args <- mget(x = c("self", "weight", "padding", "output_padding", "stride", "dilation", "groups"))
expected_types <- list(self = "Tensor", weight = "Tensor", padding = "IntArrayRef", 
    output_padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t")
nd_args <- c("self", "weight", "padding", "output_padding", "stride", "dilation", 
"groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_mps_convolution_transpose',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__mps_convolution_transpose_out
torch__mps_convolution_transpose_out <- function(out, self, weight, padding, output_padding, stride, dilation, groups) {
  args <- mget(x = c("out", "self", "weight", "padding", "output_padding", "stride", "dilation", "groups"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", padding = "IntArrayRef", 
    output_padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t")
nd_args <- c("out", "self", "weight", "padding", "output_padding", "stride", 
"dilation", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_mps_convolution_transpose_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__native_batch_norm_legit
torch__native_batch_norm_legit <- function(input, weight, bias, running_mean, running_var, training, momentum, eps) {
  args <- mget(x = c("input", "weight", "bias", "running_mean", "running_var", "training", "momentum", "eps"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", momentum = "double", 
    eps = "double")
nd_args <- c("input", "weight", "bias", "running_mean", "running_var", "training", 
"momentum", "eps")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_native_batch_norm_legit',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__native_batch_norm_legit_functional
torch__native_batch_norm_legit_functional <- function(input, weight, bias, running_mean, running_var, training, momentum, eps) {
  args <- mget(x = c("input", "weight", "bias", "running_mean", "running_var", "training", "momentum", "eps"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", momentum = "double", 
    eps = "double")
nd_args <- c("input", "weight", "bias", "running_mean", "running_var", "training", 
"momentum", "eps")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_native_batch_norm_legit_functional',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__native_batch_norm_legit_out
torch__native_batch_norm_legit_out <- function(out, save_mean, save_invstd, input, weight, bias, running_mean, running_var, training, momentum, eps) {
  args <- mget(x = c("out", "save_mean", "save_invstd", "input", "weight", "bias", "running_mean", "running_var", "training", "momentum", "eps"))
expected_types <- list(out = "Tensor", save_mean = "Tensor", save_invstd = "Tensor", 
    input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", momentum = "double", 
    eps = "double")
nd_args <- c("out", "save_mean", "save_invstd", "input", "weight", "bias", 
"running_mean", "running_var", "training", "momentum", "eps")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_native_batch_norm_legit_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__native_decoder_only_multi_head_attention
torch__native_decoder_only_multi_head_attention <- function(query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask = list(), incr_key = list(), incr_value = list(), need_weights = TRUE, average_attn_weights = TRUE) {
  args <- mget(x = c("query", "key", "value", "embed_dim", "num_head", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "mask", "incr_key", "incr_value", "need_weights", "average_attn_weights"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", embed_dim = "int64_t", 
    num_head = "int64_t", qkv_weight = "Tensor", qkv_bias = "Tensor", 
    proj_weight = "Tensor", proj_bias = "Tensor", mask = "Tensor", 
    incr_key = "Tensor", incr_value = "Tensor", need_weights = "bool", 
    average_attn_weights = "bool")
nd_args <- c("query", "key", "value", "embed_dim", "num_head", "qkv_weight", 
"qkv_bias", "proj_weight", "proj_bias")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_native_decoder_only_multi_head_attention',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__native_decoder_only_multi_head_attention_out
torch__native_decoder_only_multi_head_attention_out <- function(out0, out1, out2, out3, query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask = list(), incr_key = list(), incr_value = list(), need_weights = TRUE, average_attn_weights = TRUE) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "query", "key", "value", "embed_dim", "num_head", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "mask", "incr_key", "incr_value", "need_weights", "average_attn_weights"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    query = "Tensor", key = "Tensor", value = "Tensor", embed_dim = "int64_t", 
    num_head = "int64_t", qkv_weight = "Tensor", qkv_bias = "Tensor", 
    proj_weight = "Tensor", proj_bias = "Tensor", mask = "Tensor", 
    incr_key = "Tensor", incr_value = "Tensor", need_weights = "bool", 
    average_attn_weights = "bool")
nd_args <- c("out0", "out1", "out2", "out3", "query", "key", "value", "embed_dim", 
"num_head", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias"
)
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_native_decoder_only_multi_head_attention_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__native_multi_head_attention
torch__native_multi_head_attention <- function(query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask = list(), need_weights = TRUE, average_attn_weights = TRUE, mask_type = NULL) {
  args <- mget(x = c("query", "key", "value", "embed_dim", "num_head", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "mask", "need_weights", "average_attn_weights", "mask_type"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", embed_dim = "int64_t", 
    num_head = "int64_t", qkv_weight = "Tensor", qkv_bias = "Tensor", 
    proj_weight = "Tensor", proj_bias = "Tensor", mask = "Tensor", 
    need_weights = "bool", average_attn_weights = "bool", mask_type = "int64_t")
nd_args <- c("query", "key", "value", "embed_dim", "num_head", "qkv_weight", 
"qkv_bias", "proj_weight", "proj_bias")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_native_multi_head_attention',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__native_multi_head_attention_out
torch__native_multi_head_attention_out <- function(out0, out1, query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask = list(), need_weights = TRUE, average_attn_weights = TRUE, mask_type = NULL) {
  args <- mget(x = c("out0", "out1", "query", "key", "value", "embed_dim", "num_head", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "mask", "need_weights", "average_attn_weights", "mask_type"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", query = "Tensor", key = "Tensor", 
    value = "Tensor", embed_dim = "int64_t", num_head = "int64_t", 
    qkv_weight = "Tensor", qkv_bias = "Tensor", proj_weight = "Tensor", 
    proj_bias = "Tensor", mask = "Tensor", need_weights = "bool", 
    average_attn_weights = "bool", mask_type = "int64_t")
nd_args <- c("out0", "out1", "query", "key", "value", "embed_dim", "num_head", 
"qkv_weight", "qkv_bias", "proj_weight", "proj_bias")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_native_multi_head_attention_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__neg_view
torch__neg_view <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_neg_view',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__neg_view_copy
torch__neg_view_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_neg_view_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__neg_view_copy_out
torch__neg_view_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_neg_view_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_from_padded
torch__nested_from_padded <- function(padded, cpu_nested_shape_example, fuse_transform_0213 = FALSE) {
  args <- mget(x = c("padded", "cpu_nested_shape_example", "fuse_transform_0213"))
expected_types <- list(padded = "Tensor", cpu_nested_shape_example = "Tensor", 
    fuse_transform_0213 = "bool")
nd_args <- c("padded", "cpu_nested_shape_example")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_from_padded',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_from_padded_and_nested_example
torch__nested_from_padded_and_nested_example <- function(padded, nt_example) {
  args <- mget(x = c("padded", "nt_example"))
expected_types <- list(padded = "Tensor", nt_example = "Tensor")
nd_args <- c("padded", "nt_example")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_from_padded_and_nested_example',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_from_padded_and_nested_example_out
torch__nested_from_padded_and_nested_example_out <- function(out, padded, nt_example) {
  args <- mget(x = c("out", "padded", "nt_example"))
expected_types <- list(out = "Tensor", padded = "Tensor", nt_example = "Tensor")
nd_args <- c("out", "padded", "nt_example")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_from_padded_and_nested_example_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_from_padded_out
torch__nested_from_padded_out <- function(out, padded, cpu_nested_shape_example, fuse_transform_0213 = FALSE) {
  args <- mget(x = c("out", "padded", "cpu_nested_shape_example", "fuse_transform_0213"))
expected_types <- list(out = "Tensor", padded = "Tensor", cpu_nested_shape_example = "Tensor", 
    fuse_transform_0213 = "bool")
nd_args <- c("out", "padded", "cpu_nested_shape_example")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_from_padded_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_select_backward
torch__nested_select_backward <- function(grad_output, self, dim, index) {
  args <- mget(x = c("grad_output", "self", "dim", "index"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", dim = "int64_t", 
    index = "int64_t")
nd_args <- c("grad_output", "self", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_select_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_sum_backward
torch__nested_sum_backward <- function(grad, self, dim, keepdim = FALSE) {
  args <- mget(x = c("grad", "self", "dim", "keepdim"))
expected_types <- list(grad = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- c("grad", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_sum_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_tensor_from_mask
torch__nested_tensor_from_mask <- function(t, mask, mask_check = TRUE) {
  args <- mget(x = c("t", "mask", "mask_check"))
expected_types <- list(t = "Tensor", mask = "Tensor", mask_check = "bool")
nd_args <- c("t", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_tensor_from_mask',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_tensor_from_mask_left_aligned
torch__nested_tensor_from_mask_left_aligned <- function(t, mask) {
  args <- mget(x = c("t", "mask"))
expected_types <- list(t = "Tensor", mask = "Tensor")
nd_args <- c("t", "mask")
return_types <- list(list('bool'))
call_c_function(
fun_name = '_nested_tensor_from_mask_left_aligned',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_tensor_from_mask_out
torch__nested_tensor_from_mask_out <- function(out, t, mask, mask_check = TRUE) {
  args <- mget(x = c("out", "t", "mask", "mask_check"))
expected_types <- list(out = "Tensor", t = "Tensor", mask = "Tensor", mask_check = "bool")
nd_args <- c("out", "t", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_tensor_from_mask_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_tensor_from_tensor_list
torch__nested_tensor_from_tensor_list <- function(list, dtype = NULL, layout = NULL, device = NULL, pin_memory = NULL) {
  args <- mget(x = c("list", "dtype", "layout", "device", "pin_memory"))
expected_types <- list(list = "TensorList", dtype = "ScalarType", layout = "Layout", 
    device = "Device", pin_memory = "bool")
nd_args <- "list"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_tensor_from_tensor_list',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_tensor_from_tensor_list_out
torch__nested_tensor_from_tensor_list_out <- function(out, list, dtype = NULL, layout = NULL, device = NULL, pin_memory = NULL) {
  args <- mget(x = c("out", "list", "dtype", "layout", "device", "pin_memory"))
expected_types <- list(out = "Tensor", list = "TensorList", dtype = "ScalarType", 
    layout = "Layout", device = "Device", pin_memory = "bool")
nd_args <- c("out", "list")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_tensor_from_tensor_list_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_tensor_size_out
torch__nested_tensor_size_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_tensor_size_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_tensor_softmax_with_shape
torch__nested_tensor_softmax_with_shape <- function(self, query) {
  args <- mget(x = c("self", "query"))
expected_types <- list(self = "Tensor", query = "Tensor")
nd_args <- c("self", "query")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_tensor_softmax_with_shape',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_tensor_strides_out
torch__nested_tensor_strides_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_tensor_strides_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_view_from_buffer
torch__nested_view_from_buffer <- function(self, nested_size, nested_strides, offsets) {
  args <- mget(x = c("self", "nested_size", "nested_strides", "offsets"))
expected_types <- list(self = "Tensor", nested_size = "Tensor", nested_strides = "Tensor", 
    offsets = "IntArrayRef")
nd_args <- c("self", "nested_size", "nested_strides", "offsets")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_view_from_buffer',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_view_from_buffer_copy
torch__nested_view_from_buffer_copy <- function(self, nested_size, nested_strides, offsets) {
  args <- mget(x = c("self", "nested_size", "nested_strides", "offsets"))
expected_types <- list(self = "Tensor", nested_size = "Tensor", nested_strides = "Tensor", 
    offsets = "IntArrayRef")
nd_args <- c("self", "nested_size", "nested_strides", "offsets")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_view_from_buffer_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nested_view_from_buffer_copy_out
torch__nested_view_from_buffer_copy_out <- function(out, self, nested_size, nested_strides, offsets) {
  args <- mget(x = c("out", "self", "nested_size", "nested_strides", "offsets"))
expected_types <- list(out = "Tensor", self = "Tensor", nested_size = "Tensor", 
    nested_strides = "Tensor", offsets = "IntArrayRef")
nd_args <- c("out", "self", "nested_size", "nested_strides", "offsets")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nested_view_from_buffer_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__new_zeros_with_same_feature_meta
torch__new_zeros_with_same_feature_meta <- function(self, other, self_num_batch_dims = 0L) {
  args <- mget(x = c("self", "other", "self_num_batch_dims"))
expected_types <- list(self = "Tensor", other = "Tensor", self_num_batch_dims = "int64_t")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_new_zeros_with_same_feature_meta',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__new_zeros_with_same_feature_meta_out
torch__new_zeros_with_same_feature_meta_out <- function(out, self, other, self_num_batch_dims = 0L) {
  args <- mget(x = c("out", "self", "other", "self_num_batch_dims"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor", self_num_batch_dims = "int64_t")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_new_zeros_with_same_feature_meta_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nnpack_spatial_convolution
torch__nnpack_spatial_convolution <- function(input, weight, bias, padding, stride = 1L) {
  args <- mget(x = c("input", "weight", "bias", "padding", "stride"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef")
nd_args <- c("input", "weight", "bias", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nnpack_spatial_convolution',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__nnpack_spatial_convolution_out
torch__nnpack_spatial_convolution_out <- function(out, input, weight, bias, padding, stride = 1L) {
  args <- mget(x = c("out", "input", "weight", "bias", "padding", "stride"))
expected_types <- list(out = "Tensor", input = "Tensor", weight = "Tensor", bias = "Tensor", 
    padding = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("out", "input", "weight", "bias", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_nnpack_spatial_convolution_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pack_padded_sequence
torch__pack_padded_sequence <- function(input, lengths, batch_first) {
  args <- mget(x = c("input", "lengths", "batch_first"))
expected_types <- list(input = "Tensor", lengths = "Tensor", batch_first = "bool")
nd_args <- c("input", "lengths", "batch_first")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_pack_padded_sequence',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pack_padded_sequence_backward
torch__pack_padded_sequence_backward <- function(grad, input_size, batch_sizes, batch_first) {
  args <- mget(x = c("grad", "input_size", "batch_sizes", "batch_first"))
expected_types <- list(grad = "Tensor", input_size = "IntArrayRef", batch_sizes = "Tensor", 
    batch_first = "bool")
nd_args <- c("grad", "input_size", "batch_sizes", "batch_first")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_pack_padded_sequence_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pack_padded_sequence_out
torch__pack_padded_sequence_out <- function(out0, out1, input, lengths, batch_first) {
  args <- mget(x = c("out0", "out1", "input", "lengths", "batch_first"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", input = "Tensor", lengths = "Tensor", 
    batch_first = "bool")
nd_args <- c("out0", "out1", "input", "lengths", "batch_first")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_pack_padded_sequence_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pad_circular
torch__pad_circular <- function(self, pad) {
  args <- mget(x = c("self", "pad"))
expected_types <- list(self = "Tensor", pad = "IntArrayRef")
nd_args <- c("self", "pad")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_pad_circular',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pad_enum
torch__pad_enum <- function(self, pad, mode, value = NULL) {
  args <- mget(x = c("self", "pad", "mode", "value"))
expected_types <- list(self = "Tensor", pad = "IntArrayRef", mode = "int64_t", 
    value = "double")
nd_args <- c("self", "pad", "mode")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_pad_enum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pad_packed_sequence
torch__pad_packed_sequence <- function(data, batch_sizes, batch_first, padding_value, total_length) {
  args <- mget(x = c("data", "batch_sizes", "batch_first", "padding_value", "total_length"))
expected_types <- list(data = "Tensor", batch_sizes = "Tensor", batch_first = "bool", 
    padding_value = "Scalar", total_length = "int64_t")
nd_args <- c("data", "batch_sizes", "batch_first", "padding_value", "total_length"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_pad_packed_sequence',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pdist_backward
torch__pdist_backward <- function(grad, self, p, pdist) {
  args <- mget(x = c("grad", "self", "p", "pdist"))
expected_types <- list(grad = "Tensor", self = "Tensor", p = "double", pdist = "Tensor")
nd_args <- c("grad", "self", "p", "pdist")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_pdist_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pdist_backward_out
torch__pdist_backward_out <- function(out, grad, self, p, pdist) {
  args <- mget(x = c("out", "grad", "self", "p", "pdist"))
expected_types <- list(out = "Tensor", grad = "Tensor", self = "Tensor", p = "double", 
    pdist = "Tensor")
nd_args <- c("out", "grad", "self", "p", "pdist")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_pdist_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pdist_forward
torch__pdist_forward <- function(self, p = 2L) {
  args <- mget(x = c("self", "p"))
expected_types <- list(self = "Tensor", p = "double")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_pdist_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pdist_forward_out
torch__pdist_forward_out <- function(out, self, p = 2L) {
  args <- mget(x = c("out", "self", "p"))
expected_types <- list(out = "Tensor", self = "Tensor", p = "double")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_pdist_forward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pin_memory
torch__pin_memory <- function(self, device = NULL) {
  args <- mget(x = c("self", "device"))
expected_types <- list(self = "Tensor", device = "Device")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_pin_memory',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__pin_memory_out
torch__pin_memory_out <- function(out, self, device = NULL) {
  args <- mget(x = c("out", "self", "device"))
expected_types <- list(out = "Tensor", self = "Tensor", device = "Device")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_pin_memory_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__prelu_kernel
torch__prelu_kernel <- function(self, weight) {
  args <- mget(x = c("self", "weight"))
expected_types <- list(self = "Tensor", weight = "Tensor")
nd_args <- c("self", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_prelu_kernel',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__prelu_kernel_backward
torch__prelu_kernel_backward <- function(grad_output, self, weight) {
  args <- mget(x = c("grad_output", "self", "weight"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", weight = "Tensor")
nd_args <- c("grad_output", "self", "weight")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_prelu_kernel_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__remove_batch_dim
torch__remove_batch_dim <- function(self, level, batch_size, out_dim) {
  args <- mget(x = c("self", "level", "batch_size", "out_dim"))
expected_types <- list(self = "Tensor", level = "int64_t", batch_size = "int64_t", 
    out_dim = "int64_t")
nd_args <- c("self", "level", "batch_size", "out_dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_remove_batch_dim',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__reshape_alias
torch__reshape_alias <- function(self, size, stride) {
  args <- mget(x = c("self", "size", "stride"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("self", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_reshape_alias',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__reshape_alias_copy
torch__reshape_alias_copy <- function(self, size, stride) {
  args <- mget(x = c("self", "size", "stride"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("self", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_reshape_alias_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__reshape_alias_copy_out
torch__reshape_alias_copy_out <- function(out, self, size, stride) {
  args <- mget(x = c("out", "self", "size", "stride"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("out", "self", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_reshape_alias_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__reshape_copy
torch__reshape_copy <- function(self, size) {
  args <- mget(x = c("self", "size"))
expected_types <- list(self = "Tensor", size = "IntArrayRef")
nd_args <- c("self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_reshape_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__reshape_from_tensor
torch__reshape_from_tensor <- function(self, shape) {
  args <- mget(x = c("self", "shape"))
expected_types <- list(self = "Tensor", shape = "Tensor")
nd_args <- c("self", "shape")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_reshape_from_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__resize_output
torch__resize_output <- function(self, size, device) {
  args <- mget(x = c("self", "size", "device"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", device = "Device")
nd_args <- c("self", "size", "device")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_resize_output',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__resize_output_
torch__resize_output_ <- function(self, size, device) {
  args <- mget(x = c("self", "size", "device"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", device = "Device")
nd_args <- c("self", "size", "device")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_resize_output_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__resize_output_out
torch__resize_output_out <- function(out, self, size, device) {
  args <- mget(x = c("out", "self", "size", "device"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef", device = "Device")
nd_args <- c("out", "self", "size", "device")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_resize_output_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__rowwise_prune
torch__rowwise_prune <- function(weight, mask, compressed_indices_dtype) {
  args <- mget(x = c("weight", "mask", "compressed_indices_dtype"))
expected_types <- list(weight = "Tensor", mask = "Tensor", compressed_indices_dtype = "ScalarType")
nd_args <- c("weight", "mask", "compressed_indices_dtype")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_rowwise_prune',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sample_dirichlet
torch__sample_dirichlet <- function(self, generator = NULL) {
  args <- mget(x = c("self", "generator"))
expected_types <- list(self = "Tensor", generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sample_dirichlet',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sample_dirichlet_out
torch__sample_dirichlet_out <- function(out, self, generator = NULL) {
  args <- mget(x = c("out", "self", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", generator = "Generator")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sample_dirichlet_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__saturate_weight_to_fp16
torch__saturate_weight_to_fp16 <- function(weight) {
  args <- mget(x = c("weight"))
expected_types <- list(weight = "Tensor")
nd_args <- "weight"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_saturate_weight_to_fp16',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__scaled_dot_product_attention
torch__scaled_dot_product_attention <- function(query, key, value, attn_mask = list(), dropout_p = 0L, need_attn_weights = FALSE, is_causal = FALSE) {
  args <- mget(x = c("query", "key", "value", "attn_mask", "dropout_p", "need_attn_weights", "is_causal"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", attn_mask = "Tensor", 
    dropout_p = "double", need_attn_weights = "bool", is_causal = "bool")
nd_args <- c("query", "key", "value")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_scaled_dot_product_attention',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__scaled_dot_product_attention_math
torch__scaled_dot_product_attention_math <- function(query, key, value, attn_mask = list(), dropout_p = 0L, is_causal = FALSE, dropout_mask = list()) {
  args <- mget(x = c("query", "key", "value", "attn_mask", "dropout_p", "is_causal", "dropout_mask"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", attn_mask = "Tensor", 
    dropout_p = "double", is_causal = "bool", dropout_mask = "Tensor")
nd_args <- c("query", "key", "value")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_scaled_dot_product_attention_math',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__scaled_dot_product_efficient_attention
torch__scaled_dot_product_efficient_attention <- function(query, key, value, compute_log_sumexp, is_causal = FALSE) {
  args <- mget(x = c("query", "key", "value", "compute_log_sumexp", "is_causal"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", compute_log_sumexp = "bool", 
    is_causal = "bool")
nd_args <- c("query", "key", "value", "compute_log_sumexp")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_scaled_dot_product_efficient_attention',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__scaled_dot_product_efficient_attention_backward
torch__scaled_dot_product_efficient_attention_backward <- function(grad_out_, query, key, value, out, logsumexp, is_causal = FALSE, chunk_grad_outputs = FALSE) {
  args <- mget(x = c("grad_out_", "query", "key", "value", "out", "logsumexp", "is_causal", "chunk_grad_outputs"))
expected_types <- list(grad_out_ = "Tensor", query = "Tensor", key = "Tensor", 
    value = "Tensor", out = "Tensor", logsumexp = "Tensor", is_causal = "bool", 
    chunk_grad_outputs = "bool")
nd_args <- c("grad_out_", "query", "key", "value", "out", "logsumexp")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_scaled_dot_product_efficient_attention_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__scaled_dot_product_flash_attention
torch__scaled_dot_product_flash_attention <- function(query, key, value, dropout_p = 0L, is_causal = FALSE, return_debug_mask = FALSE) {
  args <- mget(x = c("query", "key", "value", "dropout_p", "is_causal", "return_debug_mask"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", dropout_p = "double", 
    is_causal = "bool", return_debug_mask = "bool")
nd_args <- c("query", "key", "value")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "int64_t", "int64_t",     "int64_t", "int64_t", "Tensor"))
call_c_function(
fun_name = '_scaled_dot_product_flash_attention',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__scaled_dot_product_flash_attention_backward
torch__scaled_dot_product_flash_attention_backward <- function(grad_out, query, key, value, out, logsumexp, cum_seq_q, cum_seq_k, max_q, max_k, dropout_p, is_causal, philox_seed, philox_offset) {
  args <- mget(x = c("grad_out", "query", "key", "value", "out", "logsumexp", "cum_seq_q", "cum_seq_k", "max_q", "max_k", "dropout_p", "is_causal", "philox_seed", "philox_offset"))
expected_types <- list(grad_out = "Tensor", query = "Tensor", key = "Tensor", value = "Tensor", 
    out = "Tensor", logsumexp = "Tensor", cum_seq_q = "Tensor", 
    cum_seq_k = "Tensor", max_q = "int64_t", max_k = "int64_t", 
    dropout_p = "double", is_causal = "bool", philox_seed = "int64_t", 
    philox_offset = "int64_t")
nd_args <- c("grad_out", "query", "key", "value", "out", "logsumexp", "cum_seq_q", 
"cum_seq_k", "max_q", "max_k", "dropout_p", "is_causal", "philox_seed", 
"philox_offset")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_scaled_dot_product_flash_attention_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__segment_reduce_backward
torch__segment_reduce_backward <- function(grad, output, data, reduce, lengths = list(), offsets = list(), axis = 0L, initial = NULL) {
  args <- mget(x = c("grad", "output", "data", "reduce", "lengths", "offsets", "axis", "initial"))
expected_types <- list(grad = "Tensor", output = "Tensor", data = "Tensor", reduce = "c10::string_view", 
    lengths = "Tensor", offsets = "Tensor", axis = "int64_t", 
    initial = "Scalar")
nd_args <- c("grad", "output", "data", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_segment_reduce_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__segment_reduce_backward_out
torch__segment_reduce_backward_out <- function(out, grad, output, data, reduce, lengths = list(), offsets = list(), axis = 0L, initial = NULL) {
  args <- mget(x = c("out", "grad", "output", "data", "reduce", "lengths", "offsets", "axis", "initial"))
expected_types <- list(out = "Tensor", grad = "Tensor", output = "Tensor", data = "Tensor", 
    reduce = "c10::string_view", lengths = "Tensor", offsets = "Tensor", 
    axis = "int64_t", initial = "Scalar")
nd_args <- c("out", "grad", "output", "data", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_segment_reduce_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__shape_as_tensor
torch__shape_as_tensor <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_shape_as_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__slow_conv2d_backward
torch__slow_conv2d_backward <- function(grad_output, self, weight, kernel_size, stride, padding, output_mask) {
  args <- mget(x = c("grad_output", "self", "weight", "kernel_size", "stride", "padding", "output_mask"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", weight = "Tensor", 
    kernel_size = "IntArrayRef", stride = "IntArrayRef", padding = "IntArrayRef", 
    output_mask = "::std::array<bool,3>")
nd_args <- c("grad_output", "self", "weight", "kernel_size", "stride", "padding", 
"output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_slow_conv2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__slow_conv2d_backward_out
torch__slow_conv2d_backward_out <- function(grad_input, out0, grad_weight, out1, grad_bias, out2, grad_output, self, weight, kernel_size, stride, padding, output_mask) {
  args <- mget(x = c("grad_input", "out0", "grad_weight", "out1", "grad_bias", "out2", "grad_output", "self", "weight", "kernel_size", "stride", "padding", "output_mask"))
expected_types <- list(grad_input = "Tensor", out0 = "Tensor", grad_weight = "Tensor", 
    out1 = "Tensor", grad_bias = "Tensor", out2 = "Tensor", grad_output = "Tensor", 
    self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", output_mask = "::std::array<bool,3>")
nd_args <- c("grad_input", "out0", "grad_weight", "out1", "grad_bias", "out2", 
"grad_output", "self", "weight", "kernel_size", "stride", "padding", 
"output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_slow_conv2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__slow_conv2d_forward
torch__slow_conv2d_forward <- function(self, weight, kernel_size, bias, stride, padding) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size", "bias", "stride", "padding"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_slow_conv2d_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__slow_conv2d_forward_out
torch__slow_conv2d_forward_out <- function(output, self, weight, kernel_size, bias, stride, padding) {
  args <- mget(x = c("output", "self", "weight", "kernel_size", "bias", "stride", "padding"))
expected_types <- list(output = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("output", "self", "weight", "kernel_size", "bias", "stride", 
"padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_slow_conv2d_forward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sobol_engine_draw
torch__sobol_engine_draw <- function(quasi, n, sobolstate, dimension, num_generated, dtype) {
  args <- mget(x = c("quasi", "n", "sobolstate", "dimension", "num_generated", "dtype"))
expected_types <- list(quasi = "Tensor", n = "int64_t", sobolstate = "Tensor", 
    dimension = "int64_t", num_generated = "int64_t", dtype = "ScalarType")
nd_args <- c("quasi", "n", "sobolstate", "dimension", "num_generated", "dtype"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_sobol_engine_draw',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sobol_engine_ff_
torch__sobol_engine_ff_ <- function(self, n, sobolstate, dimension, num_generated) {
  args <- mget(x = c("self", "n", "sobolstate", "dimension", "num_generated"))
expected_types <- list(self = "Tensor", n = "int64_t", sobolstate = "Tensor", dimension = "int64_t", 
    num_generated = "int64_t")
nd_args <- c("self", "n", "sobolstate", "dimension", "num_generated")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sobol_engine_ff_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sobol_engine_initialize_state_
torch__sobol_engine_initialize_state_ <- function(self, dimension) {
  args <- mget(x = c("self", "dimension"))
expected_types <- list(self = "Tensor", dimension = "int64_t")
nd_args <- c("self", "dimension")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sobol_engine_initialize_state_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sobol_engine_scramble_
torch__sobol_engine_scramble_ <- function(self, ltm, dimension) {
  args <- mget(x = c("self", "ltm", "dimension"))
expected_types <- list(self = "Tensor", ltm = "Tensor", dimension = "int64_t")
nd_args <- c("self", "ltm", "dimension")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sobol_engine_scramble_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__softmax
torch__softmax <- function(self, dim, half_to_float) {
  args <- mget(x = c("self", "dim", "half_to_float"))
expected_types <- list(self = "Tensor", dim = "int64_t", half_to_float = "bool")
nd_args <- c("self", "dim", "half_to_float")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_softmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__softmax_backward_data
torch__softmax_backward_data <- function(grad_output, output, dim, input_dtype) {
  args <- mget(x = c("grad_output", "output", "dim", "input_dtype"))
expected_types <- list(grad_output = "Tensor", output = "Tensor", dim = "int64_t", 
    input_dtype = "ScalarType")
nd_args <- c("grad_output", "output", "dim", "input_dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_softmax_backward_data',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__softmax_backward_data_out
torch__softmax_backward_data_out <- function(grad_input, grad_output, output, dim, input_dtype) {
  args <- mget(x = c("grad_input", "grad_output", "output", "dim", "input_dtype"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output = "Tensor", 
    dim = "int64_t", input_dtype = "ScalarType")
nd_args <- c("grad_input", "grad_output", "output", "dim", "input_dtype"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_softmax_backward_data_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__softmax_out
torch__softmax_out <- function(out, self, dim, half_to_float) {
  args <- mget(x = c("out", "self", "dim", "half_to_float"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", half_to_float = "bool")
nd_args <- c("out", "self", "dim", "half_to_float")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_softmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_addmm
torch__sparse_addmm <- function(self, mat1, mat2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("self", "mat1", "mat2", "beta", "alpha"))
expected_types <- list(self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", beta = "Scalar", 
    alpha = "Scalar")
nd_args <- c("self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_addmm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_addmm_out
torch__sparse_addmm_out <- function(out, self, mat1, mat2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("out", "self", "mat1", "mat2", "beta", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", 
    beta = "Scalar", alpha = "Scalar")
nd_args <- c("out", "self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_addmm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_broadcast_to
torch__sparse_broadcast_to <- function(self, size) {
  args <- mget(x = c("self", "size"))
expected_types <- list(self = "Tensor", size = "IntArrayRef")
nd_args <- c("self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_broadcast_to',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_broadcast_to_copy
torch__sparse_broadcast_to_copy <- function(self, size) {
  args <- mget(x = c("self", "size"))
expected_types <- list(self = "Tensor", size = "IntArrayRef")
nd_args <- c("self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_broadcast_to_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_broadcast_to_copy_out
torch__sparse_broadcast_to_copy_out <- function(out, self, size) {
  args <- mget(x = c("out", "self", "size"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef")
nd_args <- c("out", "self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_broadcast_to_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_bsc_tensor_unsafe
torch__sparse_bsc_tensor_unsafe <- function(ccol_indices, row_indices, values, size, options = list()) {
  args <- mget(x = c("ccol_indices", "row_indices", "values", "size", "options"))
expected_types <- list(ccol_indices = "Tensor", row_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("ccol_indices", "row_indices", "values", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_bsc_tensor_unsafe',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_bsr_tensor_unsafe
torch__sparse_bsr_tensor_unsafe <- function(crow_indices, col_indices, values, size, options = list()) {
  args <- mget(x = c("crow_indices", "col_indices", "values", "size", "options"))
expected_types <- list(crow_indices = "Tensor", col_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("crow_indices", "col_indices", "values", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_bsr_tensor_unsafe',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_compressed_tensor_unsafe
torch__sparse_compressed_tensor_unsafe <- function(compressed_indices, plain_indices, values, size, options = list()) {
  args <- mget(x = c("compressed_indices", "plain_indices", "values", "size", "options"))
expected_types <- list(compressed_indices = "Tensor", plain_indices = "Tensor", 
    values = "Tensor", size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("compressed_indices", "plain_indices", "values", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_compressed_tensor_unsafe',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_coo_tensor_unsafe
torch__sparse_coo_tensor_unsafe <- function(indices, values, size, options = list()) {
  args <- mget(x = c("indices", "values", "size", "options"))
expected_types <- list(indices = "Tensor", values = "Tensor", size = "IntArrayRef", 
    options = "TensorOptions")
nd_args <- c("indices", "values", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_coo_tensor_unsafe',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_coo_tensor_with_dims
torch__sparse_coo_tensor_with_dims <- function(sparse_dim, dense_dim, size, options) {
  args <- mget(x = c("sparse_dim", "dense_dim", "size", "options"))
expected_types <- list(sparse_dim = "int64_t", dense_dim = "int64_t", size = "IntArrayRef", 
    options = "TensorOptions")
nd_args <- c("sparse_dim", "dense_dim", "size", "options")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_coo_tensor_with_dims',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_coo_tensor_with_dims_and_tensors
torch__sparse_coo_tensor_with_dims_and_tensors <- function(sparse_dim, dense_dim, size, indices, values, options) {
  args <- mget(x = c("sparse_dim", "dense_dim", "size", "indices", "values", "options"))
expected_types <- list(sparse_dim = "int64_t", dense_dim = "int64_t", size = "IntArrayRef", 
    indices = "Tensor", values = "Tensor", options = "TensorOptions")
nd_args <- c("sparse_dim", "dense_dim", "size", "indices", "values", "options"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_coo_tensor_with_dims_and_tensors',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_coo_tensor_with_dims_and_tensors_out
torch__sparse_coo_tensor_with_dims_and_tensors_out <- function(out, sparse_dim, dense_dim, size, indices, values) {
  args <- mget(x = c("out", "sparse_dim", "dense_dim", "size", "indices", "values"))
expected_types <- list(out = "Tensor", sparse_dim = "int64_t", dense_dim = "int64_t", 
    size = "IntArrayRef", indices = "Tensor", values = "Tensor")
nd_args <- c("out", "sparse_dim", "dense_dim", "size", "indices", "values"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_coo_tensor_with_dims_and_tensors_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_coo_tensor_with_dims_out
torch__sparse_coo_tensor_with_dims_out <- function(out, sparse_dim, dense_dim, size) {
  args <- mget(x = c("out", "sparse_dim", "dense_dim", "size"))
expected_types <- list(out = "Tensor", sparse_dim = "int64_t", dense_dim = "int64_t", 
    size = "IntArrayRef")
nd_args <- c("out", "sparse_dim", "dense_dim", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_coo_tensor_with_dims_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_csc_tensor_unsafe
torch__sparse_csc_tensor_unsafe <- function(ccol_indices, row_indices, values, size, options = list()) {
  args <- mget(x = c("ccol_indices", "row_indices", "values", "size", "options"))
expected_types <- list(ccol_indices = "Tensor", row_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("ccol_indices", "row_indices", "values", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_csc_tensor_unsafe',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_csr_prod
torch__sparse_csr_prod <- function(self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_csr_prod',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_csr_prod_out
torch__sparse_csr_prod_out <- function(out, self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_csr_prod_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_csr_sum
torch__sparse_csr_sum <- function(self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_csr_sum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_csr_sum_out
torch__sparse_csr_sum_out <- function(out, self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_csr_sum_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_csr_tensor_unsafe
torch__sparse_csr_tensor_unsafe <- function(crow_indices, col_indices, values, size, options = list()) {
  args <- mget(x = c("crow_indices", "col_indices", "values", "size", "options"))
expected_types <- list(crow_indices = "Tensor", col_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("crow_indices", "col_indices", "values", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_csr_tensor_unsafe',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_log_softmax
torch__sparse_log_softmax <- function(self, dim, dtype = NULL, half_to_float) {
  args <- mget(x = c("self", "dim", "dtype", "half_to_float"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), dtype = "ScalarType", 
    half_to_float = "bool")
nd_args <- c("self", "dim", "half_to_float")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_log_softmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_log_softmax_backward_data
torch__sparse_log_softmax_backward_data <- function(grad_output, output, dim, self) {
  args <- mget(x = c("grad_output", "output", "dim", "self"))
expected_types <- list(grad_output = "Tensor", output = "Tensor", dim = "int64_t", 
    self = "Tensor")
nd_args <- c("grad_output", "output", "dim", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_log_softmax_backward_data',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_log_softmax_backward_data_out
torch__sparse_log_softmax_backward_data_out <- function(out, grad_output, output, dim, self) {
  args <- mget(x = c("out", "grad_output", "output", "dim", "self"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", output = "Tensor", 
    dim = "int64_t", self = "Tensor")
nd_args <- c("out", "grad_output", "output", "dim", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_log_softmax_backward_data_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_log_softmax_out
torch__sparse_log_softmax_out <- function(out, self, dim, half_to_float) {
  args <- mget(x = c("out", "self", "dim", "half_to_float"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", half_to_float = "bool")
nd_args <- c("out", "self", "dim", "half_to_float")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_log_softmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_mm
torch__sparse_mm <- function(sparse, dense, reduce) {
  args <- mget(x = c("sparse", "dense", "reduce"))
expected_types <- list(sparse = "Tensor", dense = "Tensor", reduce = "c10::string_view")
nd_args <- c("sparse", "dense", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_mm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_mm_reduce_impl
torch__sparse_mm_reduce_impl <- function(self, other, reduce) {
  args <- mget(x = c("self", "other", "reduce"))
expected_types <- list(self = "Tensor", other = "Tensor", reduce = "c10::string_view")
nd_args <- c("self", "other", "reduce")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_sparse_mm_reduce_impl',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_mm_reduce_impl_backward
torch__sparse_mm_reduce_impl_backward <- function(self, grad_out, weight, reduce, arg_out, output_mask) {
  args <- mget(x = c("self", "grad_out", "weight", "reduce", "arg_out", "output_mask"))
expected_types <- list(self = "Tensor", grad_out = "Tensor", weight = "Tensor", 
    reduce = "c10::string_view", arg_out = "Tensor", output_mask = "::std::array<bool,2>")
nd_args <- c("self", "grad_out", "weight", "reduce", "arg_out", "output_mask"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_sparse_mm_reduce_impl_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_softmax
torch__sparse_softmax <- function(self, dim, dtype = NULL, half_to_float) {
  args <- mget(x = c("self", "dim", "dtype", "half_to_float"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), dtype = "ScalarType", 
    half_to_float = "bool")
nd_args <- c("self", "dim", "half_to_float")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_softmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_softmax_backward_data
torch__sparse_softmax_backward_data <- function(grad_output, output, dim, self) {
  args <- mget(x = c("grad_output", "output", "dim", "self"))
expected_types <- list(grad_output = "Tensor", output = "Tensor", dim = "int64_t", 
    self = "Tensor")
nd_args <- c("grad_output", "output", "dim", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_softmax_backward_data',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_softmax_backward_data_out
torch__sparse_softmax_backward_data_out <- function(out, grad_output, output, dim, self) {
  args <- mget(x = c("out", "grad_output", "output", "dim", "self"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", output = "Tensor", 
    dim = "int64_t", self = "Tensor")
nd_args <- c("out", "grad_output", "output", "dim", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_softmax_backward_data_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_softmax_out
torch__sparse_softmax_out <- function(out, self, dim, half_to_float) {
  args <- mget(x = c("out", "self", "dim", "half_to_float"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", half_to_float = "bool")
nd_args <- c("out", "self", "dim", "half_to_float")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_softmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_sparse_matmul
torch__sparse_sparse_matmul <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_sparse_matmul',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_sparse_matmul_out
torch__sparse_sparse_matmul_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_sparse_matmul_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_sum
torch__sparse_sum <- function(self, dim, dtype) {
  args <- mget(x = c("self", "dim", "dtype"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", dtype = "ScalarType")
nd_args <- c("self", "dim", "dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_sum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_sum_backward
torch__sparse_sum_backward <- function(grad, self, dim) {
  args <- mget(x = c("grad", "self", "dim"))
expected_types <- list(grad = "Tensor", self = "Tensor", dim = "IntArrayRef")
nd_args <- c("grad", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_sum_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_sum_backward_out
torch__sparse_sum_backward_out <- function(out, grad, self, dim) {
  args <- mget(x = c("out", "grad", "self", "dim"))
expected_types <- list(out = "Tensor", grad = "Tensor", self = "Tensor", dim = "IntArrayRef")
nd_args <- c("out", "grad", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_sum_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__sparse_sum_out
torch__sparse_sum_out <- function(out, self, dim) {
  args <- mget(x = c("out", "self", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_sparse_sum_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__spdiags
torch__spdiags <- function(diagonals, offsets, shape, layout = NULL) {
  args <- mget(x = c("diagonals", "offsets", "shape", "layout"))
expected_types <- list(diagonals = "Tensor", offsets = "Tensor", shape = "IntArrayRef", 
    layout = "Layout")
nd_args <- c("diagonals", "offsets", "shape")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_spdiags',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__spdiags_out
torch__spdiags_out <- function(out, diagonals, offsets, shape, layout = NULL) {
  args <- mget(x = c("out", "diagonals", "offsets", "shape", "layout"))
expected_types <- list(out = "Tensor", diagonals = "Tensor", offsets = "Tensor", 
    shape = "IntArrayRef", layout = "Layout")
nd_args <- c("out", "diagonals", "offsets", "shape")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_spdiags_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__stack
torch__stack <- function(tensors, dim = 1L) {
  args <- mget(x = c("tensors", "dim"))
expected_types <- list(tensors = "TensorList", dim = "int64_t")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_stack',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__stack_out
torch__stack_out <- function(out, tensors, dim = 1L) {
  args <- mget(x = c("out", "tensors", "dim"))
expected_types <- list(out = "Tensor", tensors = "TensorList", dim = "int64_t")
nd_args <- c("out", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_stack_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__standard_gamma
torch__standard_gamma <- function(self, generator = NULL) {
  args <- mget(x = c("self", "generator"))
expected_types <- list(self = "Tensor", generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_standard_gamma',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__standard_gamma_grad
torch__standard_gamma_grad <- function(self, output) {
  args <- mget(x = c("self", "output"))
expected_types <- list(self = "Tensor", output = "Tensor")
nd_args <- c("self", "output")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_standard_gamma_grad',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__standard_gamma_grad_out
torch__standard_gamma_grad_out <- function(out, self, output) {
  args <- mget(x = c("out", "self", "output"))
expected_types <- list(out = "Tensor", self = "Tensor", output = "Tensor")
nd_args <- c("out", "self", "output")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_standard_gamma_grad_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__standard_gamma_out
torch__standard_gamma_out <- function(out, self, generator = NULL) {
  args <- mget(x = c("out", "self", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", generator = "Generator")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_standard_gamma_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_autograd_multiple_dispatch
torch__test_autograd_multiple_dispatch <- function(self, b) {
  args <- mget(x = c("self", "b"))
expected_types <- list(self = "Tensor", b = "bool")
nd_args <- c("self", "b")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_autograd_multiple_dispatch',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_autograd_multiple_dispatch_out
torch__test_autograd_multiple_dispatch_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_autograd_multiple_dispatch_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_autograd_multiple_dispatch_view
torch__test_autograd_multiple_dispatch_view <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_autograd_multiple_dispatch_view',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_autograd_multiple_dispatch_view_copy
torch__test_autograd_multiple_dispatch_view_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_autograd_multiple_dispatch_view_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_autograd_multiple_dispatch_view_copy_out
torch__test_autograd_multiple_dispatch_view_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_autograd_multiple_dispatch_view_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_check_tensor
torch__test_check_tensor <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_check_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_optional_filled_intlist
torch__test_optional_filled_intlist <- function(values, addends) {
  args <- mget(x = c("values", "addends"))
expected_types <- list(values = "Tensor", addends = "IntArrayRef")
nd_args <- c("values", "addends")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_optional_filled_intlist',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_optional_filled_intlist_out
torch__test_optional_filled_intlist_out <- function(out, values, addends) {
  args <- mget(x = c("out", "values", "addends"))
expected_types <- list(out = "Tensor", values = "Tensor", addends = "IntArrayRef")
nd_args <- c("out", "values", "addends")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_optional_filled_intlist_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_optional_floatlist
torch__test_optional_floatlist <- function(values, addends) {
  args <- mget(x = c("values", "addends"))
expected_types <- list(values = "Tensor", addends = "ArrayRef<double>")
nd_args <- c("values", "addends")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_optional_floatlist',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_optional_floatlist_out
torch__test_optional_floatlist_out <- function(out, values, addends) {
  args <- mget(x = c("out", "values", "addends"))
expected_types <- list(out = "Tensor", values = "Tensor", addends = "ArrayRef<double>")
nd_args <- c("out", "values", "addends")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_optional_floatlist_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_optional_intlist
torch__test_optional_intlist <- function(values, addends) {
  args <- mget(x = c("values", "addends"))
expected_types <- list(values = "Tensor", addends = "IntArrayRef")
nd_args <- c("values", "addends")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_optional_intlist',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_optional_intlist_out
torch__test_optional_intlist_out <- function(out, values, addends) {
  args <- mget(x = c("out", "values", "addends"))
expected_types <- list(out = "Tensor", values = "Tensor", addends = "IntArrayRef")
nd_args <- c("out", "values", "addends")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_optional_intlist_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_serialization_subcmul
torch__test_serialization_subcmul <- function(self, other, alpha = 1L) {
  args <- mget(x = c("self", "other", "alpha"))
expected_types <- list(self = "Tensor", other = "Tensor", alpha = "Scalar")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_serialization_subcmul',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_warn_in_autograd
torch__test_warn_in_autograd <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_warn_in_autograd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__test_warn_in_autograd_out
torch__test_warn_in_autograd_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_test_warn_in_autograd_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_differentiable_gru_cell_backward
torch__thnn_differentiable_gru_cell_backward <- function(grad_hy, input_gates, hidden_gates, hx, input_bias, hidden_bias) {
  args <- mget(x = c("grad_hy", "input_gates", "hidden_gates", "hx", "input_bias", "hidden_bias"))
expected_types <- list(grad_hy = "Tensor", input_gates = "Tensor", hidden_gates = "Tensor", 
    hx = "Tensor", input_bias = "Tensor", hidden_bias = "Tensor")
nd_args <- c("grad_hy", "input_gates", "hidden_gates", "hx", "input_bias", 
"hidden_bias")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_differentiable_gru_cell_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_differentiable_lstm_cell_backward
torch__thnn_differentiable_lstm_cell_backward <- function(grad_hy, grad_cy, input_gates, hidden_gates, input_bias, hidden_bias, cx, cy) {
  args <- mget(x = c("grad_hy", "grad_cy", "input_gates", "hidden_gates", "input_bias", "hidden_bias", "cx", "cy"))
expected_types <- list(grad_hy = "Tensor", grad_cy = "Tensor", input_gates = "Tensor", 
    hidden_gates = "Tensor", input_bias = "Tensor", hidden_bias = "Tensor", 
    cx = "Tensor", cy = "Tensor")
nd_args <- c("grad_hy", "grad_cy", "input_gates", "hidden_gates", "input_bias", 
"hidden_bias", "cx", "cy")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_differentiable_lstm_cell_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_fused_gru_cell
torch__thnn_fused_gru_cell <- function(input_gates, hidden_gates, hx, input_bias = list(), hidden_bias = list()) {
  args <- mget(x = c("input_gates", "hidden_gates", "hx", "input_bias", "hidden_bias"))
expected_types <- list(input_gates = "Tensor", hidden_gates = "Tensor", hx = "Tensor", 
    input_bias = "Tensor", hidden_bias = "Tensor")
nd_args <- c("input_gates", "hidden_gates", "hx")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_fused_gru_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_fused_gru_cell_backward
torch__thnn_fused_gru_cell_backward <- function(grad_hy, workspace, has_bias) {
  args <- mget(x = c("grad_hy", "workspace", "has_bias"))
expected_types <- list(grad_hy = "Tensor", workspace = "Tensor", has_bias = "bool")
nd_args <- c("grad_hy", "workspace", "has_bias")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_fused_gru_cell_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_fused_gru_cell_backward_out
torch__thnn_fused_gru_cell_backward_out <- function(out0, out1, out2, out3, out4, grad_hy, workspace, has_bias) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "out4", "grad_hy", "workspace", "has_bias"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    out4 = "Tensor", grad_hy = "Tensor", workspace = "Tensor", 
    has_bias = "bool")
nd_args <- c("out0", "out1", "out2", "out3", "out4", "grad_hy", "workspace", 
"has_bias")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_fused_gru_cell_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_fused_gru_cell_out
torch__thnn_fused_gru_cell_out <- function(out0, out1, input_gates, hidden_gates, hx, input_bias = list(), hidden_bias = list()) {
  args <- mget(x = c("out0", "out1", "input_gates", "hidden_gates", "hx", "input_bias", "hidden_bias"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", input_gates = "Tensor", 
    hidden_gates = "Tensor", hx = "Tensor", input_bias = "Tensor", 
    hidden_bias = "Tensor")
nd_args <- c("out0", "out1", "input_gates", "hidden_gates", "hx")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_fused_gru_cell_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_fused_lstm_cell
torch__thnn_fused_lstm_cell <- function(input_gates, hidden_gates, cx, input_bias = list(), hidden_bias = list()) {
  args <- mget(x = c("input_gates", "hidden_gates", "cx", "input_bias", "hidden_bias"))
expected_types <- list(input_gates = "Tensor", hidden_gates = "Tensor", cx = "Tensor", 
    input_bias = "Tensor", hidden_bias = "Tensor")
nd_args <- c("input_gates", "hidden_gates", "cx")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_fused_lstm_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_fused_lstm_cell_backward
torch__thnn_fused_lstm_cell_backward <- function(grad_hy, grad_cy, cx, cy, workspace, has_bias) {
  args <- mget(x = c("grad_hy", "grad_cy", "cx", "cy", "workspace", "has_bias"))
expected_types <- list(grad_hy = "Tensor", grad_cy = "Tensor", cx = "Tensor", cy = "Tensor", 
    workspace = "Tensor", has_bias = "bool")
nd_args <- c("grad_hy", "grad_cy", "cx", "cy", "workspace", "has_bias")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_fused_lstm_cell_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_fused_lstm_cell_backward_impl
torch__thnn_fused_lstm_cell_backward_impl <- function(grad_hy, grad_cy, cx, cy, workspace, has_bias) {
  args <- mget(x = c("grad_hy", "grad_cy", "cx", "cy", "workspace", "has_bias"))
expected_types <- list(grad_hy = "Tensor", grad_cy = "Tensor", cx = "Tensor", cy = "Tensor", 
    workspace = "Tensor", has_bias = "bool")
nd_args <- c("grad_hy", "grad_cy", "cx", "cy", "workspace", "has_bias")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_fused_lstm_cell_backward_impl',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_fused_lstm_cell_backward_impl_out
torch__thnn_fused_lstm_cell_backward_impl_out <- function(out0, out1, out2, grad_hy, grad_cy, cx, cy, workspace, has_bias) {
  args <- mget(x = c("out0", "out1", "out2", "grad_hy", "grad_cy", "cx", "cy", "workspace", "has_bias"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", grad_hy = "Tensor", 
    grad_cy = "Tensor", cx = "Tensor", cy = "Tensor", workspace = "Tensor", 
    has_bias = "bool")
nd_args <- c("out0", "out1", "out2", "grad_hy", "grad_cy", "cx", "cy", "workspace", 
"has_bias")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_fused_lstm_cell_backward_impl_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__thnn_fused_lstm_cell_out
torch__thnn_fused_lstm_cell_out <- function(out0, out1, out2, input_gates, hidden_gates, cx, input_bias = list(), hidden_bias = list()) {
  args <- mget(x = c("out0", "out1", "out2", "input_gates", "hidden_gates", "cx", "input_bias", "hidden_bias"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", input_gates = "Tensor", 
    hidden_gates = "Tensor", cx = "Tensor", input_bias = "Tensor", 
    hidden_bias = "Tensor")
nd_args <- c("out0", "out1", "out2", "input_gates", "hidden_gates", "cx"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_thnn_fused_lstm_cell_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__to_copy
torch__to_copy <- function(self, options = list(), non_blocking = FALSE, memory_format = NULL) {
  args <- mget(x = c("self", "options", "non_blocking", "memory_format"))
expected_types <- list(self = "Tensor", options = "TensorOptions", non_blocking = "bool", 
    memory_format = "MemoryFormat")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_to_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__to_copy_out
torch__to_copy_out <- function(out, self, non_blocking = FALSE, memory_format = NULL) {
  args <- mget(x = c("out", "self", "non_blocking", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", non_blocking = "bool", 
    memory_format = "MemoryFormat")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_to_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__to_cpu
torch__to_cpu <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = '_to_cpu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__to_dense_out
torch__to_dense_out <- function(out, self, dtype = NULL) {
  args <- mget(x = c("out", "self", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dtype = "ScalarType")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_to_dense_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__transform_bias_rescale_qkv
torch__transform_bias_rescale_qkv <- function(qkv, qkv_bias, num_heads) {
  args <- mget(x = c("qkv", "qkv_bias", "num_heads"))
expected_types <- list(qkv = "Tensor", qkv_bias = "Tensor", num_heads = "int64_t")
nd_args <- c("qkv", "qkv_bias", "num_heads")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_transform_bias_rescale_qkv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__transform_bias_rescale_qkv_out
torch__transform_bias_rescale_qkv_out <- function(out0, out1, out2, qkv, qkv_bias, num_heads) {
  args <- mget(x = c("out0", "out1", "out2", "qkv", "qkv_bias", "num_heads"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", qkv = "Tensor", 
    qkv_bias = "Tensor", num_heads = "int64_t")
nd_args <- c("out0", "out1", "out2", "qkv", "qkv_bias", "num_heads")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_transform_bias_rescale_qkv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__transformer_decoder_only_layer_fwd
torch__transformer_decoder_only_layer_fwd <- function(src, embed_dim, num_heads, qkv_weight, qkv_bias, proj_weight, proj_bias, use_gelu, norm_first, eps, norm_weight_1, norm_bias_1, norm_weight_2, norm_bias_2, ffn_weight_1, ffn_bias_1, ffn_weight_2, ffn_bias_2, mask = list(), incr_key = list(), incr_value = list()) {
  args <- mget(x = c("src", "embed_dim", "num_heads", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "use_gelu", "norm_first", "eps", "norm_weight_1", "norm_bias_1", "norm_weight_2", "norm_bias_2", "ffn_weight_1", "ffn_bias_1", "ffn_weight_2", "ffn_bias_2", "mask", "incr_key", "incr_value"))
expected_types <- list(src = "Tensor", embed_dim = "int64_t", num_heads = "int64_t", 
    qkv_weight = "Tensor", qkv_bias = "Tensor", proj_weight = "Tensor", 
    proj_bias = "Tensor", use_gelu = "bool", norm_first = "bool", 
    eps = "double", norm_weight_1 = "Tensor", norm_bias_1 = "Tensor", 
    norm_weight_2 = "Tensor", norm_bias_2 = "Tensor", ffn_weight_1 = "Tensor", 
    ffn_bias_1 = "Tensor", ffn_weight_2 = "Tensor", ffn_bias_2 = "Tensor", 
    mask = "Tensor", incr_key = "Tensor", incr_value = "Tensor")
nd_args <- c("src", "embed_dim", "num_heads", "qkv_weight", "qkv_bias", 
"proj_weight", "proj_bias", "use_gelu", "norm_first", "eps", 
"norm_weight_1", "norm_bias_1", "norm_weight_2", "norm_bias_2", 
"ffn_weight_1", "ffn_bias_1", "ffn_weight_2", "ffn_bias_2")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_transformer_decoder_only_layer_fwd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__transformer_decoder_only_layer_fwd_out
torch__transformer_decoder_only_layer_fwd_out <- function(out0, out1, out2, src, embed_dim, num_heads, qkv_weight, qkv_bias, proj_weight, proj_bias, use_gelu, norm_first, eps, norm_weight_1, norm_bias_1, norm_weight_2, norm_bias_2, ffn_weight_1, ffn_bias_1, ffn_weight_2, ffn_bias_2, mask = list(), incr_key = list(), incr_value = list()) {
  args <- mget(x = c("out0", "out1", "out2", "src", "embed_dim", "num_heads", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "use_gelu", "norm_first", "eps", "norm_weight_1", "norm_bias_1", "norm_weight_2", "norm_bias_2", "ffn_weight_1", "ffn_bias_1", "ffn_weight_2", "ffn_bias_2", "mask", "incr_key", "incr_value"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", src = "Tensor", 
    embed_dim = "int64_t", num_heads = "int64_t", qkv_weight = "Tensor", 
    qkv_bias = "Tensor", proj_weight = "Tensor", proj_bias = "Tensor", 
    use_gelu = "bool", norm_first = "bool", eps = "double", norm_weight_1 = "Tensor", 
    norm_bias_1 = "Tensor", norm_weight_2 = "Tensor", norm_bias_2 = "Tensor", 
    ffn_weight_1 = "Tensor", ffn_bias_1 = "Tensor", ffn_weight_2 = "Tensor", 
    ffn_bias_2 = "Tensor", mask = "Tensor", incr_key = "Tensor", 
    incr_value = "Tensor")
nd_args <- c("out0", "out1", "out2", "src", "embed_dim", "num_heads", "qkv_weight", 
"qkv_bias", "proj_weight", "proj_bias", "use_gelu", "norm_first", 
"eps", "norm_weight_1", "norm_bias_1", "norm_weight_2", "norm_bias_2", 
"ffn_weight_1", "ffn_bias_1", "ffn_weight_2", "ffn_bias_2")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_transformer_decoder_only_layer_fwd_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__transformer_encoder_layer_fwd
torch__transformer_encoder_layer_fwd <- function(src, embed_dim, num_heads, qkv_weight, qkv_bias, proj_weight, proj_bias, use_gelu, norm_first, eps, norm_weight_1, norm_bias_1, norm_weight_2, norm_bias_2, ffn_weight_1, ffn_bias_1, ffn_weight_2, ffn_bias_2, mask = list(), mask_type = NULL) {
  args <- mget(x = c("src", "embed_dim", "num_heads", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "use_gelu", "norm_first", "eps", "norm_weight_1", "norm_bias_1", "norm_weight_2", "norm_bias_2", "ffn_weight_1", "ffn_bias_1", "ffn_weight_2", "ffn_bias_2", "mask", "mask_type"))
expected_types <- list(src = "Tensor", embed_dim = "int64_t", num_heads = "int64_t", 
    qkv_weight = "Tensor", qkv_bias = "Tensor", proj_weight = "Tensor", 
    proj_bias = "Tensor", use_gelu = "bool", norm_first = "bool", 
    eps = "double", norm_weight_1 = "Tensor", norm_bias_1 = "Tensor", 
    norm_weight_2 = "Tensor", norm_bias_2 = "Tensor", ffn_weight_1 = "Tensor", 
    ffn_bias_1 = "Tensor", ffn_weight_2 = "Tensor", ffn_bias_2 = "Tensor", 
    mask = "Tensor", mask_type = "int64_t")
nd_args <- c("src", "embed_dim", "num_heads", "qkv_weight", "qkv_bias", 
"proj_weight", "proj_bias", "use_gelu", "norm_first", "eps", 
"norm_weight_1", "norm_bias_1", "norm_weight_2", "norm_bias_2", 
"ffn_weight_1", "ffn_bias_1", "ffn_weight_2", "ffn_bias_2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_transformer_encoder_layer_fwd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__transformer_encoder_layer_fwd_out
torch__transformer_encoder_layer_fwd_out <- function(out, src, embed_dim, num_heads, qkv_weight, qkv_bias, proj_weight, proj_bias, use_gelu, norm_first, eps, norm_weight_1, norm_bias_1, norm_weight_2, norm_bias_2, ffn_weight_1, ffn_bias_1, ffn_weight_2, ffn_bias_2, mask = list(), mask_type = NULL) {
  args <- mget(x = c("out", "src", "embed_dim", "num_heads", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "use_gelu", "norm_first", "eps", "norm_weight_1", "norm_bias_1", "norm_weight_2", "norm_bias_2", "ffn_weight_1", "ffn_bias_1", "ffn_weight_2", "ffn_bias_2", "mask", "mask_type"))
expected_types <- list(out = "Tensor", src = "Tensor", embed_dim = "int64_t", num_heads = "int64_t", 
    qkv_weight = "Tensor", qkv_bias = "Tensor", proj_weight = "Tensor", 
    proj_bias = "Tensor", use_gelu = "bool", norm_first = "bool", 
    eps = "double", norm_weight_1 = "Tensor", norm_bias_1 = "Tensor", 
    norm_weight_2 = "Tensor", norm_bias_2 = "Tensor", ffn_weight_1 = "Tensor", 
    ffn_bias_1 = "Tensor", ffn_weight_2 = "Tensor", ffn_bias_2 = "Tensor", 
    mask = "Tensor", mask_type = "int64_t")
nd_args <- c("out", "src", "embed_dim", "num_heads", "qkv_weight", "qkv_bias", 
"proj_weight", "proj_bias", "use_gelu", "norm_first", "eps", 
"norm_weight_1", "norm_bias_1", "norm_weight_2", "norm_bias_2", 
"ffn_weight_1", "ffn_bias_1", "ffn_weight_2", "ffn_bias_2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_transformer_encoder_layer_fwd_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__trilinear
torch__trilinear <- function(i1, i2, i3, expand1, expand2, expand3, sumdim, unroll_dim = 1L) {
  args <- mget(x = c("i1", "i2", "i3", "expand1", "expand2", "expand3", "sumdim", "unroll_dim"))
expected_types <- list(i1 = "Tensor", i2 = "Tensor", i3 = "Tensor", expand1 = "IntArrayRef", 
    expand2 = "IntArrayRef", expand3 = "IntArrayRef", sumdim = "IntArrayRef", 
    unroll_dim = "int64_t")
nd_args <- c("i1", "i2", "i3", "expand1", "expand2", "expand3", "sumdim"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_trilinear',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__trilinear_out
torch__trilinear_out <- function(out, i1, i2, i3, expand1, expand2, expand3, sumdim, unroll_dim = 1L) {
  args <- mget(x = c("out", "i1", "i2", "i3", "expand1", "expand2", "expand3", "sumdim", "unroll_dim"))
expected_types <- list(out = "Tensor", i1 = "Tensor", i2 = "Tensor", i3 = "Tensor", 
    expand1 = "IntArrayRef", expand2 = "IntArrayRef", expand3 = "IntArrayRef", 
    sumdim = "IntArrayRef", unroll_dim = "int64_t")
nd_args <- c("out", "i1", "i2", "i3", "expand1", "expand2", "expand3", "sumdim"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_trilinear_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__triton_multi_head_attention
torch__triton_multi_head_attention <- function(query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask = list()) {
  args <- mget(x = c("query", "key", "value", "embed_dim", "num_head", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "mask"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", embed_dim = "int64_t", 
    num_head = "int64_t", qkv_weight = "Tensor", qkv_bias = "Tensor", 
    proj_weight = "Tensor", proj_bias = "Tensor", mask = "Tensor")
nd_args <- c("query", "key", "value", "embed_dim", "num_head", "qkv_weight", 
"qkv_bias", "proj_weight", "proj_bias")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_triton_multi_head_attention',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__triton_multi_head_attention_out
torch__triton_multi_head_attention_out <- function(out, query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask = list()) {
  args <- mget(x = c("out", "query", "key", "value", "embed_dim", "num_head", "qkv_weight", "qkv_bias", "proj_weight", "proj_bias", "mask"))
expected_types <- list(out = "Tensor", query = "Tensor", key = "Tensor", value = "Tensor", 
    embed_dim = "int64_t", num_head = "int64_t", qkv_weight = "Tensor", 
    qkv_bias = "Tensor", proj_weight = "Tensor", proj_bias = "Tensor", 
    mask = "Tensor")
nd_args <- c("out", "query", "key", "value", "embed_dim", "num_head", "qkv_weight", 
"qkv_bias", "proj_weight", "proj_bias")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_triton_multi_head_attention_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__triton_scaled_dot_attention
torch__triton_scaled_dot_attention <- function(q, k, v, dropout_p = 0L) {
  args <- mget(x = c("q", "k", "v", "dropout_p"))
expected_types <- list(q = "Tensor", k = "Tensor", v = "Tensor", dropout_p = "double")
nd_args <- c("q", "k", "v")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_triton_scaled_dot_attention',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__triton_scaled_dot_attention_out
torch__triton_scaled_dot_attention_out <- function(out, q, k, v, dropout_p = 0L) {
  args <- mget(x = c("out", "q", "k", "v", "dropout_p"))
expected_types <- list(out = "Tensor", q = "Tensor", k = "Tensor", v = "Tensor", 
    dropout_p = "double")
nd_args <- c("out", "q", "k", "v")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_triton_scaled_dot_attention_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__unique
torch__unique <- function(self, sorted = TRUE, return_inverse = FALSE) {
  args <- mget(x = c("self", "sorted", "return_inverse"))
expected_types <- list(self = "Tensor", sorted = "bool", return_inverse = "bool")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_unique',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__unique_out
torch__unique_out <- function(out0, out1, self, sorted = TRUE, return_inverse = FALSE) {
  args <- mget(x = c("out0", "out1", "self", "sorted", "return_inverse"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", self = "Tensor", sorted = "bool", 
    return_inverse = "bool")
nd_args <- c("out0", "out1", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_unique_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__unique2
torch__unique2 <- function(self, sorted = TRUE, return_inverse = FALSE, return_counts = FALSE) {
  args <- mget(x = c("self", "sorted", "return_inverse", "return_counts"))
expected_types <- list(self = "Tensor", sorted = "bool", return_inverse = "bool", 
    return_counts = "bool")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_unique2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__unique2_out
torch__unique2_out <- function(out0, out1, out2, self, sorted = TRUE, return_inverse = FALSE, return_counts = FALSE) {
  args <- mget(x = c("out0", "out1", "out2", "self", "sorted", "return_inverse", "return_counts"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", self = "Tensor", 
    sorted = "bool", return_inverse = "bool", return_counts = "bool")
nd_args <- c("out0", "out1", "out2", "self")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = '_unique2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__unpack_dual
torch__unpack_dual <- function(dual, level) {
  args <- mget(x = c("dual", "level"))
expected_types <- list(dual = "Tensor", level = "int64_t")
nd_args <- c("dual", "level")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_unpack_dual',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__unsafe_view
torch__unsafe_view <- function(self, size) {
  args <- mget(x = c("self", "size"))
expected_types <- list(self = "Tensor", size = "IntArrayRef")
nd_args <- c("self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_unsafe_view',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__unsafe_view_out
torch__unsafe_view_out <- function(out, self, size) {
  args <- mget(x = c("out", "self", "size"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef")
nd_args <- c("out", "self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_unsafe_view_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_bicubic2d_aa
torch__upsample_bicubic2d_aa <- function(input, self, output_size, align_corners, scale_factors, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("input", "self", "output_size", "align_corners", "scale_factors", "scales_h", "scales_w"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scale_factors = "ArrayRef<double>", 
    scales_h = "double", scales_w = "double")
nd_args <- c("input", "self", "output_size", "align_corners", "scale_factors"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_bicubic2d_aa',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_bicubic2d_aa_backward
torch__upsample_bicubic2d_aa_backward <- function(grad_output, output_size, input_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    align_corners = "bool", scales_h = "double", scales_w = "double")
nd_args <- c("grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_bicubic2d_aa_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_bicubic2d_aa_backward_out
torch__upsample_bicubic2d_aa_backward_out <- function(grad_input, grad_output, output_size, input_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", align_corners = "bool", scales_h = "double", 
    scales_w = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_bicubic2d_aa_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_bicubic2d_aa_out
torch__upsample_bicubic2d_aa_out <- function(out, self, output_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("out", "self", "output_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scales_h = "double", scales_w = "double")
nd_args <- c("out", "self", "output_size", "align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_bicubic2d_aa_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_bilinear2d_aa
torch__upsample_bilinear2d_aa <- function(input, self, output_size, align_corners, scale_factors, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("input", "self", "output_size", "align_corners", "scale_factors", "scales_h", "scales_w"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scale_factors = "ArrayRef<double>", 
    scales_h = "double", scales_w = "double")
nd_args <- c("input", "self", "output_size", "align_corners", "scale_factors"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_bilinear2d_aa',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_bilinear2d_aa_backward
torch__upsample_bilinear2d_aa_backward <- function(grad_output, output_size, input_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    align_corners = "bool", scales_h = "double", scales_w = "double")
nd_args <- c("grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_bilinear2d_aa_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_bilinear2d_aa_backward_out
torch__upsample_bilinear2d_aa_backward_out <- function(grad_input, grad_output, output_size, input_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", align_corners = "bool", scales_h = "double", 
    scales_w = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_bilinear2d_aa_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_bilinear2d_aa_out
torch__upsample_bilinear2d_aa_out <- function(out, self, output_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("out", "self", "output_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scales_h = "double", scales_w = "double")
nd_args <- c("out", "self", "output_size", "align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_bilinear2d_aa_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact1d
torch__upsample_nearest_exact1d <- function(input, self, output_size, scale_factors, scales = NULL) {
  args <- mget(x = c("input", "self", "output_size", "scale_factors", "scales"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scale_factors = "ArrayRef<double>", scales = "double")
nd_args <- c("input", "self", "output_size", "scale_factors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact1d_backward
torch__upsample_nearest_exact1d_backward <- function(grad_output, output_size, input_size, scales = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "scales"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    scales = "double")
nd_args <- c("grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact1d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact1d_backward_out
torch__upsample_nearest_exact1d_backward_out <- function(grad_input, grad_output, output_size, input_size, scales = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "scales"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", scales = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact1d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact1d_out
torch__upsample_nearest_exact1d_out <- function(out, self, output_size, scales = NULL) {
  args <- mget(x = c("out", "self", "output_size", "scales"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scales = "double")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact1d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact2d
torch__upsample_nearest_exact2d <- function(input, self, output_size, scale_factors, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("input", "self", "output_size", "scale_factors", "scales_h", "scales_w"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scale_factors = "ArrayRef<double>", scales_h = "double", 
    scales_w = "double")
nd_args <- c("input", "self", "output_size", "scale_factors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact2d_backward
torch__upsample_nearest_exact2d_backward <- function(grad_output, output_size, input_size, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "scales_h", "scales_w"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    scales_h = "double", scales_w = "double")
nd_args <- c("grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact2d_backward_out
torch__upsample_nearest_exact2d_backward_out <- function(grad_input, grad_output, output_size, input_size, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "scales_h", "scales_w"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", scales_h = "double", scales_w = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact2d_out
torch__upsample_nearest_exact2d_out <- function(out, self, output_size, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("out", "self", "output_size", "scales_h", "scales_w"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scales_h = "double", scales_w = "double")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact3d
torch__upsample_nearest_exact3d <- function(input, self, output_size, scale_factors, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("input", "self", "output_size", "scale_factors", "scales_d", "scales_h", "scales_w"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scale_factors = "ArrayRef<double>", scales_d = "double", 
    scales_h = "double", scales_w = "double")
nd_args <- c("input", "self", "output_size", "scale_factors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact3d_backward
torch__upsample_nearest_exact3d_backward <- function(grad_output, output_size, input_size, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "scales_d", "scales_h", "scales_w"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    scales_d = "double", scales_h = "double", scales_w = "double")
nd_args <- c("grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact3d_backward_out
torch__upsample_nearest_exact3d_backward_out <- function(grad_input, grad_output, output_size, input_size, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "scales_d", "scales_h", "scales_w"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", scales_d = "double", scales_h = "double", 
    scales_w = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__upsample_nearest_exact3d_out
torch__upsample_nearest_exact3d_out <- function(out, self, output_size, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("out", "self", "output_size", "scales_d", "scales_h", "scales_w"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scales_d = "double", scales_h = "double", scales_w = "double")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_upsample_nearest_exact3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__use_cudnn_ctc_loss
torch__use_cudnn_ctc_loss <- function(log_probs, targets, input_lengths, target_lengths, blank) {
  args <- mget(x = c("log_probs", "targets", "input_lengths", "target_lengths", "blank"))
expected_types <- list(log_probs = "Tensor", targets = "Tensor", input_lengths = c("IntArrayRef", 
"Tensor"), target_lengths = c("IntArrayRef", "Tensor"), blank = "int64_t")
nd_args <- c("log_probs", "targets", "input_lengths", "target_lengths", 
"blank")
return_types <- list(list('bool'))
call_c_function(
fun_name = '_use_cudnn_ctc_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__validate_compressed_sparse_indices
torch__validate_compressed_sparse_indices <- function(is_crow, compressed_idx, plain_idx, cdim, dim, nnz) {
  args <- mget(x = c("is_crow", "compressed_idx", "plain_idx", "cdim", "dim", "nnz"))
expected_types <- list(is_crow = "bool", compressed_idx = "Tensor", plain_idx = "Tensor", 
    cdim = "int64_t", dim = "int64_t", nnz = "int64_t")
nd_args <- c("is_crow", "compressed_idx", "plain_idx", "cdim", "dim", "nnz"
)
return_types <- list(list("void"))
call_c_function(
fun_name = '_validate_compressed_sparse_indices',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__validate_sparse_bsc_tensor_args
torch__validate_sparse_bsc_tensor_args <- function(ccol_indices, row_indices, values, size) {
  args <- mget(x = c("ccol_indices", "row_indices", "values", "size"))
expected_types <- list(ccol_indices = "Tensor", row_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef")
nd_args <- c("ccol_indices", "row_indices", "values", "size")
return_types <- list(list("void"))
call_c_function(
fun_name = '_validate_sparse_bsc_tensor_args',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__validate_sparse_bsr_tensor_args
torch__validate_sparse_bsr_tensor_args <- function(crow_indices, col_indices, values, size) {
  args <- mget(x = c("crow_indices", "col_indices", "values", "size"))
expected_types <- list(crow_indices = "Tensor", col_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef")
nd_args <- c("crow_indices", "col_indices", "values", "size")
return_types <- list(list("void"))
call_c_function(
fun_name = '_validate_sparse_bsr_tensor_args',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__validate_sparse_compressed_tensor_args
torch__validate_sparse_compressed_tensor_args <- function(compressed_indices, plain_indices, values, size, layout) {
  args <- mget(x = c("compressed_indices", "plain_indices", "values", "size", "layout"))
expected_types <- list(compressed_indices = "Tensor", plain_indices = "Tensor", 
    values = "Tensor", size = "IntArrayRef", layout = "Layout")
nd_args <- c("compressed_indices", "plain_indices", "values", "size", "layout"
)
return_types <- list(list("void"))
call_c_function(
fun_name = '_validate_sparse_compressed_tensor_args',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__validate_sparse_coo_tensor_args
torch__validate_sparse_coo_tensor_args <- function(indices, values, size) {
  args <- mget(x = c("indices", "values", "size"))
expected_types <- list(indices = "Tensor", values = "Tensor", size = "IntArrayRef")
nd_args <- c("indices", "values", "size")
return_types <- list(list("void"))
call_c_function(
fun_name = '_validate_sparse_coo_tensor_args',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__validate_sparse_csc_tensor_args
torch__validate_sparse_csc_tensor_args <- function(ccol_indices, row_indices, values, size) {
  args <- mget(x = c("ccol_indices", "row_indices", "values", "size"))
expected_types <- list(ccol_indices = "Tensor", row_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef")
nd_args <- c("ccol_indices", "row_indices", "values", "size")
return_types <- list(list("void"))
call_c_function(
fun_name = '_validate_sparse_csc_tensor_args',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__validate_sparse_csr_tensor_args
torch__validate_sparse_csr_tensor_args <- function(crow_indices, col_indices, values, size) {
  args <- mget(x = c("crow_indices", "col_indices", "values", "size"))
expected_types <- list(crow_indices = "Tensor", col_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef")
nd_args <- c("crow_indices", "col_indices", "values", "size")
return_types <- list(list("void"))
call_c_function(
fun_name = '_validate_sparse_csr_tensor_args',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__values_copy
torch__values_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_values_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__values_copy_out
torch__values_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_values_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__weight_norm
torch__weight_norm <- function(v, g, dim = 1L) {
  args <- mget(x = c("v", "g", "dim"))
expected_types <- list(v = "Tensor", g = "Tensor", dim = "int64_t")
nd_args <- c("v", "g")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = '_weight_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__weight_norm_differentiable_backward
torch__weight_norm_differentiable_backward <- function(grad_w, saved_v, saved_g, saved_norms, dim) {
  args <- mget(x = c("grad_w", "saved_v", "saved_g", "saved_norms", "dim"))
expected_types <- list(grad_w = "Tensor", saved_v = "Tensor", saved_g = "Tensor", 
    saved_norms = "Tensor", dim = "int64_t")
nd_args <- c("grad_w", "saved_v", "saved_g", "saved_norms", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_weight_norm_differentiable_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__weight_norm_interface
torch__weight_norm_interface <- function(v, g, dim = 1L) {
  args <- mget(x = c("v", "g", "dim"))
expected_types <- list(v = "Tensor", g = "Tensor", dim = "int64_t")
nd_args <- c("v", "g")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_weight_norm_interface',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__weight_norm_interface_backward
torch__weight_norm_interface_backward <- function(grad_w, saved_v, saved_g, saved_norms, dim) {
  args <- mget(x = c("grad_w", "saved_v", "saved_g", "saved_norms", "dim"))
expected_types <- list(grad_w = "Tensor", saved_v = "Tensor", saved_g = "Tensor", 
    saved_norms = "Tensor", dim = "int64_t")
nd_args <- c("grad_w", "saved_v", "saved_g", "saved_norms", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_weight_norm_interface_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__weight_norm_interface_backward_out
torch__weight_norm_interface_backward_out <- function(out0, out1, grad_w, saved_v, saved_g, saved_norms, dim) {
  args <- mget(x = c("out0", "out1", "grad_w", "saved_v", "saved_g", "saved_norms", "dim"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", grad_w = "Tensor", saved_v = "Tensor", 
    saved_g = "Tensor", saved_norms = "Tensor", dim = "int64_t")
nd_args <- c("out0", "out1", "grad_w", "saved_v", "saved_g", "saved_norms", 
"dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_weight_norm_interface_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch__weight_norm_interface_out
torch__weight_norm_interface_out <- function(out0, out1, v, g, dim = 1L) {
  args <- mget(x = c("out0", "out1", "v", "g", "dim"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", v = "Tensor", g = "Tensor", 
    dim = "int64_t")
nd_args <- c("out0", "out1", "v", "g")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = '_weight_norm_interface_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_abs
torch_abs <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'abs',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_abs_
torch_abs_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'abs_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_abs_out
torch_abs_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'abs_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_absolute
torch_absolute <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'absolute',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_absolute_out
torch_absolute_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'absolute_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_acos
torch_acos <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'acos',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_acos_
torch_acos_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'acos_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_acos_out
torch_acos_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'acos_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_acosh
torch_acosh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'acosh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_acosh_
torch_acosh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'acosh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_acosh_out
torch_acosh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'acosh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_avg_pool1d
torch_adaptive_avg_pool1d <- function(self, output_size) {
  args <- mget(x = c("self", "output_size"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_avg_pool1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_avg_pool2d
torch_adaptive_avg_pool2d <- function(self, output_size) {
  args <- mget(x = c("self", "output_size"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_avg_pool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_avg_pool2d_out
torch_adaptive_avg_pool2d_out <- function(out, self, output_size) {
  args <- mget(x = c("out", "self", "output_size"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_avg_pool2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_avg_pool3d
torch_adaptive_avg_pool3d <- function(self, output_size) {
  args <- mget(x = c("self", "output_size"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_avg_pool3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_avg_pool3d_backward_out
torch_adaptive_avg_pool3d_backward_out <- function(grad_input, grad_output, self) {
  args <- mget(x = c("grad_input", "grad_output", "self"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_input", "grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_avg_pool3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_avg_pool3d_out
torch_adaptive_avg_pool3d_out <- function(out, self, output_size) {
  args <- mget(x = c("out", "self", "output_size"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_avg_pool3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_max_pool1d
torch_adaptive_max_pool1d <- function(self, output_size) {
  args <- mget(x = c("self", "output_size"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "output_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'adaptive_max_pool1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_max_pool2d
torch_adaptive_max_pool2d <- function(self, output_size) {
  args <- mget(x = c("self", "output_size"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "output_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'adaptive_max_pool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_max_pool2d_backward
torch_adaptive_max_pool2d_backward <- function(grad_output, self, indices) {
  args <- mget(x = c("grad_output", "self", "indices"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", indices = "Tensor")
nd_args <- c("grad_output", "self", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_max_pool2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_max_pool2d_backward_out
torch_adaptive_max_pool2d_backward_out <- function(grad_input, grad_output, self, indices) {
  args <- mget(x = c("grad_input", "grad_output", "self", "indices"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    indices = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_max_pool2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_max_pool2d_out
torch_adaptive_max_pool2d_out <- function(out, indices, self, output_size) {
  args <- mget(x = c("out", "indices", "self", "output_size"))
expected_types <- list(out = "Tensor", indices = "Tensor", self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("out", "indices", "self", "output_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'adaptive_max_pool2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_max_pool3d
torch_adaptive_max_pool3d <- function(self, output_size) {
  args <- mget(x = c("self", "output_size"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "output_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'adaptive_max_pool3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_max_pool3d_backward
torch_adaptive_max_pool3d_backward <- function(grad_output, self, indices) {
  args <- mget(x = c("grad_output", "self", "indices"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", indices = "Tensor")
nd_args <- c("grad_output", "self", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_max_pool3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_max_pool3d_backward_out
torch_adaptive_max_pool3d_backward_out <- function(grad_input, grad_output, self, indices) {
  args <- mget(x = c("grad_input", "grad_output", "self", "indices"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    indices = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adaptive_max_pool3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adaptive_max_pool3d_out
torch_adaptive_max_pool3d_out <- function(out, indices, self, output_size) {
  args <- mget(x = c("out", "indices", "self", "output_size"))
expected_types <- list(out = "Tensor", indices = "Tensor", self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("out", "indices", "self", "output_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'adaptive_max_pool3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_add
torch_add <- function(self, other, alpha = 1L) {
  args <- mget(x = c("self", "other", "alpha"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"), alpha = "Scalar")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'add',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_add_out
torch_add_out <- function(out, self, other, alpha = 1L) {
  args <- mget(x = c("out", "self", "other", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Tensor", "Scalar"
), alpha = "Scalar")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'add_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addbmm
torch_addbmm <- function(self, batch1, batch2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("self", "batch1", "batch2", "beta", "alpha"))
expected_types <- list(self = "Tensor", batch1 = "Tensor", batch2 = "Tensor", beta = "Scalar", 
    alpha = "Scalar")
nd_args <- c("self", "batch1", "batch2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addbmm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addbmm_out
torch_addbmm_out <- function(out, self, batch1, batch2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("out", "self", "batch1", "batch2", "beta", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", batch1 = "Tensor", batch2 = "Tensor", 
    beta = "Scalar", alpha = "Scalar")
nd_args <- c("out", "self", "batch1", "batch2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addbmm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addcdiv
torch_addcdiv <- function(self, tensor1, tensor2, value = 1L) {
  args <- mget(x = c("self", "tensor1", "tensor2", "value"))
expected_types <- list(self = "Tensor", tensor1 = "Tensor", tensor2 = "Tensor", 
    value = "Scalar")
nd_args <- c("self", "tensor1", "tensor2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addcdiv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addcdiv_out
torch_addcdiv_out <- function(out, self, tensor1, tensor2, value = 1L) {
  args <- mget(x = c("out", "self", "tensor1", "tensor2", "value"))
expected_types <- list(out = "Tensor", self = "Tensor", tensor1 = "Tensor", tensor2 = "Tensor", 
    value = "Scalar")
nd_args <- c("out", "self", "tensor1", "tensor2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addcdiv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addcmul
torch_addcmul <- function(self, tensor1, tensor2, value = 1L) {
  args <- mget(x = c("self", "tensor1", "tensor2", "value"))
expected_types <- list(self = "Tensor", tensor1 = "Tensor", tensor2 = "Tensor", 
    value = "Scalar")
nd_args <- c("self", "tensor1", "tensor2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addcmul',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addcmul_out
torch_addcmul_out <- function(out, self, tensor1, tensor2, value = 1L) {
  args <- mget(x = c("out", "self", "tensor1", "tensor2", "value"))
expected_types <- list(out = "Tensor", self = "Tensor", tensor1 = "Tensor", tensor2 = "Tensor", 
    value = "Scalar")
nd_args <- c("out", "self", "tensor1", "tensor2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addcmul_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addmm
torch_addmm <- function(self, mat1, mat2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("self", "mat1", "mat2", "beta", "alpha"))
expected_types <- list(self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", beta = "Scalar", 
    alpha = "Scalar")
nd_args <- c("self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addmm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addmm_out
torch_addmm_out <- function(out, self, mat1, mat2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("out", "self", "mat1", "mat2", "beta", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", 
    beta = "Scalar", alpha = "Scalar")
nd_args <- c("out", "self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addmm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addmv
torch_addmv <- function(self, mat, vec, beta = 1L, alpha = 1L) {
  args <- mget(x = c("self", "mat", "vec", "beta", "alpha"))
expected_types <- list(self = "Tensor", mat = "Tensor", vec = "Tensor", beta = "Scalar", 
    alpha = "Scalar")
nd_args <- c("self", "mat", "vec")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addmv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addmv_
torch_addmv_ <- function(self, mat, vec, beta = 1L, alpha = 1L) {
  args <- mget(x = c("self", "mat", "vec", "beta", "alpha"))
expected_types <- list(self = "Tensor", mat = "Tensor", vec = "Tensor", beta = "Scalar", 
    alpha = "Scalar")
nd_args <- c("self", "mat", "vec")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addmv_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addmv_out
torch_addmv_out <- function(out, self, mat, vec, beta = 1L, alpha = 1L) {
  args <- mget(x = c("out", "self", "mat", "vec", "beta", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", mat = "Tensor", vec = "Tensor", 
    beta = "Scalar", alpha = "Scalar")
nd_args <- c("out", "self", "mat", "vec")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addmv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addr
torch_addr <- function(self, vec1, vec2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("self", "vec1", "vec2", "beta", "alpha"))
expected_types <- list(self = "Tensor", vec1 = "Tensor", vec2 = "Tensor", beta = "Scalar", 
    alpha = "Scalar")
nd_args <- c("self", "vec1", "vec2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_addr_out
torch_addr_out <- function(out, self, vec1, vec2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("out", "self", "vec1", "vec2", "beta", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", vec1 = "Tensor", vec2 = "Tensor", 
    beta = "Scalar", alpha = "Scalar")
nd_args <- c("out", "self", "vec1", "vec2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'addr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_adjoint
torch_adjoint <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'adjoint',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_affine_grid_generator
torch_affine_grid_generator <- function(theta, size, align_corners) {
  args <- mget(x = c("theta", "size", "align_corners"))
expected_types <- list(theta = "Tensor", size = "IntArrayRef", align_corners = "bool")
nd_args <- c("theta", "size", "align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'affine_grid_generator',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_affine_grid_generator_backward
torch_affine_grid_generator_backward <- function(grad, size, align_corners) {
  args <- mget(x = c("grad", "size", "align_corners"))
expected_types <- list(grad = "Tensor", size = "IntArrayRef", align_corners = "bool")
nd_args <- c("grad", "size", "align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'affine_grid_generator_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_affine_grid_generator_out
torch_affine_grid_generator_out <- function(out, theta, size, align_corners) {
  args <- mget(x = c("out", "theta", "size", "align_corners"))
expected_types <- list(out = "Tensor", theta = "Tensor", size = "IntArrayRef", 
    align_corners = "bool")
nd_args <- c("out", "theta", "size", "align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'affine_grid_generator_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_alias
torch_alias <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'alias',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_alias_copy
torch_alias_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'alias_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_alias_copy_out
torch_alias_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'alias_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_align_tensors
torch_align_tensors <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'align_tensors',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_all
torch_all <- function(self, dim, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'all',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_all_out
torch_all_out <- function(out, self, dim, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("int64_t", "Dimname"
), keepdim = "bool")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'all_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_allclose
torch_allclose <- function(self, other, rtol = 1e-05, atol = 1e-08, equal_nan = FALSE) {
  args <- mget(x = c("self", "other", "rtol", "atol", "equal_nan"))
expected_types <- list(self = "Tensor", other = "Tensor", rtol = "double", atol = "double", 
    equal_nan = "bool")
nd_args <- c("self", "other")
return_types <- list(list('bool'))
call_c_function(
fun_name = 'allclose',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_alpha_dropout
torch_alpha_dropout <- function(input, p, train) {
  args <- mget(x = c("input", "p", "train"))
expected_types <- list(input = "Tensor", p = "double", train = "bool")
nd_args <- c("input", "p", "train")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'alpha_dropout',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_alpha_dropout_
torch_alpha_dropout_ <- function(self, p, train) {
  args <- mget(x = c("self", "p", "train"))
expected_types <- list(self = "Tensor", p = "double", train = "bool")
nd_args <- c("self", "p", "train")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'alpha_dropout_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_amax
torch_amax <- function(self, dim = list(), keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'amax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_amax_out
torch_amax_out <- function(out, self, dim = list(), keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'amax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_amin
torch_amin <- function(self, dim = list(), keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'amin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_amin_out
torch_amin_out <- function(out, self, dim = list(), keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'amin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_aminmax
torch_aminmax <- function(self, dim = NULL, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = "int64_t", keepdim = "bool")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'aminmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_aminmax_out
torch_aminmax_out <- function(min, max, self, dim = NULL, keepdim = FALSE) {
  args <- mget(x = c("min", "max", "self", "dim", "keepdim"))
expected_types <- list(min = "Tensor", max = "Tensor", self = "Tensor", dim = "int64_t", 
    keepdim = "bool")
nd_args <- c("min", "max", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'aminmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_angle
torch_angle <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'angle',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_angle_out
torch_angle_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'angle_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_any
torch_any <- function(self, dim, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'any',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_any_out
torch_any_out <- function(out, self, dim, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("int64_t", "Dimname"
), keepdim = "bool")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'any_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_arange
.torch_arange <- function(start, end, step = 1L, options = list()) {
  args <- mget(x = c("start", "end", "step", "options"))
expected_types <- list(start = "Scalar", end = "Scalar", step = "Scalar", options = "TensorOptions")
nd_args <- c("start", "end")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arange',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arange_out
torch_arange_out <- function(out, start, end, step = 1L) {
  args <- mget(x = c("out", "start", "end", "step"))
expected_types <- list(out = "Tensor", start = "Scalar", end = "Scalar", step = "Scalar")
nd_args <- c("out", "start", "end")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arange_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arccos
torch_arccos <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arccos',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arccos_
torch_arccos_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arccos_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arccos_out
torch_arccos_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arccos_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arccosh
torch_arccosh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arccosh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arccosh_
torch_arccosh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arccosh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arccosh_out
torch_arccosh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arccosh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arcsin
torch_arcsin <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arcsin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arcsin_
torch_arcsin_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arcsin_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arcsin_out
torch_arcsin_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arcsin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arcsinh
torch_arcsinh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arcsinh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arcsinh_
torch_arcsinh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arcsinh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arcsinh_out
torch_arcsinh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arcsinh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arctan
torch_arctan <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arctan',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arctan_
torch_arctan_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arctan_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arctan_out
torch_arctan_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arctan_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arctan2
torch_arctan2 <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arctan2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arctan2_out
torch_arctan2_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arctan2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arctanh
torch_arctanh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arctanh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arctanh_
torch_arctanh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arctanh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_arctanh_out
torch_arctanh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'arctanh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_argmax
.torch_argmax <- function(self, dim = NULL, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = "int64_t", keepdim = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'argmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_argmax_out
torch_argmax_out <- function(out, self, dim = NULL, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", keepdim = "bool")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'argmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_argmin
.torch_argmin <- function(self, dim = NULL, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = "int64_t", keepdim = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'argmin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_argmin_out
torch_argmin_out <- function(out, self, dim = NULL, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", keepdim = "bool")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'argmin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_argsort
.torch_argsort <- function(self, stable, dim = -1L, descending = FALSE) {
  args <- mget(x = c("self", "stable", "dim", "descending"))
expected_types <- list(self = "Tensor", stable = "bool", dim = c("int64_t", "Dimname"
), descending = "bool")
nd_args <- c("self", "stable", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'argsort',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_argsort_out
torch_argsort_out <- function(out, self, stable, dim = -1L, descending = FALSE) {
  args <- mget(x = c("out", "self", "stable", "dim", "descending"))
expected_types <- list(out = "Tensor", self = "Tensor", stable = "bool", dim = "int64_t", 
    descending = "bool")
nd_args <- c("out", "self", "stable")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'argsort_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_argwhere
torch_argwhere <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'argwhere',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_as_strided
torch_as_strided <- function(self, size, stride, storage_offset = NULL) {
  args <- mget(x = c("self", "size", "stride", "storage_offset"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", stride = "IntArrayRef", 
    storage_offset = "int64_t")
nd_args <- c("self", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'as_strided',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_as_strided_
torch_as_strided_ <- function(self, size, stride, storage_offset = NULL) {
  args <- mget(x = c("self", "size", "stride", "storage_offset"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", stride = "IntArrayRef", 
    storage_offset = "int64_t")
nd_args <- c("self", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'as_strided_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_as_strided_copy
torch_as_strided_copy <- function(self, size, stride, storage_offset = NULL) {
  args <- mget(x = c("self", "size", "stride", "storage_offset"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", stride = "IntArrayRef", 
    storage_offset = "int64_t")
nd_args <- c("self", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'as_strided_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_as_strided_copy_out
torch_as_strided_copy_out <- function(out, self, size, stride, storage_offset = NULL) {
  args <- mget(x = c("out", "self", "size", "stride", "storage_offset"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef", stride = "IntArrayRef", 
    storage_offset = "int64_t")
nd_args <- c("out", "self", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'as_strided_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_as_strided_scatter
torch_as_strided_scatter <- function(self, src, size, stride, storage_offset = NULL) {
  args <- mget(x = c("self", "src", "size", "stride", "storage_offset"))
expected_types <- list(self = "Tensor", src = "Tensor", size = "IntArrayRef", stride = "IntArrayRef", 
    storage_offset = "int64_t")
nd_args <- c("self", "src", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'as_strided_scatter',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_as_strided_scatter_out
torch_as_strided_scatter_out <- function(out, self, src, size, stride, storage_offset = NULL) {
  args <- mget(x = c("out", "self", "src", "size", "stride", "storage_offset"))
expected_types <- list(out = "Tensor", self = "Tensor", src = "Tensor", size = "IntArrayRef", 
    stride = "IntArrayRef", storage_offset = "int64_t")
nd_args <- c("out", "self", "src", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'as_strided_scatter_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_asin
torch_asin <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'asin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_asin_
torch_asin_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'asin_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_asin_out
torch_asin_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'asin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_asinh
torch_asinh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'asinh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_asinh_
torch_asinh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'asinh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_asinh_out
torch_asinh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'asinh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_atan
torch_atan <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'atan',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_atan_
torch_atan_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'atan_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_atan_out
torch_atan_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'atan_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_atan2
torch_atan2 <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'atan2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_atan2_out
torch_atan2_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'atan2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_atanh
torch_atanh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'atanh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_atanh_
torch_atanh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'atanh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_atanh_out
torch_atanh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'atanh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_atleast_1d
.torch_atleast_1d <- function(self, tensors) {
  args <- mget(x = c("self", "tensors"))
expected_types <- list(self = "Tensor", tensors = "TensorList")
nd_args <- c("self", "tensors")
return_types <- list(list('Tensor'), list('TensorList'))
call_c_function(
fun_name = 'atleast_1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_atleast_2d
.torch_atleast_2d <- function(self, tensors) {
  args <- mget(x = c("self", "tensors"))
expected_types <- list(self = "Tensor", tensors = "TensorList")
nd_args <- c("self", "tensors")
return_types <- list(list('Tensor'), list('TensorList'))
call_c_function(
fun_name = 'atleast_2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_atleast_3d
.torch_atleast_3d <- function(self, tensors) {
  args <- mget(x = c("self", "tensors"))
expected_types <- list(self = "Tensor", tensors = "TensorList")
nd_args <- c("self", "tensors")
return_types <- list(list('Tensor'), list('TensorList'))
call_c_function(
fun_name = 'atleast_3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_avg_pool1d
torch_avg_pool1d <- function(self, kernel_size, stride = list(), padding = 0L, ceil_mode = FALSE, count_include_pad = TRUE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "ceil_mode", "count_include_pad"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", ceil_mode = "bool", count_include_pad = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'avg_pool1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_avg_pool2d
torch_avg_pool2d <- function(self, kernel_size, stride = list(), padding = 0L, ceil_mode = FALSE, count_include_pad = TRUE, divisor_override = NULL) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "ceil_mode", "count_include_pad", "divisor_override"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", ceil_mode = "bool", count_include_pad = "bool", 
    divisor_override = "int64_t")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'avg_pool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_avg_pool2d_backward
torch_avg_pool2d_backward <- function(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override) {
  args <- mget(x = c("grad_output", "self", "kernel_size", "stride", "padding", "ceil_mode", "count_include_pad", "divisor_override"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", ceil_mode = "bool", 
    count_include_pad = "bool", divisor_override = "int64_t")
nd_args <- c("grad_output", "self", "kernel_size", "stride", "padding", 
"ceil_mode", "count_include_pad", "divisor_override")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'avg_pool2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_avg_pool2d_backward_out
torch_avg_pool2d_backward_out <- function(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override) {
  args <- mget(x = c("grad_input", "grad_output", "self", "kernel_size", "stride", "padding", "ceil_mode", "count_include_pad", "divisor_override"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    kernel_size = "IntArrayRef", stride = "IntArrayRef", padding = "IntArrayRef", 
    ceil_mode = "bool", count_include_pad = "bool", divisor_override = "int64_t")
nd_args <- c("grad_input", "grad_output", "self", "kernel_size", "stride", 
"padding", "ceil_mode", "count_include_pad", "divisor_override"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'avg_pool2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_avg_pool2d_out
torch_avg_pool2d_out <- function(out, self, kernel_size, stride = list(), padding = 0L, ceil_mode = FALSE, count_include_pad = TRUE, divisor_override = NULL) {
  args <- mget(x = c("out", "self", "kernel_size", "stride", "padding", "ceil_mode", "count_include_pad", "divisor_override"))
expected_types <- list(out = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", ceil_mode = "bool", 
    count_include_pad = "bool", divisor_override = "int64_t")
nd_args <- c("out", "self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'avg_pool2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_avg_pool3d
torch_avg_pool3d <- function(self, kernel_size, stride = list(), padding = 0L, ceil_mode = FALSE, count_include_pad = TRUE, divisor_override = NULL) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "ceil_mode", "count_include_pad", "divisor_override"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", ceil_mode = "bool", count_include_pad = "bool", 
    divisor_override = "int64_t")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'avg_pool3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_avg_pool3d_backward
torch_avg_pool3d_backward <- function(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override) {
  args <- mget(x = c("grad_output", "self", "kernel_size", "stride", "padding", "ceil_mode", "count_include_pad", "divisor_override"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", ceil_mode = "bool", 
    count_include_pad = "bool", divisor_override = "int64_t")
nd_args <- c("grad_output", "self", "kernel_size", "stride", "padding", 
"ceil_mode", "count_include_pad", "divisor_override")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'avg_pool3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_avg_pool3d_backward_out
torch_avg_pool3d_backward_out <- function(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override) {
  args <- mget(x = c("grad_input", "grad_output", "self", "kernel_size", "stride", "padding", "ceil_mode", "count_include_pad", "divisor_override"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    kernel_size = "IntArrayRef", stride = "IntArrayRef", padding = "IntArrayRef", 
    ceil_mode = "bool", count_include_pad = "bool", divisor_override = "int64_t")
nd_args <- c("grad_input", "grad_output", "self", "kernel_size", "stride", 
"padding", "ceil_mode", "count_include_pad", "divisor_override"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'avg_pool3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_avg_pool3d_out
torch_avg_pool3d_out <- function(out, self, kernel_size, stride = list(), padding = 0L, ceil_mode = FALSE, count_include_pad = TRUE, divisor_override = NULL) {
  args <- mget(x = c("out", "self", "kernel_size", "stride", "padding", "ceil_mode", "count_include_pad", "divisor_override"))
expected_types <- list(out = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", ceil_mode = "bool", 
    count_include_pad = "bool", divisor_override = "int64_t")
nd_args <- c("out", "self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'avg_pool3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_baddbmm
torch_baddbmm <- function(self, batch1, batch2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("self", "batch1", "batch2", "beta", "alpha"))
expected_types <- list(self = "Tensor", batch1 = "Tensor", batch2 = "Tensor", beta = "Scalar", 
    alpha = "Scalar")
nd_args <- c("self", "batch1", "batch2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'baddbmm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_baddbmm_out
torch_baddbmm_out <- function(out, self, batch1, batch2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("out", "self", "batch1", "batch2", "beta", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", batch1 = "Tensor", batch2 = "Tensor", 
    beta = "Scalar", alpha = "Scalar")
nd_args <- c("out", "self", "batch1", "batch2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'baddbmm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_bartlett_window
.torch_bartlett_window <- function(window_length, periodic, options = list()) {
  args <- mget(x = c("window_length", "periodic", "options"))
expected_types <- list(window_length = "int64_t", periodic = "bool", options = "TensorOptions")
nd_args <- c("window_length", "periodic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bartlett_window',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bartlett_window_out
torch_bartlett_window_out <- function(out, window_length, periodic) {
  args <- mget(x = c("out", "window_length", "periodic"))
expected_types <- list(out = "Tensor", window_length = "int64_t", periodic = "bool")
nd_args <- c("out", "window_length", "periodic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bartlett_window_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm
torch_batch_norm <- function(input, weight, bias, running_mean, running_var, training, momentum, eps, cudnn_enabled) {
  args <- mget(x = c("input", "weight", "bias", "running_mean", "running_var", "training", "momentum", "eps", "cudnn_enabled"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", momentum = "double", 
    eps = "double", cudnn_enabled = "bool")
nd_args <- c("input", "weight", "bias", "running_mean", "running_var", "training", 
"momentum", "eps", "cudnn_enabled")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'batch_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_backward_elemt
torch_batch_norm_backward_elemt <- function(grad_out, input, mean, invstd, weight, mean_dy, mean_dy_xmu, count) {
  args <- mget(x = c("grad_out", "input", "mean", "invstd", "weight", "mean_dy", "mean_dy_xmu", "count"))
expected_types <- list(grad_out = "Tensor", input = "Tensor", mean = "Tensor", 
    invstd = "Tensor", weight = "Tensor", mean_dy = "Tensor", 
    mean_dy_xmu = "Tensor", count = "Tensor")
nd_args <- c("grad_out", "input", "mean", "invstd", "weight", "mean_dy", 
"mean_dy_xmu", "count")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'batch_norm_backward_elemt',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_backward_elemt_out
torch_batch_norm_backward_elemt_out <- function(out, grad_out, input, mean, invstd, weight, mean_dy, mean_dy_xmu, count) {
  args <- mget(x = c("out", "grad_out", "input", "mean", "invstd", "weight", "mean_dy", "mean_dy_xmu", "count"))
expected_types <- list(out = "Tensor", grad_out = "Tensor", input = "Tensor", mean = "Tensor", 
    invstd = "Tensor", weight = "Tensor", mean_dy = "Tensor", 
    mean_dy_xmu = "Tensor", count = "Tensor")
nd_args <- c("out", "grad_out", "input", "mean", "invstd", "weight", "mean_dy", 
"mean_dy_xmu", "count")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'batch_norm_backward_elemt_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_backward_reduce
torch_batch_norm_backward_reduce <- function(grad_out, input, mean, invstd, weight, input_g, weight_g, bias_g) {
  args <- mget(x = c("grad_out", "input", "mean", "invstd", "weight", "input_g", "weight_g", "bias_g"))
expected_types <- list(grad_out = "Tensor", input = "Tensor", mean = "Tensor", 
    invstd = "Tensor", weight = "Tensor", input_g = "bool", weight_g = "bool", 
    bias_g = "bool")
nd_args <- c("grad_out", "input", "mean", "invstd", "weight", "input_g", 
"weight_g", "bias_g")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_backward_reduce',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_backward_reduce_out
torch_batch_norm_backward_reduce_out <- function(out0, out1, out2, out3, grad_out, input, mean, invstd, weight, input_g, weight_g, bias_g) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "grad_out", "input", "mean", "invstd", "weight", "input_g", "weight_g", "bias_g"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    grad_out = "Tensor", input = "Tensor", mean = "Tensor", invstd = "Tensor", 
    weight = "Tensor", input_g = "bool", weight_g = "bool", bias_g = "bool")
nd_args <- c("out0", "out1", "out2", "out3", "grad_out", "input", "mean", 
"invstd", "weight", "input_g", "weight_g", "bias_g")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_backward_reduce_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_elemt
torch_batch_norm_elemt <- function(input, weight, bias, mean, invstd, eps) {
  args <- mget(x = c("input", "weight", "bias", "mean", "invstd", "eps"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", mean = "Tensor", 
    invstd = "Tensor", eps = "double")
nd_args <- c("input", "weight", "bias", "mean", "invstd", "eps")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'batch_norm_elemt',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_elemt_out
torch_batch_norm_elemt_out <- function(out, input, weight, bias, mean, invstd, eps) {
  args <- mget(x = c("out", "input", "weight", "bias", "mean", "invstd", "eps"))
expected_types <- list(out = "Tensor", input = "Tensor", weight = "Tensor", bias = "Tensor", 
    mean = "Tensor", invstd = "Tensor", eps = "double")
nd_args <- c("out", "input", "weight", "bias", "mean", "invstd", "eps")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'batch_norm_elemt_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_gather_stats
torch_batch_norm_gather_stats <- function(input, mean, invstd, running_mean, running_var, momentum, eps, count) {
  args <- mget(x = c("input", "mean", "invstd", "running_mean", "running_var", "momentum", "eps", "count"))
expected_types <- list(input = "Tensor", mean = "Tensor", invstd = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", momentum = "double", eps = "double", 
    count = "int64_t")
nd_args <- c("input", "mean", "invstd", "running_mean", "running_var", "momentum", 
"eps", "count")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_gather_stats',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_gather_stats_out
torch_batch_norm_gather_stats_out <- function(out0, out1, input, mean, invstd, running_mean, running_var, momentum, eps, count) {
  args <- mget(x = c("out0", "out1", "input", "mean", "invstd", "running_mean", "running_var", "momentum", "eps", "count"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", input = "Tensor", mean = "Tensor", 
    invstd = "Tensor", running_mean = "Tensor", running_var = "Tensor", 
    momentum = "double", eps = "double", count = "int64_t")
nd_args <- c("out0", "out1", "input", "mean", "invstd", "running_mean", 
"running_var", "momentum", "eps", "count")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_gather_stats_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_gather_stats_with_counts
torch_batch_norm_gather_stats_with_counts <- function(input, mean, invstd, running_mean, running_var, momentum, eps, counts) {
  args <- mget(x = c("input", "mean", "invstd", "running_mean", "running_var", "momentum", "eps", "counts"))
expected_types <- list(input = "Tensor", mean = "Tensor", invstd = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", momentum = "double", eps = "double", 
    counts = "Tensor")
nd_args <- c("input", "mean", "invstd", "running_mean", "running_var", "momentum", 
"eps", "counts")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_gather_stats_with_counts',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_gather_stats_with_counts_out
torch_batch_norm_gather_stats_with_counts_out <- function(out0, out1, input, mean, invstd, running_mean, running_var, momentum, eps, counts) {
  args <- mget(x = c("out0", "out1", "input", "mean", "invstd", "running_mean", "running_var", "momentum", "eps", "counts"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", input = "Tensor", mean = "Tensor", 
    invstd = "Tensor", running_mean = "Tensor", running_var = "Tensor", 
    momentum = "double", eps = "double", counts = "Tensor")
nd_args <- c("out0", "out1", "input", "mean", "invstd", "running_mean", 
"running_var", "momentum", "eps", "counts")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_gather_stats_with_counts_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_stats
torch_batch_norm_stats <- function(input, eps) {
  args <- mget(x = c("input", "eps"))
expected_types <- list(input = "Tensor", eps = "double")
nd_args <- c("input", "eps")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_stats',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_stats_out
torch_batch_norm_stats_out <- function(out0, out1, input, eps) {
  args <- mget(x = c("out0", "out1", "input", "eps"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", input = "Tensor", eps = "double")
nd_args <- c("out0", "out1", "input", "eps")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_stats_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_update_stats
torch_batch_norm_update_stats <- function(input, running_mean, running_var, momentum) {
  args <- mget(x = c("input", "running_mean", "running_var", "momentum"))
expected_types <- list(input = "Tensor", running_mean = "Tensor", running_var = "Tensor", 
    momentum = "double")
nd_args <- c("input", "running_mean", "running_var", "momentum")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_update_stats',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_batch_norm_update_stats_out
torch_batch_norm_update_stats_out <- function(out0, out1, input, running_mean, running_var, momentum) {
  args <- mget(x = c("out0", "out1", "input", "running_mean", "running_var", "momentum"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", input = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", momentum = "double")
nd_args <- c("out0", "out1", "input", "running_mean", "running_var", "momentum"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'batch_norm_update_stats_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bernoulli
torch_bernoulli <- function(self, p, generator = NULL) {
  args <- mget(x = c("self", "p", "generator"))
expected_types <- list(self = "Tensor", p = c("double", "Tensor"), generator = "Generator")
nd_args <- c("self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bernoulli',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bernoulli_out
torch_bernoulli_out <- function(out, self, p = 0.5, generator = NULL) {
  args <- mget(x = c("out", "self", "p", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", p = c("Tensor", "double"
), generator = "Generator")
nd_args <- c("out", "self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bernoulli_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bilinear
torch_bilinear <- function(input1, input2, weight, bias = list()) {
  args <- mget(x = c("input1", "input2", "weight", "bias"))
expected_types <- list(input1 = "Tensor", input2 = "Tensor", weight = "Tensor", 
    bias = "Tensor")
nd_args <- c("input1", "input2", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bilinear',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_binary_cross_entropy
torch_binary_cross_entropy <- function(self, target, weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("self", "target", "weight", "reduction"))
expected_types <- list(self = "Tensor", target = "Tensor", weight = "Tensor", reduction = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'binary_cross_entropy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_binary_cross_entropy_backward
torch_binary_cross_entropy_backward <- function(grad_output, self, target, weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("grad_output", "self", "target", "weight", "reduction"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", target = "Tensor", 
    weight = "Tensor", reduction = "int64_t")
nd_args <- c("grad_output", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'binary_cross_entropy_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_binary_cross_entropy_backward_out
torch_binary_cross_entropy_backward_out <- function(grad_input, grad_output, self, target, weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("grad_input", "grad_output", "self", "target", "weight", "reduction"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    target = "Tensor", weight = "Tensor", reduction = "int64_t")
nd_args <- c("grad_input", "grad_output", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'binary_cross_entropy_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_binary_cross_entropy_out
torch_binary_cross_entropy_out <- function(out, self, target, weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("out", "self", "target", "weight", "reduction"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", weight = "Tensor", 
    reduction = "int64_t")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'binary_cross_entropy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_binary_cross_entropy_with_logits
torch_binary_cross_entropy_with_logits <- function(self, target, weight = list(), pos_weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("self", "target", "weight", "pos_weight", "reduction"))
expected_types <- list(self = "Tensor", target = "Tensor", weight = "Tensor", pos_weight = "Tensor", 
    reduction = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'binary_cross_entropy_with_logits',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_binary_cross_entropy_with_logits_out
torch_binary_cross_entropy_with_logits_out <- function(out, self, target, weight = list(), pos_weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("out", "self", "target", "weight", "pos_weight", "reduction"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", weight = "Tensor", 
    pos_weight = "Tensor", reduction = "int64_t")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'binary_cross_entropy_with_logits_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_bincount
.torch_bincount <- function(self, weights = list(), minlength = 0L) {
  args <- mget(x = c("self", "weights", "minlength"))
expected_types <- list(self = "Tensor", weights = "Tensor", minlength = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bincount',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bincount_out
torch_bincount_out <- function(out, self, weights = list(), minlength = 0L) {
  args <- mget(x = c("out", "self", "weights", "minlength"))
expected_types <- list(out = "Tensor", self = "Tensor", weights = "Tensor", minlength = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bincount_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_binomial
torch_binomial <- function(count, prob, generator = NULL) {
  args <- mget(x = c("count", "prob", "generator"))
expected_types <- list(count = "Tensor", prob = "Tensor", generator = "Generator")
nd_args <- c("count", "prob")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'binomial',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_binomial_out
torch_binomial_out <- function(out, count, prob, generator = NULL) {
  args <- mget(x = c("out", "count", "prob", "generator"))
expected_types <- list(out = "Tensor", count = "Tensor", prob = "Tensor", generator = "Generator")
nd_args <- c("out", "count", "prob")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'binomial_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_and
torch_bitwise_and <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Scalar", "Tensor"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_and',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_and_out
torch_bitwise_and_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_and_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_left_shift
torch_bitwise_left_shift <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Tensor", "Scalar"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_left_shift',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_left_shift_out
torch_bitwise_left_shift_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_left_shift_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_not
torch_bitwise_not <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_not',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_not_out
torch_bitwise_not_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_not_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_or
torch_bitwise_or <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Scalar", "Tensor"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_or',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_or_out
torch_bitwise_or_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_or_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_right_shift
torch_bitwise_right_shift <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Tensor", "Scalar"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_right_shift',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_right_shift_out
torch_bitwise_right_shift_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_right_shift_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_xor
torch_bitwise_xor <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Scalar", "Tensor"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_xor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bitwise_xor_out
torch_bitwise_xor_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bitwise_xor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_blackman_window
.torch_blackman_window <- function(window_length, periodic, options = list()) {
  args <- mget(x = c("window_length", "periodic", "options"))
expected_types <- list(window_length = "int64_t", periodic = "bool", options = "TensorOptions")
nd_args <- c("window_length", "periodic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'blackman_window',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_blackman_window_out
torch_blackman_window_out <- function(out, window_length, periodic) {
  args <- mget(x = c("out", "window_length", "periodic"))
expected_types <- list(out = "Tensor", window_length = "int64_t", periodic = "bool")
nd_args <- c("out", "window_length", "periodic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'blackman_window_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_block_diag
torch_block_diag <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'block_diag',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_block_diag_out
torch_block_diag_out <- function(out, tensors) {
  args <- mget(x = c("out", "tensors"))
expected_types <- list(out = "Tensor", tensors = "TensorList")
nd_args <- c("out", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'block_diag_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bmm
torch_bmm <- function(self, mat2) {
  args <- mget(x = c("self", "mat2"))
expected_types <- list(self = "Tensor", mat2 = "Tensor")
nd_args <- c("self", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bmm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bmm_out
torch_bmm_out <- function(out, self, mat2) {
  args <- mget(x = c("out", "self", "mat2"))
expected_types <- list(out = "Tensor", self = "Tensor", mat2 = "Tensor")
nd_args <- c("out", "self", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bmm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_broadcast_tensors
torch_broadcast_tensors <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'broadcast_tensors',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_broadcast_to
torch_broadcast_to <- function(self, size) {
  args <- mget(x = c("self", "size"))
expected_types <- list(self = "Tensor", size = "IntArrayRef")
nd_args <- c("self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'broadcast_to',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bucketize
torch_bucketize <- function(self, boundaries, out_int32 = FALSE, right = FALSE) {
  args <- mget(x = c("self", "boundaries", "out_int32", "right"))
expected_types <- list(self = c("Tensor", "Scalar"), boundaries = "Tensor", out_int32 = "bool", 
    right = "bool")
nd_args <- c("self", "boundaries")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bucketize',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_bucketize_out
torch_bucketize_out <- function(out, self, boundaries, out_int32 = FALSE, right = FALSE) {
  args <- mget(x = c("out", "self", "boundaries", "out_int32", "right"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), boundaries = "Tensor", 
    out_int32 = "bool", right = "bool")
nd_args <- c("out", "self", "boundaries")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'bucketize_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_can_cast
torch_can_cast <- function(from, to) {
  args <- mget(x = c("from", "to"))
expected_types <- list(from = "ScalarType", to = "ScalarType")
nd_args <- c("from", "to")
return_types <- list(list('bool'))
call_c_function(
fun_name = 'can_cast',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cartesian_prod
torch_cartesian_prod <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cartesian_prod',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cat
torch_cat <- function(tensors, dim = 1L) {
  args <- mget(x = c("tensors", "dim"))
expected_types <- list(tensors = "TensorList", dim = c("int64_t", "Dimname"))
nd_args <- c("tensors", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cat',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cat_out
torch_cat_out <- function(out, tensors, dim = 1L) {
  args <- mget(x = c("out", "tensors", "dim"))
expected_types <- list(out = "Tensor", tensors = "TensorList", dim = c("int64_t", 
"Dimname"))
nd_args <- c("out", "tensors", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cat_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cauchy
torch_cauchy <- function(self, median = 0L, sigma = 1L, generator = NULL) {
  args <- mget(x = c("self", "median", "sigma", "generator"))
expected_types <- list(self = "Tensor", median = "double", sigma = "double", generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cauchy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cauchy_out
torch_cauchy_out <- function(out, self, median = 0L, sigma = 1L, generator = NULL) {
  args <- mget(x = c("out", "self", "median", "sigma", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", median = "double", sigma = "double", 
    generator = "Generator")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cauchy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ccol_indices_copy
torch_ccol_indices_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ccol_indices_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ccol_indices_copy_out
torch_ccol_indices_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ccol_indices_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cdist
torch_cdist <- function(x1, x2, p = 2L, compute_mode = NULL) {
  args <- mget(x = c("x1", "x2", "p", "compute_mode"))
expected_types <- list(x1 = "Tensor", x2 = "Tensor", p = "double", compute_mode = "int64_t")
nd_args <- c("x1", "x2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cdist',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ceil
torch_ceil <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ceil',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ceil_
torch_ceil_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ceil_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ceil_out
torch_ceil_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ceil_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_celu
torch_celu <- function(self, alpha = 1L) {
  args <- mget(x = c("self", "alpha"))
expected_types <- list(self = "Tensor", alpha = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'celu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_celu_
torch_celu_ <- function(self, alpha = 1L) {
  args <- mget(x = c("self", "alpha"))
expected_types <- list(self = "Tensor", alpha = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'celu_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_celu_out
torch_celu_out <- function(out, self, alpha = 1L) {
  args <- mget(x = c("out", "self", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", alpha = "Scalar")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'celu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_chain_matmul
torch_chain_matmul <- function(matrices) {
  args <- mget(x = c("matrices"))
expected_types <- list(matrices = "TensorList")
nd_args <- "matrices"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'chain_matmul',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_chain_matmul_out
torch_chain_matmul_out <- function(out, matrices) {
  args <- mget(x = c("out", "matrices"))
expected_types <- list(out = "Tensor", matrices = "TensorList")
nd_args <- c("out", "matrices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'chain_matmul_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_channel_shuffle
torch_channel_shuffle <- function(self, groups) {
  args <- mget(x = c("self", "groups"))
expected_types <- list(self = "Tensor", groups = "int64_t")
nd_args <- c("self", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'channel_shuffle',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_channel_shuffle_out
torch_channel_shuffle_out <- function(out, self, groups) {
  args <- mget(x = c("out", "self", "groups"))
expected_types <- list(out = "Tensor", self = "Tensor", groups = "int64_t")
nd_args <- c("out", "self", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'channel_shuffle_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cholesky
torch_cholesky <- function(self, upper = FALSE) {
  args <- mget(x = c("self", "upper"))
expected_types <- list(self = "Tensor", upper = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cholesky',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cholesky_inverse
torch_cholesky_inverse <- function(self, upper = FALSE) {
  args <- mget(x = c("self", "upper"))
expected_types <- list(self = "Tensor", upper = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cholesky_inverse',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cholesky_inverse_out
torch_cholesky_inverse_out <- function(out, self, upper = FALSE) {
  args <- mget(x = c("out", "self", "upper"))
expected_types <- list(out = "Tensor", self = "Tensor", upper = "bool")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cholesky_inverse_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cholesky_out
torch_cholesky_out <- function(out, self, upper = FALSE) {
  args <- mget(x = c("out", "self", "upper"))
expected_types <- list(out = "Tensor", self = "Tensor", upper = "bool")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cholesky_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cholesky_solve
torch_cholesky_solve <- function(self, input2, upper = FALSE) {
  args <- mget(x = c("self", "input2", "upper"))
expected_types <- list(self = "Tensor", input2 = "Tensor", upper = "bool")
nd_args <- c("self", "input2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cholesky_solve',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cholesky_solve_out
torch_cholesky_solve_out <- function(out, self, input2, upper = FALSE) {
  args <- mget(x = c("out", "self", "input2", "upper"))
expected_types <- list(out = "Tensor", self = "Tensor", input2 = "Tensor", upper = "bool")
nd_args <- c("out", "self", "input2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cholesky_solve_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_choose_qparams_optimized
torch_choose_qparams_optimized <- function(input, numel, n_bins, ratio, bit_width) {
  args <- mget(x = c("input", "numel", "n_bins", "ratio", "bit_width"))
expected_types <- list(input = "Tensor", numel = "int64_t", n_bins = "int64_t", 
    ratio = "double", bit_width = "int64_t")
nd_args <- c("input", "numel", "n_bins", "ratio", "bit_width")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'choose_qparams_optimized',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_chunk
torch_chunk <- function(self, chunks, dim = 1L) {
  args <- mget(x = c("self", "chunks", "dim"))
expected_types <- list(self = "Tensor", chunks = "int64_t", dim = "int64_t")
nd_args <- c("self", "chunks")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'chunk',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clamp
torch_clamp <- function(self, min = NULL, max = NULL) {
  args <- mget(x = c("self", "min", "max"))
expected_types <- list(self = "Tensor", min = c("Scalar", "Tensor"), max = c("Scalar", 
"Tensor"))
nd_args <- c("self", "min", "max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clamp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clamp_
torch_clamp_ <- function(self, min = NULL, max = NULL) {
  args <- mget(x = c("self", "min", "max"))
expected_types <- list(self = "Tensor", min = c("Scalar", "Tensor"), max = c("Scalar", 
"Tensor"))
nd_args <- c("self", "min", "max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clamp_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clamp_max
torch_clamp_max <- function(self, max) {
  args <- mget(x = c("self", "max"))
expected_types <- list(self = "Tensor", max = c("Scalar", "Tensor"))
nd_args <- c("self", "max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clamp_max',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clamp_max_
torch_clamp_max_ <- function(self, max) {
  args <- mget(x = c("self", "max"))
expected_types <- list(self = "Tensor", max = c("Scalar", "Tensor"))
nd_args <- c("self", "max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clamp_max_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clamp_max_out
torch_clamp_max_out <- function(out, self, max) {
  args <- mget(x = c("out", "self", "max"))
expected_types <- list(out = "Tensor", self = "Tensor", max = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clamp_max_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clamp_min
torch_clamp_min <- function(self, min) {
  args <- mget(x = c("self", "min"))
expected_types <- list(self = "Tensor", min = c("Scalar", "Tensor"))
nd_args <- c("self", "min")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clamp_min',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clamp_min_
torch_clamp_min_ <- function(self, min) {
  args <- mget(x = c("self", "min"))
expected_types <- list(self = "Tensor", min = c("Scalar", "Tensor"))
nd_args <- c("self", "min")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clamp_min_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clamp_min_out
torch_clamp_min_out <- function(out, self, min) {
  args <- mget(x = c("out", "self", "min"))
expected_types <- list(out = "Tensor", self = "Tensor", min = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "min")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clamp_min_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clamp_out
torch_clamp_out <- function(out, self, min = NULL, max = NULL) {
  args <- mget(x = c("out", "self", "min", "max"))
expected_types <- list(out = "Tensor", self = "Tensor", min = c("Scalar", "Tensor"
), max = c("Scalar", "Tensor"))
nd_args <- c("out", "self", "min", "max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clamp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clip
torch_clip <- function(self, min = NULL, max = NULL) {
  args <- mget(x = c("self", "min", "max"))
expected_types <- list(self = "Tensor", min = c("Scalar", "Tensor"), max = c("Scalar", 
"Tensor"))
nd_args <- c("self", "min", "max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clip',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clip_
torch_clip_ <- function(self, min = NULL, max = NULL) {
  args <- mget(x = c("self", "min", "max"))
expected_types <- list(self = "Tensor", min = c("Scalar", "Tensor"), max = c("Scalar", 
"Tensor"))
nd_args <- c("self", "min", "max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clip_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clip_out
torch_clip_out <- function(out, self, min = NULL, max = NULL) {
  args <- mget(x = c("out", "self", "min", "max"))
expected_types <- list(out = "Tensor", self = "Tensor", min = c("Scalar", "Tensor"
), max = c("Scalar", "Tensor"))
nd_args <- c("out", "self", "min", "max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clip_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clone
torch_clone <- function(self, memory_format = NULL) {
  args <- mget(x = c("self", "memory_format"))
expected_types <- list(self = "Tensor", memory_format = "MemoryFormat")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clone',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_clone_out
torch_clone_out <- function(out, self, memory_format = NULL) {
  args <- mget(x = c("out", "self", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", memory_format = "MemoryFormat")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'clone_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_col_indices_copy
torch_col_indices_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'col_indices_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_col_indices_copy_out
torch_col_indices_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'col_indices_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_col2im
torch_col2im <- function(self, output_size, kernel_size, dilation, padding, stride) {
  args <- mget(x = c("self", "output_size", "kernel_size", "dilation", "padding", "stride"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef", kernel_size = "IntArrayRef", 
    dilation = "IntArrayRef", padding = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("self", "output_size", "kernel_size", "dilation", "padding", 
"stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'col2im',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_col2im_out
torch_col2im_out <- function(out, self, output_size, kernel_size, dilation, padding, stride) {
  args <- mget(x = c("out", "self", "output_size", "kernel_size", "dilation", "padding", "stride"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    kernel_size = "IntArrayRef", dilation = "IntArrayRef", padding = "IntArrayRef", 
    stride = "IntArrayRef")
nd_args <- c("out", "self", "output_size", "kernel_size", "dilation", "padding", 
"stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'col2im_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_column_stack
torch_column_stack <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'column_stack',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_column_stack_out
torch_column_stack_out <- function(out, tensors) {
  args <- mget(x = c("out", "tensors"))
expected_types <- list(out = "Tensor", tensors = "TensorList")
nd_args <- c("out", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'column_stack_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_combinations
torch_combinations <- function(self, r = 2L, with_replacement = FALSE) {
  args <- mget(x = c("self", "r", "with_replacement"))
expected_types <- list(self = "Tensor", r = "int64_t", with_replacement = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'combinations',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_complex
torch_complex <- function(real, imag) {
  args <- mget(x = c("real", "imag"))
expected_types <- list(real = "Tensor", imag = "Tensor")
nd_args <- c("real", "imag")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'complex',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_complex_out
torch_complex_out <- function(out, real, imag) {
  args <- mget(x = c("out", "real", "imag"))
expected_types <- list(out = "Tensor", real = "Tensor", imag = "Tensor")
nd_args <- c("out", "real", "imag")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'complex_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_concat
torch_concat <- function(tensors, dim = 1L) {
  args <- mget(x = c("tensors", "dim"))
expected_types <- list(tensors = "TensorList", dim = c("int64_t", "Dimname"))
nd_args <- c("tensors", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'concat',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_concat_out
torch_concat_out <- function(out, tensors, dim = 1L) {
  args <- mget(x = c("out", "tensors", "dim"))
expected_types <- list(out = "Tensor", tensors = "TensorList", dim = c("int64_t", 
"Dimname"))
nd_args <- c("out", "tensors", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'concat_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_concatenate
torch_concatenate <- function(tensors, dim = 1L) {
  args <- mget(x = c("tensors", "dim"))
expected_types <- list(tensors = "TensorList", dim = c("int64_t", "Dimname"))
nd_args <- c("tensors", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'concatenate',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_concatenate_out
torch_concatenate_out <- function(out, tensors, dim = 1L) {
  args <- mget(x = c("out", "tensors", "dim"))
expected_types <- list(out = "Tensor", tensors = "TensorList", dim = c("int64_t", 
"Dimname"))
nd_args <- c("out", "tensors", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'concatenate_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conj
torch_conj <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conj',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conj_physical
torch_conj_physical <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conj_physical',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conj_physical_
torch_conj_physical_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conj_physical_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conj_physical_out
torch_conj_physical_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conj_physical_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_constant_pad_nd
torch_constant_pad_nd <- function(self, pad, value = 0L) {
  args <- mget(x = c("self", "pad", "value"))
expected_types <- list(self = "Tensor", pad = "IntArrayRef", value = "Scalar")
nd_args <- c("self", "pad")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'constant_pad_nd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_constant_pad_nd_out
torch_constant_pad_nd_out <- function(out, self, pad, value = 0L) {
  args <- mget(x = c("out", "self", "pad", "value"))
expected_types <- list(out = "Tensor", self = "Tensor", pad = "IntArrayRef", value = "Scalar")
nd_args <- c("out", "self", "pad")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'constant_pad_nd_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv_depthwise3d
torch_conv_depthwise3d <- function(self, weight, kernel_size, bias, stride, padding, dilation) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding", "dilation"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size", "bias", "stride", "padding", 
"dilation")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv_depthwise3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv_depthwise3d_out
torch_conv_depthwise3d_out <- function(out, self, weight, kernel_size, bias, stride, padding, dilation) {
  args <- mget(x = c("out", "self", "weight", "kernel_size", "bias", "stride", "padding", "dilation"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef")
nd_args <- c("out", "self", "weight", "kernel_size", "bias", "stride", "padding", 
"dilation")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv_depthwise3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv_tbc
torch_conv_tbc <- function(self, weight, bias, pad = 0L) {
  args <- mget(x = c("self", "weight", "bias", "pad"))
expected_types <- list(self = "Tensor", weight = "Tensor", bias = "Tensor", pad = "int64_t")
nd_args <- c("self", "weight", "bias")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv_tbc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv_tbc_backward
torch_conv_tbc_backward <- function(self, input, weight, bias, pad) {
  args <- mget(x = c("self", "input", "weight", "bias", "pad"))
expected_types <- list(self = "Tensor", input = "Tensor", weight = "Tensor", bias = "Tensor", 
    pad = "int64_t")
nd_args <- c("self", "input", "weight", "bias", "pad")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'conv_tbc_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv_tbc_out
torch_conv_tbc_out <- function(out, self, weight, bias, pad = 0L) {
  args <- mget(x = c("out", "self", "weight", "bias", "pad"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", bias = "Tensor", 
    pad = "int64_t")
nd_args <- c("out", "self", "weight", "bias")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv_tbc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv_transpose1d
torch_conv_transpose1d <- function(input, weight, bias = list(), stride = 1L, padding = 0L, output_padding = 0L, groups = 1L, dilation = 1L) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "output_padding", "groups", "dilation"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", output_padding = "IntArrayRef", 
    groups = "int64_t", dilation = "IntArrayRef")
nd_args <- c("input", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv_transpose1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv_transpose2d
torch_conv_transpose2d <- function(input, weight, bias = list(), stride = 1L, padding = 0L, output_padding = 0L, groups = 1L, dilation = 1L) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "output_padding", "groups", "dilation"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", output_padding = "IntArrayRef", 
    groups = "int64_t", dilation = "IntArrayRef")
nd_args <- c("input", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv_transpose2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv_transpose3d
torch_conv_transpose3d <- function(input, weight, bias = list(), stride = 1L, padding = 0L, output_padding = 0L, groups = 1L, dilation = 1L) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "output_padding", "groups", "dilation"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", output_padding = "IntArrayRef", 
    groups = "int64_t", dilation = "IntArrayRef")
nd_args <- c("input", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv_transpose3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv1d
torch_conv1d <- function(input, weight, bias = list(), stride = 1L, padding = 0L, dilation = 1L, groups = 1L) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = c("IntArrayRef", "c10::string_view"), dilation = "IntArrayRef", 
    groups = "int64_t")
nd_args <- c("input", "weight", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv2d
torch_conv2d <- function(input, weight, bias = list(), stride = 1L, padding = 0L, dilation = 1L, groups = 1L) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = c("IntArrayRef", "c10::string_view"), dilation = "IntArrayRef", 
    groups = "int64_t")
nd_args <- c("input", "weight", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_conv3d
torch_conv3d <- function(input, weight, bias = list(), stride = 1L, padding = 0L, dilation = 1L, groups = 1L) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = c("IntArrayRef", "c10::string_view"), dilation = "IntArrayRef", 
    groups = "int64_t")
nd_args <- c("input", "weight", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'conv3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_convolution
torch_convolution <- function(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "dilation", "transposed", "output_padding", "groups"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", transposed = "bool", 
    output_padding = "IntArrayRef", groups = "int64_t")
nd_args <- c("input", "weight", "bias", "stride", "padding", "dilation", 
"transposed", "output_padding", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'convolution',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_convolution_backward
torch_convolution_backward <- function(grad_output, input, weight, bias_sizes, stride, padding, dilation, transposed, output_padding, groups, output_mask) {
  args <- mget(x = c("grad_output", "input", "weight", "bias_sizes", "stride", "padding", "dilation", "transposed", "output_padding", "groups", "output_mask"))
expected_types <- list(grad_output = "Tensor", input = "Tensor", weight = "Tensor", 
    bias_sizes = "IntArrayRef", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef", transposed = "bool", output_padding = "IntArrayRef", 
    groups = "int64_t", output_mask = "::std::array<bool,3>")
nd_args <- c("grad_output", "input", "weight", "bias_sizes", "stride", "padding", 
"dilation", "transposed", "output_padding", "groups", "output_mask"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'convolution_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_convolution_backward_out
torch_convolution_backward_out <- function(out0, out1, out2, grad_output, input, weight, bias_sizes, stride, padding, dilation, transposed, output_padding, groups, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "grad_output", "input", "weight", "bias_sizes", "stride", "padding", "dilation", "transposed", "output_padding", "groups", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", grad_output = "Tensor", 
    input = "Tensor", weight = "Tensor", bias_sizes = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    transposed = "bool", output_padding = "IntArrayRef", groups = "int64_t", 
    output_mask = "::std::array<bool,3>")
nd_args <- c("out0", "out1", "out2", "grad_output", "input", "weight", "bias_sizes", 
"stride", "padding", "dilation", "transposed", "output_padding", 
"groups", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'convolution_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_convolution_backward_overrideable
torch_convolution_backward_overrideable <- function(grad_output, input, weight, stride, padding, dilation, transposed, output_padding, groups, output_mask) {
  args <- mget(x = c("grad_output", "input", "weight", "stride", "padding", "dilation", "transposed", "output_padding", "groups", "output_mask"))
expected_types <- list(grad_output = "Tensor", input = "Tensor", weight = "Tensor", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    transposed = "bool", output_padding = "IntArrayRef", groups = "int64_t", 
    output_mask = "::std::array<bool,3>")
nd_args <- c("grad_output", "input", "weight", "stride", "padding", "dilation", 
"transposed", "output_padding", "groups", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'convolution_backward_overrideable',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_convolution_backward_overrideable_out
torch_convolution_backward_overrideable_out <- function(out0, out1, out2, grad_output, input, weight, stride, padding, dilation, transposed, output_padding, groups, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "grad_output", "input", "weight", "stride", "padding", "dilation", "transposed", "output_padding", "groups", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", grad_output = "Tensor", 
    input = "Tensor", weight = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", transposed = "bool", 
    output_padding = "IntArrayRef", groups = "int64_t", output_mask = "::std::array<bool,3>")
nd_args <- c("out0", "out1", "out2", "grad_output", "input", "weight", "stride", 
"padding", "dilation", "transposed", "output_padding", "groups", 
"output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'convolution_backward_overrideable_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_convolution_out
torch_convolution_out <- function(out, input, weight, bias, stride, padding, dilation, transposed, output_padding, groups) {
  args <- mget(x = c("out", "input", "weight", "bias", "stride", "padding", "dilation", "transposed", "output_padding", "groups"))
expected_types <- list(out = "Tensor", input = "Tensor", weight = "Tensor", bias = "Tensor", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    transposed = "bool", output_padding = "IntArrayRef", groups = "int64_t")
nd_args <- c("out", "input", "weight", "bias", "stride", "padding", "dilation", 
"transposed", "output_padding", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'convolution_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_convolution_overrideable
torch_convolution_overrideable <- function(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups) {
  args <- mget(x = c("input", "weight", "bias", "stride", "padding", "dilation", "transposed", "output_padding", "groups"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", transposed = "bool", 
    output_padding = "IntArrayRef", groups = "int64_t")
nd_args <- c("input", "weight", "bias", "stride", "padding", "dilation", 
"transposed", "output_padding", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'convolution_overrideable',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_convolution_overrideable_out
torch_convolution_overrideable_out <- function(out, input, weight, bias, stride, padding, dilation, transposed, output_padding, groups) {
  args <- mget(x = c("out", "input", "weight", "bias", "stride", "padding", "dilation", "transposed", "output_padding", "groups"))
expected_types <- list(out = "Tensor", input = "Tensor", weight = "Tensor", bias = "Tensor", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    transposed = "bool", output_padding = "IntArrayRef", groups = "int64_t")
nd_args <- c("out", "input", "weight", "bias", "stride", "padding", "dilation", 
"transposed", "output_padding", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'convolution_overrideable_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_copy
torch_copy <- function(self, src, non_blocking = FALSE) {
  args <- mget(x = c("self", "src", "non_blocking"))
expected_types <- list(self = "Tensor", src = "Tensor", non_blocking = "bool")
nd_args <- c("self", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_copy_out
torch_copy_out <- function(out, self, src, non_blocking = FALSE) {
  args <- mget(x = c("out", "self", "src", "non_blocking"))
expected_types <- list(out = "Tensor", self = "Tensor", src = "Tensor", non_blocking = "bool")
nd_args <- c("out", "self", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_copy_sparse_to_sparse
torch_copy_sparse_to_sparse <- function(self, src, non_blocking = FALSE) {
  args <- mget(x = c("self", "src", "non_blocking"))
expected_types <- list(self = "Tensor", src = "Tensor", non_blocking = "bool")
nd_args <- c("self", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'copy_sparse_to_sparse',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_copy_sparse_to_sparse_
torch_copy_sparse_to_sparse_ <- function(self, src, non_blocking = FALSE) {
  args <- mget(x = c("self", "src", "non_blocking"))
expected_types <- list(self = "Tensor", src = "Tensor", non_blocking = "bool")
nd_args <- c("self", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'copy_sparse_to_sparse_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_copy_sparse_to_sparse_out
torch_copy_sparse_to_sparse_out <- function(out, self, src, non_blocking = FALSE) {
  args <- mget(x = c("out", "self", "src", "non_blocking"))
expected_types <- list(out = "Tensor", self = "Tensor", src = "Tensor", non_blocking = "bool")
nd_args <- c("out", "self", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'copy_sparse_to_sparse_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_copysign
torch_copysign <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'copysign',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_copysign_out
torch_copysign_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Tensor", "Scalar"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'copysign_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_corrcoef
torch_corrcoef <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'corrcoef',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cos
torch_cos <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cos',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cos_
torch_cos_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cos_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cos_out
torch_cos_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cos_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cosh
torch_cosh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cosh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cosh_
torch_cosh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cosh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cosh_out
torch_cosh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cosh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cosine_embedding_loss
torch_cosine_embedding_loss <- function(input1, input2, target, margin = 0L, reduction = torch_reduction_mean()) {
  args <- mget(x = c("input1", "input2", "target", "margin", "reduction"))
expected_types <- list(input1 = "Tensor", input2 = "Tensor", target = "Tensor", 
    margin = "double", reduction = "int64_t")
nd_args <- c("input1", "input2", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cosine_embedding_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cosine_similarity
torch_cosine_similarity <- function(x1, x2, dim = 2L, eps = 1e-08) {
  args <- mget(x = c("x1", "x2", "dim", "eps"))
expected_types <- list(x1 = "Tensor", x2 = "Tensor", dim = "int64_t", eps = "double")
nd_args <- c("x1", "x2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cosine_similarity',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_count_nonzero
torch_count_nonzero <- function(self, dim = NULL) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = c("IntArrayRef", "int64_t"))
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'count_nonzero',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_count_nonzero_out
torch_count_nonzero_out <- function(out, self, dim = NULL) {
  args <- mget(x = c("out", "self", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("IntArrayRef", 
"int64_t"))
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'count_nonzero_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cov
torch_cov <- function(self, correction = 1L, fweights = list(), aweights = list()) {
  args <- mget(x = c("self", "correction", "fweights", "aweights"))
expected_types <- list(self = "Tensor", correction = "int64_t", fweights = "Tensor", 
    aweights = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cov',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cross
torch_cross <- function(self, other, dim = NULL) {
  args <- mget(x = c("self", "other", "dim"))
expected_types <- list(self = "Tensor", other = "Tensor", dim = "int64_t")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cross',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_cross_entropy_loss
.torch_cross_entropy_loss <- function(self, target, weight = list(), reduction = torch_reduction_mean(), ignore_index = -100L, label_smoothing = 0L) {
  args <- mget(x = c("self", "target", "weight", "reduction", "ignore_index", "label_smoothing"))
expected_types <- list(self = "Tensor", target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t", label_smoothing = "double")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cross_entropy_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cross_out
torch_cross_out <- function(out, self, other, dim = NULL) {
  args <- mget(x = c("out", "self", "other", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor", dim = "int64_t")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cross_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_crow_indices_copy
torch_crow_indices_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'crow_indices_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_crow_indices_copy_out
torch_crow_indices_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'crow_indices_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ctc_loss
torch_ctc_loss <- function(log_probs, targets, input_lengths, target_lengths, blank = 0L, reduction = torch_reduction_mean(), zero_infinity = FALSE) {
  args <- mget(x = c("log_probs", "targets", "input_lengths", "target_lengths", "blank", "reduction", "zero_infinity"))
expected_types <- list(log_probs = "Tensor", targets = "Tensor", input_lengths = c("IntArrayRef", 
"Tensor"), target_lengths = c("IntArrayRef", "Tensor"), blank = "int64_t", 
    reduction = "int64_t", zero_infinity = "bool")
nd_args <- c("log_probs", "targets", "input_lengths", "target_lengths")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ctc_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_affine_grid_generator
torch_cudnn_affine_grid_generator <- function(theta, False, C, H, W) {
  args <- mget(x = c("theta", "False", "C", "H", "W"))
expected_types <- list(theta = "Tensor", False = "int64_t", C = "int64_t", H = "int64_t", 
    W = "int64_t")
nd_args <- c("theta", "False", "C", "H", "W")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_affine_grid_generator',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_affine_grid_generator_backward
torch_cudnn_affine_grid_generator_backward <- function(grad, False, C, H, W) {
  args <- mget(x = c("grad", "False", "C", "H", "W"))
expected_types <- list(grad = "Tensor", False = "int64_t", C = "int64_t", H = "int64_t", 
    W = "int64_t")
nd_args <- c("grad", "False", "C", "H", "W")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_affine_grid_generator_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_affine_grid_generator_backward_out
torch_cudnn_affine_grid_generator_backward_out <- function(out, grad, False, C, H, W) {
  args <- mget(x = c("out", "grad", "False", "C", "H", "W"))
expected_types <- list(out = "Tensor", grad = "Tensor", False = "int64_t", C = "int64_t", 
    H = "int64_t", W = "int64_t")
nd_args <- c("out", "grad", "False", "C", "H", "W")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_affine_grid_generator_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_affine_grid_generator_out
torch_cudnn_affine_grid_generator_out <- function(out, theta, False, C, H, W) {
  args <- mget(x = c("out", "theta", "False", "C", "H", "W"))
expected_types <- list(out = "Tensor", theta = "Tensor", False = "int64_t", C = "int64_t", 
    H = "int64_t", W = "int64_t")
nd_args <- c("out", "theta", "False", "C", "H", "W")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_affine_grid_generator_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_batch_norm
torch_cudnn_batch_norm <- function(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon) {
  args <- mget(x = c("input", "weight", "bias", "running_mean", "running_var", "training", "exponential_average_factor", "epsilon"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", exponential_average_factor = "double", 
    epsilon = "double")
nd_args <- c("input", "weight", "bias", "running_mean", "running_var", "training", 
"exponential_average_factor", "epsilon")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'cudnn_batch_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_batch_norm_backward
torch_cudnn_batch_norm_backward <- function(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, reserveSpace) {
  args <- mget(x = c("input", "grad_output", "weight", "running_mean", "running_var", "save_mean", "save_var", "epsilon", "reserveSpace"))
expected_types <- list(input = "Tensor", grad_output = "Tensor", weight = "Tensor", 
    running_mean = "Tensor", running_var = "Tensor", save_mean = "Tensor", 
    save_var = "Tensor", epsilon = "double", reserveSpace = "Tensor")
nd_args <- c("input", "grad_output", "weight", "running_mean", "running_var", 
"save_mean", "save_var", "epsilon", "reserveSpace")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'cudnn_batch_norm_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_batch_norm_backward_out
torch_cudnn_batch_norm_backward_out <- function(out0, out1, out2, input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, reserveSpace) {
  args <- mget(x = c("out0", "out1", "out2", "input", "grad_output", "weight", "running_mean", "running_var", "save_mean", "save_var", "epsilon", "reserveSpace"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", input = "Tensor", 
    grad_output = "Tensor", weight = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", save_mean = "Tensor", save_var = "Tensor", 
    epsilon = "double", reserveSpace = "Tensor")
nd_args <- c("out0", "out1", "out2", "input", "grad_output", "weight", "running_mean", 
"running_var", "save_mean", "save_var", "epsilon", "reserveSpace"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'cudnn_batch_norm_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_batch_norm_out
torch_cudnn_batch_norm_out <- function(out0, out1, out2, out3, input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "input", "weight", "bias", "running_mean", "running_var", "training", "exponential_average_factor", "epsilon"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", exponential_average_factor = "double", 
    epsilon = "double")
nd_args <- c("out0", "out1", "out2", "out3", "input", "weight", "bias", 
"running_mean", "running_var", "training", "exponential_average_factor", 
"epsilon")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'cudnn_batch_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_convolution
torch_cudnn_convolution <- function(self, weight, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32) {
  args <- mget(x = c("self", "weight", "padding", "stride", "dilation", "groups", "benchmark", "deterministic", "allow_tf32"))
expected_types <- list(self = "Tensor", weight = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t", 
    benchmark = "bool", deterministic = "bool", allow_tf32 = "bool")
nd_args <- c("self", "weight", "padding", "stride", "dilation", "groups", 
"benchmark", "deterministic", "allow_tf32")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_convolution',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_convolution_add_relu
torch_cudnn_convolution_add_relu <- function(self, weight, z, alpha, bias, stride, padding, dilation, groups) {
  args <- mget(x = c("self", "weight", "z", "alpha", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(self = "Tensor", weight = "Tensor", z = "Tensor", alpha = "Scalar", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef", groups = "int64_t")
nd_args <- c("self", "weight", "z", "alpha", "bias", "stride", "padding", 
"dilation", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_convolution_add_relu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_convolution_add_relu_out
torch_cudnn_convolution_add_relu_out <- function(out, self, weight, z, alpha, bias, stride, padding, dilation, groups) {
  args <- mget(x = c("out", "self", "weight", "z", "alpha", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", z = "Tensor", 
    alpha = "Scalar", bias = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t")
nd_args <- c("out", "self", "weight", "z", "alpha", "bias", "stride", "padding", 
"dilation", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_convolution_add_relu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_convolution_out
torch_cudnn_convolution_out <- function(out, self, weight, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32) {
  args <- mget(x = c("out", "self", "weight", "padding", "stride", "dilation", "groups", "benchmark", "deterministic", "allow_tf32"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t", 
    benchmark = "bool", deterministic = "bool", allow_tf32 = "bool")
nd_args <- c("out", "self", "weight", "padding", "stride", "dilation", "groups", 
"benchmark", "deterministic", "allow_tf32")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_convolution_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_convolution_relu
torch_cudnn_convolution_relu <- function(self, weight, bias, stride, padding, dilation, groups) {
  args <- mget(x = c("self", "weight", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(self = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t")
nd_args <- c("self", "weight", "bias", "stride", "padding", "dilation", 
"groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_convolution_relu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_convolution_relu_out
torch_cudnn_convolution_relu_out <- function(out, self, weight, bias, stride, padding, dilation, groups) {
  args <- mget(x = c("out", "self", "weight", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", bias = "Tensor", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t")
nd_args <- c("out", "self", "weight", "bias", "stride", "padding", "dilation", 
"groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_convolution_relu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_convolution_transpose
torch_cudnn_convolution_transpose <- function(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32) {
  args <- mget(x = c("self", "weight", "padding", "output_padding", "stride", "dilation", "groups", "benchmark", "deterministic", "allow_tf32"))
expected_types <- list(self = "Tensor", weight = "Tensor", padding = "IntArrayRef", 
    output_padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t", benchmark = "bool", deterministic = "bool", 
    allow_tf32 = "bool")
nd_args <- c("self", "weight", "padding", "output_padding", "stride", "dilation", 
"groups", "benchmark", "deterministic", "allow_tf32")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_convolution_transpose',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_convolution_transpose_out
torch_cudnn_convolution_transpose_out <- function(out, self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32) {
  args <- mget(x = c("out", "self", "weight", "padding", "output_padding", "stride", "dilation", "groups", "benchmark", "deterministic", "allow_tf32"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", padding = "IntArrayRef", 
    output_padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t", benchmark = "bool", deterministic = "bool", 
    allow_tf32 = "bool")
nd_args <- c("out", "self", "weight", "padding", "output_padding", "stride", 
"dilation", "groups", "benchmark", "deterministic", "allow_tf32"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_convolution_transpose_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_grid_sampler
torch_cudnn_grid_sampler <- function(self, grid) {
  args <- mget(x = c("self", "grid"))
expected_types <- list(self = "Tensor", grid = "Tensor")
nd_args <- c("self", "grid")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_grid_sampler',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_grid_sampler_backward
torch_cudnn_grid_sampler_backward <- function(self, grid, grad_output) {
  args <- mget(x = c("self", "grid", "grad_output"))
expected_types <- list(self = "Tensor", grid = "Tensor", grad_output = "Tensor")
nd_args <- c("self", "grid", "grad_output")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'cudnn_grid_sampler_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_grid_sampler_backward_out
torch_cudnn_grid_sampler_backward_out <- function(out0, out1, self, grid, grad_output) {
  args <- mget(x = c("out0", "out1", "self", "grid", "grad_output"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", self = "Tensor", grid = "Tensor", 
    grad_output = "Tensor")
nd_args <- c("out0", "out1", "self", "grid", "grad_output")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'cudnn_grid_sampler_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_grid_sampler_out
torch_cudnn_grid_sampler_out <- function(out, self, grid) {
  args <- mget(x = c("out", "self", "grid"))
expected_types <- list(out = "Tensor", self = "Tensor", grid = "Tensor")
nd_args <- c("out", "self", "grid")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cudnn_grid_sampler_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cudnn_is_acceptable
torch_cudnn_is_acceptable <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = 'cudnn_is_acceptable',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cummax
torch_cummax <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"))
nd_args <- c("self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'cummax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cummax_out
torch_cummax_out <- function(values, indices, self, dim) {
  args <- mget(x = c("values", "indices", "self", "dim"))
expected_types <- list(values = "Tensor", indices = "Tensor", self = "Tensor", 
    dim = c("int64_t", "Dimname"))
nd_args <- c("values", "indices", "self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'cummax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cummaxmin_backward
torch_cummaxmin_backward <- function(grad, input, indices, dim) {
  args <- mget(x = c("grad", "input", "indices", "dim"))
expected_types <- list(grad = "Tensor", input = "Tensor", indices = "Tensor", dim = "int64_t")
nd_args <- c("grad", "input", "indices", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cummaxmin_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cummin
torch_cummin <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"))
nd_args <- c("self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'cummin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cummin_out
torch_cummin_out <- function(values, indices, self, dim) {
  args <- mget(x = c("values", "indices", "self", "dim"))
expected_types <- list(values = "Tensor", indices = "Tensor", self = "Tensor", 
    dim = c("int64_t", "Dimname"))
nd_args <- c("values", "indices", "self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'cummin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cumprod
torch_cumprod <- function(self, dim, dtype = NULL) {
  args <- mget(x = c("self", "dim", "dtype"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cumprod',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cumprod_backward
torch_cumprod_backward <- function(grad, input, dim, output) {
  args <- mget(x = c("grad", "input", "dim", "output"))
expected_types <- list(grad = "Tensor", input = "Tensor", dim = "int64_t", output = "Tensor")
nd_args <- c("grad", "input", "dim", "output")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cumprod_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cumprod_out
torch_cumprod_out <- function(out, self, dim, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("int64_t", "Dimname"
), dtype = "ScalarType")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cumprod_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cumsum
torch_cumsum <- function(self, dim, dtype = NULL) {
  args <- mget(x = c("self", "dim", "dtype"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cumsum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cumsum_out
torch_cumsum_out <- function(out, self, dim, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("int64_t", "Dimname"
), dtype = "ScalarType")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cumsum_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_cumulative_trapezoid
torch_cumulative_trapezoid <- function(y, dx = 1L, x, dim = -1L) {
  args <- mget(x = c("y", "dx", "x", "dim"))
expected_types <- list(y = "Tensor", dx = "Scalar", x = "Tensor", dim = "int64_t")
nd_args <- c("y", "x")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'cumulative_trapezoid',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_deg2rad
torch_deg2rad <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'deg2rad',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_deg2rad_
torch_deg2rad_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'deg2rad_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_deg2rad_out
torch_deg2rad_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'deg2rad_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_dequantize
.torch_dequantize <- function(self, tensors) {
  args <- mget(x = c("self", "tensors"))
expected_types <- list(self = "Tensor", tensors = "TensorList")
nd_args <- c("self", "tensors")
return_types <- list(list('Tensor'), list('TensorList'))
call_c_function(
fun_name = 'dequantize',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dequantize_out
torch_dequantize_out <- function(out, self, tensors) {
  args <- mget(x = c("out", "self", "tensors"))
expected_types <- list(out = c("Tensor", "TensorList"), self = "Tensor", tensors = "TensorList")
nd_args <- c("out", "self", "tensors")
return_types <- list(list('Tensor'), list("void"))
call_c_function(
fun_name = 'dequantize_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_det
torch_det <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'det',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_detach
torch_detach <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'detach',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_detach_
torch_detach_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'detach_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_detach_copy
torch_detach_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'detach_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_detach_copy_out
torch_detach_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'detach_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diag
torch_diag <- function(self, diagonal = 0L) {
  args <- mget(x = c("self", "diagonal"))
expected_types <- list(self = "Tensor", diagonal = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diag',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diag_embed
torch_diag_embed <- function(self, offset = 0L, dim1 = -2L, dim2 = -1L) {
  args <- mget(x = c("self", "offset", "dim1", "dim2"))
expected_types <- list(self = "Tensor", offset = "int64_t", dim1 = "int64_t", dim2 = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diag_embed',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diag_embed_out
torch_diag_embed_out <- function(out, self, offset = 0L, dim1 = -2L, dim2 = -1L) {
  args <- mget(x = c("out", "self", "offset", "dim1", "dim2"))
expected_types <- list(out = "Tensor", self = "Tensor", offset = "int64_t", dim1 = "int64_t", 
    dim2 = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diag_embed_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diag_out
torch_diag_out <- function(out, self, diagonal = 0L) {
  args <- mget(x = c("out", "self", "diagonal"))
expected_types <- list(out = "Tensor", self = "Tensor", diagonal = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diag_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diagflat
torch_diagflat <- function(self, offset = 0L) {
  args <- mget(x = c("self", "offset"))
expected_types <- list(self = "Tensor", offset = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diagflat',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diagonal
torch_diagonal <- function(self, outdim, dim1 = 1L, dim2 = 2L, offset = 0L) {
  args <- mget(x = c("self", "outdim", "dim1", "dim2", "offset"))
expected_types <- list(self = "Tensor", outdim = "Dimname", dim1 = c("int64_t", 
"Dimname"), dim2 = c("int64_t", "Dimname"), offset = "int64_t")
nd_args <- c("self", "outdim", "dim1", "dim2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diagonal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diagonal_backward
torch_diagonal_backward <- function(grad_output, input_sizes, offset, dim1, dim2) {
  args <- mget(x = c("grad_output", "input_sizes", "offset", "dim1", "dim2"))
expected_types <- list(grad_output = "Tensor", input_sizes = "IntArrayRef", offset = "int64_t", 
    dim1 = "int64_t", dim2 = "int64_t")
nd_args <- c("grad_output", "input_sizes", "offset", "dim1", "dim2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diagonal_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diagonal_backward_out
torch_diagonal_backward_out <- function(out, grad_output, input_sizes, offset, dim1, dim2) {
  args <- mget(x = c("out", "grad_output", "input_sizes", "offset", "dim1", "dim2"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", input_sizes = "IntArrayRef", 
    offset = "int64_t", dim1 = "int64_t", dim2 = "int64_t")
nd_args <- c("out", "grad_output", "input_sizes", "offset", "dim1", "dim2"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diagonal_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diagonal_copy
torch_diagonal_copy <- function(self, offset = 0L, dim1 = 1L, dim2 = 2L) {
  args <- mget(x = c("self", "offset", "dim1", "dim2"))
expected_types <- list(self = "Tensor", offset = "int64_t", dim1 = "int64_t", dim2 = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diagonal_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diagonal_copy_out
torch_diagonal_copy_out <- function(out, self, offset = 0L, dim1 = 1L, dim2 = 2L) {
  args <- mget(x = c("out", "self", "offset", "dim1", "dim2"))
expected_types <- list(out = "Tensor", self = "Tensor", offset = "int64_t", dim1 = "int64_t", 
    dim2 = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diagonal_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diagonal_scatter
torch_diagonal_scatter <- function(self, src, offset = 0L, dim1 = 1L, dim2 = 2L) {
  args <- mget(x = c("self", "src", "offset", "dim1", "dim2"))
expected_types <- list(self = "Tensor", src = "Tensor", offset = "int64_t", dim1 = "int64_t", 
    dim2 = "int64_t")
nd_args <- c("self", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diagonal_scatter',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diagonal_scatter_out
torch_diagonal_scatter_out <- function(out, self, src, offset = 0L, dim1 = 1L, dim2 = 2L) {
  args <- mget(x = c("out", "self", "src", "offset", "dim1", "dim2"))
expected_types <- list(out = "Tensor", self = "Tensor", src = "Tensor", offset = "int64_t", 
    dim1 = "int64_t", dim2 = "int64_t")
nd_args <- c("out", "self", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diagonal_scatter_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diff
torch_diff <- function(self, n = 1L, dim = -1L, prepend = list(), append = list()) {
  args <- mget(x = c("self", "n", "dim", "prepend", "append"))
expected_types <- list(self = "Tensor", n = "int64_t", dim = "int64_t", prepend = "Tensor", 
    append = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diff',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_diff_out
torch_diff_out <- function(out, self, n = 1L, dim = -1L, prepend = list(), append = list()) {
  args <- mget(x = c("out", "self", "n", "dim", "prepend", "append"))
expected_types <- list(out = "Tensor", self = "Tensor", n = "int64_t", dim = "int64_t", 
    prepend = "Tensor", append = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'diff_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_digamma
torch_digamma <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'digamma',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_digamma_out
torch_digamma_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'digamma_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dist
torch_dist <- function(self, other, p = 2L) {
  args <- mget(x = c("self", "other", "p"))
expected_types <- list(self = "Tensor", other = "Tensor", p = "Scalar")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'dist',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dist_out
torch_dist_out <- function(out, self, other, p = 2L) {
  args <- mget(x = c("out", "self", "other", "p"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor", p = "Scalar")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'dist_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_div
torch_div <- function(self, other, rounding_mode) {
  args <- mget(x = c("self", "other", "rounding_mode"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"), rounding_mode = "c10::string_view")
nd_args <- c("self", "other", "rounding_mode")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'div',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_div_out
torch_div_out <- function(out, self, other, rounding_mode) {
  args <- mget(x = c("out", "self", "other", "rounding_mode"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Tensor", "Scalar"
), rounding_mode = "c10::string_view")
nd_args <- c("out", "self", "other", "rounding_mode")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'div_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_divide
torch_divide <- function(self, other, rounding_mode) {
  args <- mget(x = c("self", "other", "rounding_mode"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"), rounding_mode = "c10::string_view")
nd_args <- c("self", "other", "rounding_mode")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'divide',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_divide_out
torch_divide_out <- function(out, self, other, rounding_mode) {
  args <- mget(x = c("out", "self", "other", "rounding_mode"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor", rounding_mode = "c10::string_view")
nd_args <- c("out", "self", "other", "rounding_mode")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'divide_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dot
torch_dot <- function(self, tensor) {
  args <- mget(x = c("self", "tensor"))
expected_types <- list(self = "Tensor", tensor = "Tensor")
nd_args <- c("self", "tensor")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'dot',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dot_out
torch_dot_out <- function(out, self, tensor) {
  args <- mget(x = c("out", "self", "tensor"))
expected_types <- list(out = "Tensor", self = "Tensor", tensor = "Tensor")
nd_args <- c("out", "self", "tensor")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'dot_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dropout
torch_dropout <- function(input, p, train) {
  args <- mget(x = c("input", "p", "train"))
expected_types <- list(input = "Tensor", p = "double", train = "bool")
nd_args <- c("input", "p", "train")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'dropout',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dropout_
torch_dropout_ <- function(self, p, train) {
  args <- mget(x = c("self", "p", "train"))
expected_types <- list(self = "Tensor", p = "double", train = "bool")
nd_args <- c("self", "p", "train")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'dropout_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dsplit
torch_dsplit <- function(self, indices, sections) {
  args <- mget(x = c("self", "indices", "sections"))
expected_types <- list(self = "Tensor", indices = "IntArrayRef", sections = "int64_t")
nd_args <- c("self", "indices", "sections")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'dsplit',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dstack
torch_dstack <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'dstack',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_dstack_out
torch_dstack_out <- function(out, tensors) {
  args <- mget(x = c("out", "tensors"))
expected_types <- list(out = "Tensor", tensors = "TensorList")
nd_args <- c("out", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'dstack_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_einsum
torch_einsum <- function(equation, tensors, path = NULL) {
  args <- mget(x = c("equation", "tensors", "path"))
expected_types <- list(equation = "c10::string_view", tensors = "TensorList", path = "IntArrayRef")
nd_args <- c("equation", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'einsum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_elu
torch_elu <- function(self, alpha = 1L, scale = 1L, input_scale = 1L) {
  args <- mget(x = c("self", "alpha", "scale", "input_scale"))
expected_types <- list(self = "Tensor", alpha = "Scalar", scale = "Scalar", input_scale = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'elu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_elu_
torch_elu_ <- function(self, alpha = 1L, scale = 1L, input_scale = 1L) {
  args <- mget(x = c("self", "alpha", "scale", "input_scale"))
expected_types <- list(self = "Tensor", alpha = "Scalar", scale = "Scalar", input_scale = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'elu_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_elu_backward
torch_elu_backward <- function(grad_output, alpha, scale, input_scale, is_result, self_or_result) {
  args <- mget(x = c("grad_output", "alpha", "scale", "input_scale", "is_result", "self_or_result"))
expected_types <- list(grad_output = "Tensor", alpha = "Scalar", scale = "Scalar", 
    input_scale = "Scalar", is_result = "bool", self_or_result = "Tensor")
nd_args <- c("grad_output", "alpha", "scale", "input_scale", "is_result", 
"self_or_result")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'elu_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_elu_backward_out
torch_elu_backward_out <- function(grad_input, grad_output, alpha, scale, input_scale, is_result, self_or_result) {
  args <- mget(x = c("grad_input", "grad_output", "alpha", "scale", "input_scale", "is_result", "self_or_result"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", alpha = "Scalar", 
    scale = "Scalar", input_scale = "Scalar", is_result = "bool", 
    self_or_result = "Tensor")
nd_args <- c("grad_input", "grad_output", "alpha", "scale", "input_scale", 
"is_result", "self_or_result")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'elu_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_elu_out
torch_elu_out <- function(out, self, alpha = 1L, scale = 1L, input_scale = 1L) {
  args <- mget(x = c("out", "self", "alpha", "scale", "input_scale"))
expected_types <- list(out = "Tensor", self = "Tensor", alpha = "Scalar", scale = "Scalar", 
    input_scale = "Scalar")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'elu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding
torch_embedding <- function(weight, indices, padding_idx = -1L, scale_grad_by_freq = FALSE, sparse = FALSE) {
  args <- mget(x = c("weight", "indices", "padding_idx", "scale_grad_by_freq", "sparse"))
expected_types <- list(weight = "Tensor", indices = "Tensor", padding_idx = "int64_t", 
    scale_grad_by_freq = "bool", sparse = "bool")
nd_args <- c("weight", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'embedding',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding_backward
torch_embedding_backward <- function(grad, indices, num_weights, padding_idx, scale_grad_by_freq, sparse) {
  args <- mget(x = c("grad", "indices", "num_weights", "padding_idx", "scale_grad_by_freq", "sparse"))
expected_types <- list(grad = "Tensor", indices = "Tensor", num_weights = "int64_t", 
    padding_idx = "int64_t", scale_grad_by_freq = "bool", sparse = "bool")
nd_args <- c("grad", "indices", "num_weights", "padding_idx", "scale_grad_by_freq", 
"sparse")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'embedding_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding_bag
torch_embedding_bag <- function(weight, indices, offsets, scale_grad_by_freq = FALSE, mode = 0L, sparse = FALSE, per_sample_weights = list(), include_last_offset = FALSE, padding_idx) {
  args <- mget(x = c("weight", "indices", "offsets", "scale_grad_by_freq", "mode", "sparse", "per_sample_weights", "include_last_offset", "padding_idx"))
expected_types <- list(weight = "Tensor", indices = "Tensor", offsets = "Tensor", 
    scale_grad_by_freq = "bool", mode = "int64_t", sparse = "bool", 
    per_sample_weights = "Tensor", include_last_offset = "bool", 
    padding_idx = "int64_t")
nd_args <- c("weight", "indices", "offsets", "scale_grad_by_freq", "mode", 
"sparse", "per_sample_weights", "include_last_offset", "padding_idx"
)
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'embedding_bag',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding_dense_backward
torch_embedding_dense_backward <- function(grad_output, indices, num_weights, padding_idx, scale_grad_by_freq) {
  args <- mget(x = c("grad_output", "indices", "num_weights", "padding_idx", "scale_grad_by_freq"))
expected_types <- list(grad_output = "Tensor", indices = "Tensor", num_weights = "int64_t", 
    padding_idx = "int64_t", scale_grad_by_freq = "bool")
nd_args <- c("grad_output", "indices", "num_weights", "padding_idx", "scale_grad_by_freq"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'embedding_dense_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding_dense_backward_out
torch_embedding_dense_backward_out <- function(out, grad_output, indices, num_weights, padding_idx, scale_grad_by_freq) {
  args <- mget(x = c("out", "grad_output", "indices", "num_weights", "padding_idx", "scale_grad_by_freq"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", indices = "Tensor", 
    num_weights = "int64_t", padding_idx = "int64_t", scale_grad_by_freq = "bool")
nd_args <- c("out", "grad_output", "indices", "num_weights", "padding_idx", 
"scale_grad_by_freq")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'embedding_dense_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding_out
torch_embedding_out <- function(out, weight, indices, padding_idx = -1L, scale_grad_by_freq = FALSE, sparse = FALSE) {
  args <- mget(x = c("out", "weight", "indices", "padding_idx", "scale_grad_by_freq", "sparse"))
expected_types <- list(out = "Tensor", weight = "Tensor", indices = "Tensor", padding_idx = "int64_t", 
    scale_grad_by_freq = "bool", sparse = "bool")
nd_args <- c("out", "weight", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'embedding_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding_renorm
torch_embedding_renorm <- function(self, indices, max_norm, norm_type) {
  args <- mget(x = c("self", "indices", "max_norm", "norm_type"))
expected_types <- list(self = "Tensor", indices = "Tensor", max_norm = "double", 
    norm_type = "double")
nd_args <- c("self", "indices", "max_norm", "norm_type")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'embedding_renorm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding_renorm_
torch_embedding_renorm_ <- function(self, indices, max_norm, norm_type) {
  args <- mget(x = c("self", "indices", "max_norm", "norm_type"))
expected_types <- list(self = "Tensor", indices = "Tensor", max_norm = "double", 
    norm_type = "double")
nd_args <- c("self", "indices", "max_norm", "norm_type")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'embedding_renorm_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding_renorm_out
torch_embedding_renorm_out <- function(out, self, indices, max_norm, norm_type) {
  args <- mget(x = c("out", "self", "indices", "max_norm", "norm_type"))
expected_types <- list(out = "Tensor", self = "Tensor", indices = "Tensor", max_norm = "double", 
    norm_type = "double")
nd_args <- c("out", "self", "indices", "max_norm", "norm_type")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'embedding_renorm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_embedding_sparse_backward
torch_embedding_sparse_backward <- function(grad, indices, num_weights, padding_idx, scale_grad_by_freq) {
  args <- mget(x = c("grad", "indices", "num_weights", "padding_idx", "scale_grad_by_freq"))
expected_types <- list(grad = "Tensor", indices = "Tensor", num_weights = "int64_t", 
    padding_idx = "int64_t", scale_grad_by_freq = "bool")
nd_args <- c("grad", "indices", "num_weights", "padding_idx", "scale_grad_by_freq"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'embedding_sparse_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_empty
.torch_empty <- function(size, names, options = list(), memory_format = NULL) {
  args <- mget(x = c("size", "names", "options", "memory_format"))
expected_types <- list(size = "IntArrayRef", names = "DimnameList", options = "TensorOptions", 
    memory_format = "MemoryFormat")
nd_args <- c("size", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'empty',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_empty_like
.torch_empty_like <- function(self, options = list(), memory_format = NULL) {
  args <- mget(x = c("self", "options", "memory_format"))
expected_types <- list(self = "Tensor", options = "TensorOptions", memory_format = "MemoryFormat")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'empty_like',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_empty_like_out
torch_empty_like_out <- function(out, self, memory_format = NULL) {
  args <- mget(x = c("out", "self", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", memory_format = "MemoryFormat")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'empty_like_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_empty_out
torch_empty_out <- function(out, size, names, memory_format = NULL) {
  args <- mget(x = c("out", "size", "names", "memory_format"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", names = "DimnameList", 
    memory_format = "MemoryFormat")
nd_args <- c("out", "size", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'empty_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_empty_quantized
torch_empty_quantized <- function(size, qtensor, options = list(), memory_format = NULL) {
  args <- mget(x = c("size", "qtensor", "options", "memory_format"))
expected_types <- list(size = "IntArrayRef", qtensor = "Tensor", options = "TensorOptions", 
    memory_format = "MemoryFormat")
nd_args <- c("size", "qtensor")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'empty_quantized',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_empty_quantized_out
torch_empty_quantized_out <- function(out, size, qtensor, memory_format = NULL) {
  args <- mget(x = c("out", "size", "qtensor", "memory_format"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", qtensor = "Tensor", 
    memory_format = "MemoryFormat")
nd_args <- c("out", "size", "qtensor")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'empty_quantized_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_empty_strided
.torch_empty_strided <- function(size, stride, options = list()) {
  args <- mget(x = c("size", "stride", "options"))
expected_types <- list(size = "IntArrayRef", stride = "IntArrayRef", options = "TensorOptions")
nd_args <- c("size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'empty_strided',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_empty_strided_out
torch_empty_strided_out <- function(out, size, stride) {
  args <- mget(x = c("out", "size", "stride"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("out", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'empty_strided_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_eq
torch_eq <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'eq',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_eq_out
torch_eq_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'eq_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_equal
torch_equal <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('bool'))
call_c_function(
fun_name = 'equal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_erf
torch_erf <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'erf',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_erf_
torch_erf_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'erf_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_erf_out
torch_erf_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'erf_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_erfc
torch_erfc <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'erfc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_erfc_
torch_erfc_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'erfc_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_erfc_out
torch_erfc_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'erfc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_erfinv
torch_erfinv <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'erfinv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_erfinv_out
torch_erfinv_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'erfinv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_exp
torch_exp <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'exp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_exp_
torch_exp_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'exp_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_exp_out
torch_exp_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'exp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_exp2
torch_exp2 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'exp2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_exp2_
torch_exp2_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'exp2_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_exp2_out
torch_exp2_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'exp2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_expand_copy
torch_expand_copy <- function(self, size, implicit = FALSE) {
  args <- mget(x = c("self", "size", "implicit"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", implicit = "bool")
nd_args <- c("self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'expand_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_expand_copy_out
torch_expand_copy_out <- function(out, self, size, implicit = FALSE) {
  args <- mget(x = c("out", "self", "size", "implicit"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef", implicit = "bool")
nd_args <- c("out", "self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'expand_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_expm1
torch_expm1 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'expm1',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_expm1_
torch_expm1_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'expm1_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_expm1_out
torch_expm1_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'expm1_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_exponential
torch_exponential <- function(self, lambd = 1L, generator = NULL) {
  args <- mget(x = c("self", "lambd", "generator"))
expected_types <- list(self = "Tensor", lambd = "double", generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'exponential',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_exponential_out
torch_exponential_out <- function(out, self, lambd = 1L, generator = NULL) {
  args <- mget(x = c("out", "self", "lambd", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", lambd = "double", generator = "Generator")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'exponential_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_eye
.torch_eye <- function(n, m, options = list()) {
  args <- mget(x = c("n", "m", "options"))
expected_types <- list(n = "int64_t", m = "int64_t", options = "TensorOptions")
nd_args <- c("n", "m")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'eye',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_eye_out
torch_eye_out <- function(out, n, m) {
  args <- mget(x = c("out", "n", "m"))
expected_types <- list(out = "Tensor", n = "int64_t", m = "int64_t")
nd_args <- c("out", "n", "m")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'eye_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fake_quantize_per_channel_affine
torch_fake_quantize_per_channel_affine <- function(self, scale, zero_point, axis, quant_min, quant_max) {
  args <- mget(x = c("self", "scale", "zero_point", "axis", "quant_min", "quant_max"))
expected_types <- list(self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    axis = "int64_t", quant_min = "int64_t", quant_max = "int64_t")
nd_args <- c("self", "scale", "zero_point", "axis", "quant_min", "quant_max"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fake_quantize_per_channel_affine',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fake_quantize_per_channel_affine_cachemask
torch_fake_quantize_per_channel_affine_cachemask <- function(self, scale, zero_point, axis, quant_min, quant_max) {
  args <- mget(x = c("self", "scale", "zero_point", "axis", "quant_min", "quant_max"))
expected_types <- list(self = "Tensor", scale = "Tensor", zero_point = "Tensor", 
    axis = "int64_t", quant_min = "int64_t", quant_max = "int64_t")
nd_args <- c("self", "scale", "zero_point", "axis", "quant_min", "quant_max"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'fake_quantize_per_channel_affine_cachemask',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fake_quantize_per_channel_affine_cachemask_backward
torch_fake_quantize_per_channel_affine_cachemask_backward <- function(grad, mask) {
  args <- mget(x = c("grad", "mask"))
expected_types <- list(grad = "Tensor", mask = "Tensor")
nd_args <- c("grad", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fake_quantize_per_channel_affine_cachemask_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fake_quantize_per_channel_affine_cachemask_out
torch_fake_quantize_per_channel_affine_cachemask_out <- function(out0, out1, self, scale, zero_point, axis, quant_min, quant_max) {
  args <- mget(x = c("out0", "out1", "self", "scale", "zero_point", "axis", "quant_min", "quant_max"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", self = "Tensor", scale = "Tensor", 
    zero_point = "Tensor", axis = "int64_t", quant_min = "int64_t", 
    quant_max = "int64_t")
nd_args <- c("out0", "out1", "self", "scale", "zero_point", "axis", "quant_min", 
"quant_max")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'fake_quantize_per_channel_affine_cachemask_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fake_quantize_per_tensor_affine
torch_fake_quantize_per_tensor_affine <- function(self, scale, zero_point, quant_min, quant_max) {
  args <- mget(x = c("self", "scale", "zero_point", "quant_min", "quant_max"))
expected_types <- list(self = "Tensor", scale = c("double", "Tensor"), zero_point = c("int64_t", 
"Tensor"), quant_min = "int64_t", quant_max = "int64_t")
nd_args <- c("self", "scale", "zero_point", "quant_min", "quant_max")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fake_quantize_per_tensor_affine',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fake_quantize_per_tensor_affine_cachemask
torch_fake_quantize_per_tensor_affine_cachemask <- function(self, scale, zero_point, quant_min, quant_max) {
  args <- mget(x = c("self", "scale", "zero_point", "quant_min", "quant_max"))
expected_types <- list(self = "Tensor", scale = "double", zero_point = "int64_t", 
    quant_min = "int64_t", quant_max = "int64_t")
nd_args <- c("self", "scale", "zero_point", "quant_min", "quant_max")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'fake_quantize_per_tensor_affine_cachemask',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fake_quantize_per_tensor_affine_cachemask_backward
torch_fake_quantize_per_tensor_affine_cachemask_backward <- function(grad, mask) {
  args <- mget(x = c("grad", "mask"))
expected_types <- list(grad = "Tensor", mask = "Tensor")
nd_args <- c("grad", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fake_quantize_per_tensor_affine_cachemask_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fake_quantize_per_tensor_affine_cachemask_out
torch_fake_quantize_per_tensor_affine_cachemask_out <- function(out0, out1, self, scale, zero_point, quant_min, quant_max) {
  args <- mget(x = c("out0", "out1", "self", "scale", "zero_point", "quant_min", "quant_max"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", self = "Tensor", scale = "double", 
    zero_point = "int64_t", quant_min = "int64_t", quant_max = "int64_t")
nd_args <- c("out0", "out1", "self", "scale", "zero_point", "quant_min", 
"quant_max")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'fake_quantize_per_tensor_affine_cachemask_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fbgemm_linear_fp16_weight
torch_fbgemm_linear_fp16_weight <- function(input, packed_weight, bias) {
  args <- mget(x = c("input", "packed_weight", "bias"))
expected_types <- list(input = "Tensor", packed_weight = "Tensor", bias = "Tensor")
nd_args <- c("input", "packed_weight", "bias")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fbgemm_linear_fp16_weight',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fbgemm_linear_fp16_weight_fp32_activation
torch_fbgemm_linear_fp16_weight_fp32_activation <- function(input, packed_weight, bias) {
  args <- mget(x = c("input", "packed_weight", "bias"))
expected_types <- list(input = "Tensor", packed_weight = "Tensor", bias = "Tensor")
nd_args <- c("input", "packed_weight", "bias")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fbgemm_linear_fp16_weight_fp32_activation',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fbgemm_linear_int8_weight
torch_fbgemm_linear_int8_weight <- function(input, weight, packed, col_offsets, weight_scale, weight_zero_point, bias) {
  args <- mget(x = c("input", "weight", "packed", "col_offsets", "weight_scale", "weight_zero_point", "bias"))
expected_types <- list(input = "Tensor", weight = "Tensor", packed = "Tensor", 
    col_offsets = "Tensor", weight_scale = "Scalar", weight_zero_point = "Scalar", 
    bias = "Tensor")
nd_args <- c("input", "weight", "packed", "col_offsets", "weight_scale", 
"weight_zero_point", "bias")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fbgemm_linear_int8_weight',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fbgemm_linear_int8_weight_fp32_activation
torch_fbgemm_linear_int8_weight_fp32_activation <- function(input, weight, packed, col_offsets, weight_scale, weight_zero_point, bias) {
  args <- mget(x = c("input", "weight", "packed", "col_offsets", "weight_scale", "weight_zero_point", "bias"))
expected_types <- list(input = "Tensor", weight = "Tensor", packed = "Tensor", 
    col_offsets = "Tensor", weight_scale = "Scalar", weight_zero_point = "Scalar", 
    bias = "Tensor")
nd_args <- c("input", "weight", "packed", "col_offsets", "weight_scale", 
"weight_zero_point", "bias")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fbgemm_linear_int8_weight_fp32_activation',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fbgemm_linear_quantize_weight
torch_fbgemm_linear_quantize_weight <- function(input) {
  args <- mget(x = c("input"))
expected_types <- list(input = "Tensor")
nd_args <- "input"
return_types <- list(list("Tensor", "Tensor", "double", "int64_t"))
call_c_function(
fun_name = 'fbgemm_linear_quantize_weight',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fbgemm_pack_gemm_matrix_fp16
torch_fbgemm_pack_gemm_matrix_fp16 <- function(input) {
  args <- mget(x = c("input"))
expected_types <- list(input = "Tensor")
nd_args <- "input"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fbgemm_pack_gemm_matrix_fp16',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fbgemm_pack_quantized_matrix
torch_fbgemm_pack_quantized_matrix <- function(input, K, False) {
  args <- mget(x = c("input", "K", "False"))
expected_types <- list(input = "Tensor", K = "int64_t", False = "int64_t")
nd_args <- c("input", "K", "False")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fbgemm_pack_quantized_matrix',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_feature_alpha_dropout
torch_feature_alpha_dropout <- function(input, p, train) {
  args <- mget(x = c("input", "p", "train"))
expected_types <- list(input = "Tensor", p = "double", train = "bool")
nd_args <- c("input", "p", "train")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'feature_alpha_dropout',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_feature_alpha_dropout_
torch_feature_alpha_dropout_ <- function(self, p, train) {
  args <- mget(x = c("self", "p", "train"))
expected_types <- list(self = "Tensor", p = "double", train = "bool")
nd_args <- c("self", "p", "train")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'feature_alpha_dropout_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_feature_dropout
torch_feature_dropout <- function(input, p, train) {
  args <- mget(x = c("input", "p", "train"))
expected_types <- list(input = "Tensor", p = "double", train = "bool")
nd_args <- c("input", "p", "train")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'feature_dropout',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_feature_dropout_
torch_feature_dropout_ <- function(self, p, train) {
  args <- mget(x = c("self", "p", "train"))
expected_types <- list(self = "Tensor", p = "double", train = "bool")
nd_args <- c("self", "p", "train")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'feature_dropout_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_fft_fft
.torch_fft_fft <- function(self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("self", "n", "dim", "norm"))
expected_types <- list(self = "Tensor", n = "int64_t", dim = "int64_t", norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_fft',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_fft_out
torch_fft_fft_out <- function(out, self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("out", "self", "n", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", n = "int64_t", dim = "int64_t", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_fft_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_fft2
torch_fft_fft2 <- function(self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_fft2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_fft2_out
torch_fft_fft2_out <- function(out, self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_fft2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_fft_fftfreq
.torch_fft_fftfreq <- function(n, d = 1L, options = list()) {
  args <- mget(x = c("n", "d", "options"))
expected_types <- list(n = "int64_t", d = "double", options = "TensorOptions")
nd_args <- "n"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_fftfreq',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_fftfreq_out
torch_fft_fftfreq_out <- function(out, n, d = 1L) {
  args <- mget(x = c("out", "n", "d"))
expected_types <- list(out = "Tensor", n = "int64_t", d = "double")
nd_args <- c("out", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_fftfreq_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_fftn
torch_fft_fftn <- function(self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_fftn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_fftn_out
torch_fft_fftn_out <- function(out, self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_fftn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_fftshift
torch_fft_fftshift <- function(self, dim = NULL) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_fftshift',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_hfft
torch_fft_hfft <- function(self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("self", "n", "dim", "norm"))
expected_types <- list(self = "Tensor", n = "int64_t", dim = "int64_t", norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_hfft',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_hfft_out
torch_fft_hfft_out <- function(out, self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("out", "self", "n", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", n = "int64_t", dim = "int64_t", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_hfft_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_hfft2
torch_fft_hfft2 <- function(self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_hfft2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_hfft2_out
torch_fft_hfft2_out <- function(out, self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_hfft2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_hfftn
torch_fft_hfftn <- function(self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_hfftn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_hfftn_out
torch_fft_hfftn_out <- function(out, self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_hfftn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_fft_ifft
.torch_fft_ifft <- function(self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("self", "n", "dim", "norm"))
expected_types <- list(self = "Tensor", n = "int64_t", dim = "int64_t", norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ifft',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ifft_out
torch_fft_ifft_out <- function(out, self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("out", "self", "n", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", n = "int64_t", dim = "int64_t", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ifft_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ifft2
torch_fft_ifft2 <- function(self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ifft2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ifft2_out
torch_fft_ifft2_out <- function(out, self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ifft2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ifftn
torch_fft_ifftn <- function(self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ifftn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ifftn_out
torch_fft_ifftn_out <- function(out, self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ifftn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ifftshift
torch_fft_ifftshift <- function(self, dim = NULL) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ifftshift',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ihfft
torch_fft_ihfft <- function(self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("self", "n", "dim", "norm"))
expected_types <- list(self = "Tensor", n = "int64_t", dim = "int64_t", norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ihfft',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ihfft_out
torch_fft_ihfft_out <- function(out, self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("out", "self", "n", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", n = "int64_t", dim = "int64_t", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ihfft_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ihfft2
torch_fft_ihfft2 <- function(self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ihfft2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ihfft2_out
torch_fft_ihfft2_out <- function(out, self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ihfft2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ihfftn
torch_fft_ihfftn <- function(self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ihfftn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_ihfftn_out
torch_fft_ihfftn_out <- function(out, self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_ihfftn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_fft_irfft
.torch_fft_irfft <- function(self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("self", "n", "dim", "norm"))
expected_types <- list(self = "Tensor", n = "int64_t", dim = "int64_t", norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_irfft',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_irfft_out
torch_fft_irfft_out <- function(out, self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("out", "self", "n", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", n = "int64_t", dim = "int64_t", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_irfft_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_irfft2
torch_fft_irfft2 <- function(self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_irfft2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_irfft2_out
torch_fft_irfft2_out <- function(out, self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_irfft2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_irfftn
torch_fft_irfftn <- function(self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_irfftn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_irfftn_out
torch_fft_irfftn_out <- function(out, self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_irfftn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_fft_rfft
.torch_fft_rfft <- function(self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("self", "n", "dim", "norm"))
expected_types <- list(self = "Tensor", n = "int64_t", dim = "int64_t", norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_rfft',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_rfft_out
torch_fft_rfft_out <- function(out, self, n = NULL, dim = -1L, norm = NULL) {
  args <- mget(x = c("out", "self", "n", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", n = "int64_t", dim = "int64_t", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_rfft_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_rfft2
torch_fft_rfft2 <- function(self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_rfft2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_rfft2_out
torch_fft_rfft2_out <- function(out, self, s = NULL, dim = c(-2,-1), norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_rfft2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_rfftfreq
torch_fft_rfftfreq <- function(n, d = 1L, options = list()) {
  args <- mget(x = c("n", "d", "options"))
expected_types <- list(n = "int64_t", d = "double", options = "TensorOptions")
nd_args <- "n"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_rfftfreq',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_rfftfreq_out
torch_fft_rfftfreq_out <- function(out, n, d = 1L) {
  args <- mget(x = c("out", "n", "d"))
expected_types <- list(out = "Tensor", n = "int64_t", d = "double")
nd_args <- c("out", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_rfftfreq_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_rfftn
torch_fft_rfftn <- function(self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("self", "s", "dim", "norm"))
expected_types <- list(self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_rfftn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fft_rfftn_out
torch_fft_rfftn_out <- function(out, self, s = NULL, dim = NULL, norm = NULL) {
  args <- mget(x = c("out", "self", "s", "dim", "norm"))
expected_types <- list(out = "Tensor", self = "Tensor", s = "IntArrayRef", dim = "IntArrayRef", 
    norm = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fft_rfftn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fill
torch_fill <- function(self, value) {
  args <- mget(x = c("self", "value"))
expected_types <- list(self = "Tensor", value = c("Scalar", "Tensor"))
nd_args <- c("self", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fill',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fill_
torch_fill_ <- function(self, value) {
  args <- mget(x = c("self", "value"))
expected_types <- list(self = "Tensor", value = c("Scalar", "Tensor"))
nd_args <- c("self", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fill_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fill_out
torch_fill_out <- function(out, self, value) {
  args <- mget(x = c("out", "self", "value"))
expected_types <- list(out = "Tensor", self = "Tensor", value = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fill_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fix
torch_fix <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fix',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fix_
torch_fix_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fix_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fix_out
torch_fix_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fix_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_flatten
torch_flatten <- function(self, dims, start_dim = 1L, end_dim = -1L, out_dim) {
  args <- mget(x = c("self", "dims", "start_dim", "end_dim", "out_dim"))
expected_types <- list(self = "Tensor", dims = "DimnameList", start_dim = c("int64_t", 
"Dimname"), end_dim = c("int64_t", "Dimname"), out_dim = "Dimname")
nd_args <- c("self", "dims", "start_dim", "end_dim", "out_dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'flatten',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_flatten_dense_tensors
torch_flatten_dense_tensors <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'flatten_dense_tensors',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_flip
torch_flip <- function(self, dims) {
  args <- mget(x = c("self", "dims"))
expected_types <- list(self = "Tensor", dims = "IntArrayRef")
nd_args <- c("self", "dims")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'flip',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_flip_out
torch_flip_out <- function(out, self, dims) {
  args <- mget(x = c("out", "self", "dims"))
expected_types <- list(out = "Tensor", self = "Tensor", dims = "IntArrayRef")
nd_args <- c("out", "self", "dims")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'flip_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fliplr
torch_fliplr <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fliplr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_flipud
torch_flipud <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'flipud',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_float_power
torch_float_power <- function(self, exponent) {
  args <- mget(x = c("self", "exponent"))
expected_types <- list(self = c("Tensor", "Scalar"), exponent = c("Tensor", "Scalar"
))
nd_args <- c("self", "exponent")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'float_power',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_float_power_out
torch_float_power_out <- function(out, self, exponent) {
  args <- mget(x = c("out", "self", "exponent"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), exponent = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "exponent")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'float_power_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_floor
torch_floor <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'floor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_floor_
torch_floor_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'floor_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_floor_divide
torch_floor_divide <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'floor_divide',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_floor_divide_out
torch_floor_divide_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'floor_divide_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_floor_out
torch_floor_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'floor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fmax
torch_fmax <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fmax_out
torch_fmax_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fmin
torch_fmin <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fmin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fmin_out
torch_fmin_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fmin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fmod
torch_fmod <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fmod',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fmod_out
torch_fmod_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fmod_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_frac
torch_frac <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'frac',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_frac_
torch_frac_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'frac_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_frac_out
torch_frac_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'frac_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fractional_max_pool2d
torch_fractional_max_pool2d <- function(self, kernel_size, output_size, random_samples) {
  args <- mget(x = c("self", "kernel_size", "output_size", "random_samples"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", output_size = "IntArrayRef", 
    random_samples = "Tensor")
nd_args <- c("self", "kernel_size", "output_size", "random_samples")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'fractional_max_pool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fractional_max_pool2d_backward
torch_fractional_max_pool2d_backward <- function(grad_output, self, kernel_size, output_size, indices) {
  args <- mget(x = c("grad_output", "self", "kernel_size", "output_size", "indices"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    output_size = "IntArrayRef", indices = "Tensor")
nd_args <- c("grad_output", "self", "kernel_size", "output_size", "indices"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fractional_max_pool2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fractional_max_pool2d_backward_out
torch_fractional_max_pool2d_backward_out <- function(grad_input, grad_output, self, kernel_size, output_size, indices) {
  args <- mget(x = c("grad_input", "grad_output", "self", "kernel_size", "output_size", "indices"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    kernel_size = "IntArrayRef", output_size = "IntArrayRef", 
    indices = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "kernel_size", "output_size", 
"indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fractional_max_pool2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fractional_max_pool2d_out
torch_fractional_max_pool2d_out <- function(output, indices, self, kernel_size, output_size, random_samples) {
  args <- mget(x = c("output", "indices", "self", "kernel_size", "output_size", "random_samples"))
expected_types <- list(output = "Tensor", indices = "Tensor", self = "Tensor", 
    kernel_size = "IntArrayRef", output_size = "IntArrayRef", 
    random_samples = "Tensor")
nd_args <- c("output", "indices", "self", "kernel_size", "output_size", 
"random_samples")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'fractional_max_pool2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fractional_max_pool3d
torch_fractional_max_pool3d <- function(self, kernel_size, output_size, random_samples) {
  args <- mget(x = c("self", "kernel_size", "output_size", "random_samples"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", output_size = "IntArrayRef", 
    random_samples = "Tensor")
nd_args <- c("self", "kernel_size", "output_size", "random_samples")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'fractional_max_pool3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fractional_max_pool3d_backward
torch_fractional_max_pool3d_backward <- function(grad_output, self, kernel_size, output_size, indices) {
  args <- mget(x = c("grad_output", "self", "kernel_size", "output_size", "indices"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    output_size = "IntArrayRef", indices = "Tensor")
nd_args <- c("grad_output", "self", "kernel_size", "output_size", "indices"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fractional_max_pool3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fractional_max_pool3d_backward_out
torch_fractional_max_pool3d_backward_out <- function(grad_input, grad_output, self, kernel_size, output_size, indices) {
  args <- mget(x = c("grad_input", "grad_output", "self", "kernel_size", "output_size", "indices"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    kernel_size = "IntArrayRef", output_size = "IntArrayRef", 
    indices = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "kernel_size", "output_size", 
"indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fractional_max_pool3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fractional_max_pool3d_out
torch_fractional_max_pool3d_out <- function(output, indices, self, kernel_size, output_size, random_samples) {
  args <- mget(x = c("output", "indices", "self", "kernel_size", "output_size", "random_samples"))
expected_types <- list(output = "Tensor", indices = "Tensor", self = "Tensor", 
    kernel_size = "IntArrayRef", output_size = "IntArrayRef", 
    random_samples = "Tensor")
nd_args <- c("output", "indices", "self", "kernel_size", "output_size", 
"random_samples")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'fractional_max_pool3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_frexp
torch_frexp <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'frexp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_frexp_out
torch_frexp_out <- function(mantissa, exponent, self) {
  args <- mget(x = c("mantissa", "exponent", "self"))
expected_types <- list(mantissa = "Tensor", exponent = "Tensor", self = "Tensor")
nd_args <- c("mantissa", "exponent", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'frexp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_frobenius_norm
torch_frobenius_norm <- function(self, dim, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'frobenius_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_frobenius_norm_out
torch_frobenius_norm_out <- function(out, self, dim, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'frobenius_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_from_file
torch_from_file <- function(filename, shared = NULL, size = 0L, options = list()) {
  args <- mget(x = c("filename", "shared", "size", "options"))
expected_types <- list(filename = "c10::string_view", shared = "bool", size = "int64_t", 
    options = "TensorOptions")
nd_args <- "filename"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'from_file',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_from_file_out
torch_from_file_out <- function(out, filename, shared = NULL, size = 0L) {
  args <- mget(x = c("out", "filename", "shared", "size"))
expected_types <- list(out = "Tensor", filename = "c10::string_view", shared = "bool", 
    size = "int64_t")
nd_args <- c("out", "filename")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'from_file_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_full
.torch_full <- function(size, fill_value, names, options = list()) {
  args <- mget(x = c("size", "fill_value", "names", "options"))
expected_types <- list(size = "IntArrayRef", fill_value = "Scalar", names = "DimnameList", 
    options = "TensorOptions")
nd_args <- c("size", "fill_value", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'full',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_full_like
.torch_full_like <- function(self, fill_value, options = list(), memory_format = NULL) {
  args <- mget(x = c("self", "fill_value", "options", "memory_format"))
expected_types <- list(self = "Tensor", fill_value = "Scalar", options = "TensorOptions", 
    memory_format = "MemoryFormat")
nd_args <- c("self", "fill_value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'full_like',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_full_like_out
torch_full_like_out <- function(out, self, fill_value, memory_format = NULL) {
  args <- mget(x = c("out", "self", "fill_value", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", fill_value = "Scalar", 
    memory_format = "MemoryFormat")
nd_args <- c("out", "self", "fill_value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'full_like_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_full_out
torch_full_out <- function(out, size, fill_value, names) {
  args <- mget(x = c("out", "size", "fill_value", "names"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", fill_value = "Scalar", 
    names = "DimnameList")
nd_args <- c("out", "size", "fill_value", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'full_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_fused_moving_avg_obs_fake_quant
torch_fused_moving_avg_obs_fake_quant <- function(self, observer_on, fake_quant_on, running_min, running_max, scale, zero_point, averaging_const, quant_min, quant_max, ch_axis, per_row_fake_quant = FALSE, symmetric_quant = FALSE) {
  args <- mget(x = c("self", "observer_on", "fake_quant_on", "running_min", "running_max", "scale", "zero_point", "averaging_const", "quant_min", "quant_max", "ch_axis", "per_row_fake_quant", "symmetric_quant"))
expected_types <- list(self = "Tensor", observer_on = "Tensor", fake_quant_on = "Tensor", 
    running_min = "Tensor", running_max = "Tensor", scale = "Tensor", 
    zero_point = "Tensor", averaging_const = "double", quant_min = "int64_t", 
    quant_max = "int64_t", ch_axis = "int64_t", per_row_fake_quant = "bool", 
    symmetric_quant = "bool")
nd_args <- c("self", "observer_on", "fake_quant_on", "running_min", "running_max", 
"scale", "zero_point", "averaging_const", "quant_min", "quant_max", 
"ch_axis")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'fused_moving_avg_obs_fake_quant',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gather
torch_gather <- function(self, dim, index, sparse_grad = FALSE) {
  args <- mget(x = c("self", "dim", "index", "sparse_grad"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), index = "Tensor", 
    sparse_grad = "bool")
nd_args <- c("self", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gather',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gather_backward
torch_gather_backward <- function(grad, self, dim, index, sparse_grad) {
  args <- mget(x = c("grad", "self", "dim", "index", "sparse_grad"))
expected_types <- list(grad = "Tensor", self = "Tensor", dim = "int64_t", index = "Tensor", 
    sparse_grad = "bool")
nd_args <- c("grad", "self", "dim", "index", "sparse_grad")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gather_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gather_out
torch_gather_out <- function(out, self, dim, index, sparse_grad = FALSE) {
  args <- mget(x = c("out", "self", "dim", "index", "sparse_grad"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("int64_t", "Dimname"
), index = "Tensor", sparse_grad = "bool")
nd_args <- c("out", "self", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gather_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gcd
torch_gcd <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gcd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gcd_
torch_gcd_ <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gcd_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gcd_out
torch_gcd_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gcd_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ge
torch_ge <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ge',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ge_out
torch_ge_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ge_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gelu
torch_gelu <- function(self, approximate = "none") {
  args <- mget(x = c("self", "approximate"))
expected_types <- list(self = "Tensor", approximate = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gelu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gelu_
torch_gelu_ <- function(self, approximate = "none") {
  args <- mget(x = c("self", "approximate"))
expected_types <- list(self = "Tensor", approximate = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gelu_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gelu_backward
torch_gelu_backward <- function(grad_output, self, approximate = "none") {
  args <- mget(x = c("grad_output", "self", "approximate"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", approximate = "c10::string_view")
nd_args <- c("grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gelu_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gelu_backward_out
torch_gelu_backward_out <- function(grad_input, grad_output, self, approximate = "none") {
  args <- mget(x = c("grad_input", "grad_output", "self", "approximate"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    approximate = "c10::string_view")
nd_args <- c("grad_input", "grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gelu_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gelu_out
torch_gelu_out <- function(out, self, approximate = "none") {
  args <- mget(x = c("out", "self", "approximate"))
expected_types <- list(out = "Tensor", self = "Tensor", approximate = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gelu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_geometric
torch_geometric <- function(self, p, generator = NULL) {
  args <- mget(x = c("self", "p", "generator"))
expected_types <- list(self = "Tensor", p = "double", generator = "Generator")
nd_args <- c("self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'geometric',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_geometric_out
torch_geometric_out <- function(out, self, p, generator = NULL) {
  args <- mget(x = c("out", "self", "p", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", p = "double", generator = "Generator")
nd_args <- c("out", "self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'geometric_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_geqrf
torch_geqrf <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'geqrf',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_geqrf_out
torch_geqrf_out <- function(a, tau, self) {
  args <- mget(x = c("a", "tau", "self"))
expected_types <- list(a = "Tensor", tau = "Tensor", self = "Tensor")
nd_args <- c("a", "tau", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'geqrf_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ger
torch_ger <- function(self, vec2) {
  args <- mget(x = c("self", "vec2"))
expected_types <- list(self = "Tensor", vec2 = "Tensor")
nd_args <- c("self", "vec2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ger',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ger_out
torch_ger_out <- function(out, self, vec2) {
  args <- mget(x = c("out", "self", "vec2"))
expected_types <- list(out = "Tensor", self = "Tensor", vec2 = "Tensor")
nd_args <- c("out", "self", "vec2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ger_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_glu
torch_glu <- function(self, dim = -1L) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'glu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_glu_backward
torch_glu_backward <- function(grad_output, self, dim) {
  args <- mget(x = c("grad_output", "self", "dim"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", dim = "int64_t")
nd_args <- c("grad_output", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'glu_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_glu_backward_jvp
torch_glu_backward_jvp <- function(grad_x, grad_glu, x, dgrad_glu, dx, dim) {
  args <- mget(x = c("grad_x", "grad_glu", "x", "dgrad_glu", "dx", "dim"))
expected_types <- list(grad_x = "Tensor", grad_glu = "Tensor", x = "Tensor", dgrad_glu = "Tensor", 
    dx = "Tensor", dim = "int64_t")
nd_args <- c("grad_x", "grad_glu", "x", "dgrad_glu", "dx", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'glu_backward_jvp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_glu_backward_jvp_out
torch_glu_backward_jvp_out <- function(out, grad_x, grad_glu, x, dgrad_glu, dx, dim) {
  args <- mget(x = c("out", "grad_x", "grad_glu", "x", "dgrad_glu", "dx", "dim"))
expected_types <- list(out = "Tensor", grad_x = "Tensor", grad_glu = "Tensor", 
    x = "Tensor", dgrad_glu = "Tensor", dx = "Tensor", dim = "int64_t")
nd_args <- c("out", "grad_x", "grad_glu", "x", "dgrad_glu", "dx", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'glu_backward_jvp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_glu_backward_out
torch_glu_backward_out <- function(grad_input, grad_output, self, dim) {
  args <- mget(x = c("grad_input", "grad_output", "self", "dim"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    dim = "int64_t")
nd_args <- c("grad_input", "grad_output", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'glu_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_glu_jvp
torch_glu_jvp <- function(glu, x, dx, dim) {
  args <- mget(x = c("glu", "x", "dx", "dim"))
expected_types <- list(glu = "Tensor", x = "Tensor", dx = "Tensor", dim = "int64_t")
nd_args <- c("glu", "x", "dx", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'glu_jvp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_glu_jvp_out
torch_glu_jvp_out <- function(out, glu, x, dx, dim) {
  args <- mget(x = c("out", "glu", "x", "dx", "dim"))
expected_types <- list(out = "Tensor", glu = "Tensor", x = "Tensor", dx = "Tensor", 
    dim = "int64_t")
nd_args <- c("out", "glu", "x", "dx", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'glu_jvp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_glu_out
torch_glu_out <- function(out, self, dim = -1L) {
  args <- mget(x = c("out", "self", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'glu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gradient
torch_gradient <- function(self, spacing = NULL, dim = NULL, edge_order = 1L) {
  args <- mget(x = c("self", "spacing", "dim", "edge_order"))
expected_types <- list(self = "Tensor", spacing = c("Scalar", "ArrayRef<Scalar>", 
"TensorList"), dim = c("int64_t", "IntArrayRef"), edge_order = "int64_t")
nd_args <- c("self", "spacing", "dim")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'gradient',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_greater
torch_greater <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'greater',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_greater_equal
torch_greater_equal <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'greater_equal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_greater_equal_out
torch_greater_equal_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'greater_equal_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_greater_out
torch_greater_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'greater_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_grid_sampler
torch_grid_sampler <- function(input, grid, interpolation_mode, padding_mode, align_corners) {
  args <- mget(x = c("input", "grid", "interpolation_mode", "padding_mode", "align_corners"))
expected_types <- list(input = "Tensor", grid = "Tensor", interpolation_mode = "int64_t", 
    padding_mode = "int64_t", align_corners = "bool")
nd_args <- c("input", "grid", "interpolation_mode", "padding_mode", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'grid_sampler',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_grid_sampler_2d
torch_grid_sampler_2d <- function(input, grid, interpolation_mode, padding_mode, align_corners) {
  args <- mget(x = c("input", "grid", "interpolation_mode", "padding_mode", "align_corners"))
expected_types <- list(input = "Tensor", grid = "Tensor", interpolation_mode = "int64_t", 
    padding_mode = "int64_t", align_corners = "bool")
nd_args <- c("input", "grid", "interpolation_mode", "padding_mode", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'grid_sampler_2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_grid_sampler_2d_backward
torch_grid_sampler_2d_backward <- function(grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask) {
  args <- mget(x = c("grad_output", "input", "grid", "interpolation_mode", "padding_mode", "align_corners", "output_mask"))
expected_types <- list(grad_output = "Tensor", input = "Tensor", grid = "Tensor", 
    interpolation_mode = "int64_t", padding_mode = "int64_t", 
    align_corners = "bool", output_mask = "::std::array<bool,2>")
nd_args <- c("grad_output", "input", "grid", "interpolation_mode", "padding_mode", 
"align_corners", "output_mask")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'grid_sampler_2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_grid_sampler_2d_backward_out
torch_grid_sampler_2d_backward_out <- function(out0, out1, grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask) {
  args <- mget(x = c("out0", "out1", "grad_output", "input", "grid", "interpolation_mode", "padding_mode", "align_corners", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", grad_output = "Tensor", 
    input = "Tensor", grid = "Tensor", interpolation_mode = "int64_t", 
    padding_mode = "int64_t", align_corners = "bool", output_mask = "::std::array<bool,2>")
nd_args <- c("out0", "out1", "grad_output", "input", "grid", "interpolation_mode", 
"padding_mode", "align_corners", "output_mask")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'grid_sampler_2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_grid_sampler_2d_out
torch_grid_sampler_2d_out <- function(out, input, grid, interpolation_mode, padding_mode, align_corners) {
  args <- mget(x = c("out", "input", "grid", "interpolation_mode", "padding_mode", "align_corners"))
expected_types <- list(out = "Tensor", input = "Tensor", grid = "Tensor", interpolation_mode = "int64_t", 
    padding_mode = "int64_t", align_corners = "bool")
nd_args <- c("out", "input", "grid", "interpolation_mode", "padding_mode", 
"align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'grid_sampler_2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_grid_sampler_3d
torch_grid_sampler_3d <- function(input, grid, interpolation_mode, padding_mode, align_corners) {
  args <- mget(x = c("input", "grid", "interpolation_mode", "padding_mode", "align_corners"))
expected_types <- list(input = "Tensor", grid = "Tensor", interpolation_mode = "int64_t", 
    padding_mode = "int64_t", align_corners = "bool")
nd_args <- c("input", "grid", "interpolation_mode", "padding_mode", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'grid_sampler_3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_grid_sampler_3d_backward
torch_grid_sampler_3d_backward <- function(grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask) {
  args <- mget(x = c("grad_output", "input", "grid", "interpolation_mode", "padding_mode", "align_corners", "output_mask"))
expected_types <- list(grad_output = "Tensor", input = "Tensor", grid = "Tensor", 
    interpolation_mode = "int64_t", padding_mode = "int64_t", 
    align_corners = "bool", output_mask = "::std::array<bool,2>")
nd_args <- c("grad_output", "input", "grid", "interpolation_mode", "padding_mode", 
"align_corners", "output_mask")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'grid_sampler_3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_grid_sampler_3d_backward_out
torch_grid_sampler_3d_backward_out <- function(out0, out1, grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask) {
  args <- mget(x = c("out0", "out1", "grad_output", "input", "grid", "interpolation_mode", "padding_mode", "align_corners", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", grad_output = "Tensor", 
    input = "Tensor", grid = "Tensor", interpolation_mode = "int64_t", 
    padding_mode = "int64_t", align_corners = "bool", output_mask = "::std::array<bool,2>")
nd_args <- c("out0", "out1", "grad_output", "input", "grid", "interpolation_mode", 
"padding_mode", "align_corners", "output_mask")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'grid_sampler_3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_grid_sampler_3d_out
torch_grid_sampler_3d_out <- function(out, input, grid, interpolation_mode, padding_mode, align_corners) {
  args <- mget(x = c("out", "input", "grid", "interpolation_mode", "padding_mode", "align_corners"))
expected_types <- list(out = "Tensor", input = "Tensor", grid = "Tensor", interpolation_mode = "int64_t", 
    padding_mode = "int64_t", align_corners = "bool")
nd_args <- c("out", "input", "grid", "interpolation_mode", "padding_mode", 
"align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'grid_sampler_3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_group_norm
torch_group_norm <- function(input, num_groups, weight = list(), bias = list(), eps = 1e-05, cudnn_enabled = TRUE) {
  args <- mget(x = c("input", "num_groups", "weight", "bias", "eps", "cudnn_enabled"))
expected_types <- list(input = "Tensor", num_groups = "int64_t", weight = "Tensor", 
    bias = "Tensor", eps = "double", cudnn_enabled = "bool")
nd_args <- c("input", "num_groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'group_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gru
torch_gru <- function(data, input, batch_sizes, hx, params, has_biases, num_layers, dropout, train, batch_first, bidirectional) {
  args <- mget(x = c("data", "input", "batch_sizes", "hx", "params", "has_biases", "num_layers", "dropout", "train", "batch_first", "bidirectional"))
expected_types <- list(data = "Tensor", input = "Tensor", batch_sizes = "Tensor", 
    hx = "Tensor", params = "TensorList", has_biases = "bool", 
    num_layers = "int64_t", dropout = "double", train = "bool", 
    batch_first = "bool", bidirectional = "bool")
nd_args <- c("data", "input", "batch_sizes", "hx", "params", "has_biases", 
"num_layers", "dropout", "train", "batch_first", "bidirectional"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'gru',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gru_cell
torch_gru_cell <- function(input, hx, w_ih, w_hh, b_ih = list(), b_hh = list()) {
  args <- mget(x = c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh"))
expected_types <- list(input = "Tensor", hx = "Tensor", w_ih = "Tensor", w_hh = "Tensor", 
    b_ih = "Tensor", b_hh = "Tensor")
nd_args <- c("input", "hx", "w_ih", "w_hh")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gru_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gt
torch_gt <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gt',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_gt_out
torch_gt_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'gt_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_hamming_window
.torch_hamming_window <- function(window_length, periodic, alpha, beta, options = list()) {
  args <- mget(x = c("window_length", "periodic", "alpha", "beta", "options"))
expected_types <- list(window_length = "int64_t", periodic = "bool", alpha = "double", 
    beta = "double", options = "TensorOptions")
nd_args <- c("window_length", "periodic", "alpha", "beta")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hamming_window',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hamming_window_out
torch_hamming_window_out <- function(out, window_length, periodic, alpha, beta) {
  args <- mget(x = c("out", "window_length", "periodic", "alpha", "beta"))
expected_types <- list(out = "Tensor", window_length = "int64_t", periodic = "bool", 
    alpha = "double", beta = "double")
nd_args <- c("out", "window_length", "periodic", "alpha", "beta")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hamming_window_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_hann_window
.torch_hann_window <- function(window_length, periodic, options = list()) {
  args <- mget(x = c("window_length", "periodic", "options"))
expected_types <- list(window_length = "int64_t", periodic = "bool", options = "TensorOptions")
nd_args <- c("window_length", "periodic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hann_window',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hann_window_out
torch_hann_window_out <- function(out, window_length, periodic) {
  args <- mget(x = c("out", "window_length", "periodic"))
expected_types <- list(out = "Tensor", window_length = "int64_t", periodic = "bool")
nd_args <- c("out", "window_length", "periodic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hann_window_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardshrink
torch_hardshrink <- function(self, lambd = 0.5) {
  args <- mget(x = c("self", "lambd"))
expected_types <- list(self = "Tensor", lambd = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardshrink',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardshrink_backward
torch_hardshrink_backward <- function(grad_out, self, lambd) {
  args <- mget(x = c("grad_out", "self", "lambd"))
expected_types <- list(grad_out = "Tensor", self = "Tensor", lambd = "Scalar")
nd_args <- c("grad_out", "self", "lambd")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardshrink_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardshrink_backward_out
torch_hardshrink_backward_out <- function(grad_input, grad_out, self, lambd) {
  args <- mget(x = c("grad_input", "grad_out", "self", "lambd"))
expected_types <- list(grad_input = "Tensor", grad_out = "Tensor", self = "Tensor", 
    lambd = "Scalar")
nd_args <- c("grad_input", "grad_out", "self", "lambd")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardshrink_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardshrink_out
torch_hardshrink_out <- function(out, self, lambd = 0.5) {
  args <- mget(x = c("out", "self", "lambd"))
expected_types <- list(out = "Tensor", self = "Tensor", lambd = "Scalar")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardshrink_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardsigmoid
torch_hardsigmoid <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardsigmoid',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardsigmoid_
torch_hardsigmoid_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardsigmoid_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardsigmoid_backward
torch_hardsigmoid_backward <- function(grad_output, self) {
  args <- mget(x = c("grad_output", "self"))
expected_types <- list(grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardsigmoid_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardsigmoid_backward_out
torch_hardsigmoid_backward_out <- function(grad_input, grad_output, self) {
  args <- mget(x = c("grad_input", "grad_output", "self"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_input", "grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardsigmoid_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardsigmoid_out
torch_hardsigmoid_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardsigmoid_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardswish
torch_hardswish <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardswish',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardswish_
torch_hardswish_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardswish_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardswish_backward
torch_hardswish_backward <- function(grad_output, self) {
  args <- mget(x = c("grad_output", "self"))
expected_types <- list(grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardswish_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardswish_backward_out
torch_hardswish_backward_out <- function(out, grad_output, self) {
  args <- mget(x = c("out", "grad_output", "self"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", self = "Tensor")
nd_args <- c("out", "grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardswish_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardswish_out
torch_hardswish_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardswish_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardtanh
torch_hardtanh <- function(self, min_val = -1L, max_val = 1L) {
  args <- mget(x = c("self", "min_val", "max_val"))
expected_types <- list(self = "Tensor", min_val = "Scalar", max_val = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardtanh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardtanh_
torch_hardtanh_ <- function(self, min_val = -1L, max_val = 1L) {
  args <- mget(x = c("self", "min_val", "max_val"))
expected_types <- list(self = "Tensor", min_val = "Scalar", max_val = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardtanh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardtanh_backward
torch_hardtanh_backward <- function(grad_output, self, min_val, max_val) {
  args <- mget(x = c("grad_output", "self", "min_val", "max_val"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", min_val = "Scalar", 
    max_val = "Scalar")
nd_args <- c("grad_output", "self", "min_val", "max_val")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardtanh_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardtanh_backward_out
torch_hardtanh_backward_out <- function(grad_input, grad_output, self, min_val, max_val) {
  args <- mget(x = c("grad_input", "grad_output", "self", "min_val", "max_val"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    min_val = "Scalar", max_val = "Scalar")
nd_args <- c("grad_input", "grad_output", "self", "min_val", "max_val")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardtanh_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hardtanh_out
torch_hardtanh_out <- function(out, self, min_val = -1L, max_val = 1L) {
  args <- mget(x = c("out", "self", "min_val", "max_val"))
expected_types <- list(out = "Tensor", self = "Tensor", min_val = "Scalar", max_val = "Scalar")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hardtanh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_heaviside
torch_heaviside <- function(self, values) {
  args <- mget(x = c("self", "values"))
expected_types <- list(self = "Tensor", values = "Tensor")
nd_args <- c("self", "values")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'heaviside',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_heaviside_out
torch_heaviside_out <- function(out, self, values) {
  args <- mget(x = c("out", "self", "values"))
expected_types <- list(out = "Tensor", self = "Tensor", values = "Tensor")
nd_args <- c("out", "self", "values")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'heaviside_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hinge_embedding_loss
torch_hinge_embedding_loss <- function(self, target, margin = 1L, reduction = torch_reduction_mean()) {
  args <- mget(x = c("self", "target", "margin", "reduction"))
expected_types <- list(self = "Tensor", target = "Tensor", margin = "double", reduction = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hinge_embedding_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_histc
torch_histc <- function(self, bins = 100L, min = 0L, max = 0L) {
  args <- mget(x = c("self", "bins", "min", "max"))
expected_types <- list(self = "Tensor", bins = "int64_t", min = "Scalar", max = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'histc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_histc_out
torch_histc_out <- function(out, self, bins = 100L, min = 0L, max = 0L) {
  args <- mget(x = c("out", "self", "bins", "min", "max"))
expected_types <- list(out = "Tensor", self = "Tensor", bins = "int64_t", min = "Scalar", 
    max = "Scalar")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'histc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_histogram
torch_histogram <- function(self, bins = 100L, range = NULL, weight = list(), density = FALSE) {
  args <- mget(x = c("self", "bins", "range", "weight", "density"))
expected_types <- list(self = "Tensor", bins = c("Tensor", "int64_t"), range = "ArrayRef<double>", 
    weight = "Tensor", density = "bool")
nd_args <- c("self", "bins")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'histogram',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_histogram_out
torch_histogram_out <- function(hist, bin_edges, self, bins = 100L, range = NULL, weight = list(), density = FALSE) {
  args <- mget(x = c("hist", "bin_edges", "self", "bins", "range", "weight", "density"))
expected_types <- list(hist = "Tensor", bin_edges = "Tensor", self = "Tensor", 
    bins = c("Tensor", "int64_t"), range = "ArrayRef<double>", 
    weight = "Tensor", density = "bool")
nd_args <- c("hist", "bin_edges", "self", "bins")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'histogram_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_histogramdd
torch_histogramdd <- function(self, bins, range = NULL, weight = list(), density = FALSE) {
  args <- mget(x = c("self", "bins", "range", "weight", "density"))
expected_types <- list(self = "Tensor", bins = c("IntArrayRef", "int64_t", "TensorList"
), range = "ArrayRef<double>", weight = "Tensor", density = "bool")
nd_args <- c("self", "bins")
return_types <- list(list("Tensor", "TensorList"))
call_c_function(
fun_name = 'histogramdd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hsplit
torch_hsplit <- function(self, indices, sections) {
  args <- mget(x = c("self", "indices", "sections"))
expected_types <- list(self = "Tensor", indices = "IntArrayRef", sections = "int64_t")
nd_args <- c("self", "indices", "sections")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'hsplit',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hspmm
torch_hspmm <- function(mat1, mat2) {
  args <- mget(x = c("mat1", "mat2"))
expected_types <- list(mat1 = "Tensor", mat2 = "Tensor")
nd_args <- c("mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hspmm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hspmm_out
torch_hspmm_out <- function(out, mat1, mat2) {
  args <- mget(x = c("out", "mat1", "mat2"))
expected_types <- list(out = "Tensor", mat1 = "Tensor", mat2 = "Tensor")
nd_args <- c("out", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hspmm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hstack
torch_hstack <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hstack',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hstack_out
torch_hstack_out <- function(out, tensors) {
  args <- mget(x = c("out", "tensors"))
expected_types <- list(out = "Tensor", tensors = "TensorList")
nd_args <- c("out", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hstack_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_huber_loss
torch_huber_loss <- function(self, target, reduction = torch_reduction_mean(), delta = 1L) {
  args <- mget(x = c("self", "target", "reduction", "delta"))
expected_types <- list(self = "Tensor", target = "Tensor", reduction = "int64_t", 
    delta = "double")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'huber_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_huber_loss_backward
torch_huber_loss_backward <- function(grad_output, self, target, reduction, delta) {
  args <- mget(x = c("grad_output", "self", "target", "reduction", "delta"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", target = "Tensor", 
    reduction = "int64_t", delta = "double")
nd_args <- c("grad_output", "self", "target", "reduction", "delta")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'huber_loss_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_huber_loss_backward_out
torch_huber_loss_backward_out <- function(grad_input, grad_output, self, target, reduction, delta) {
  args <- mget(x = c("grad_input", "grad_output", "self", "target", "reduction", "delta"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    target = "Tensor", reduction = "int64_t", delta = "double")
nd_args <- c("grad_input", "grad_output", "self", "target", "reduction", 
"delta")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'huber_loss_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_huber_loss_out
torch_huber_loss_out <- function(out, self, target, reduction = torch_reduction_mean(), delta = 1L) {
  args <- mget(x = c("out", "self", "target", "reduction", "delta"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", reduction = "int64_t", 
    delta = "double")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'huber_loss_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hypot
torch_hypot <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hypot',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_hypot_out
torch_hypot_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'hypot_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_i0
torch_i0 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'i0',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_i0_
torch_i0_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'i0_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_i0_out
torch_i0_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'i0_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_igamma
torch_igamma <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'igamma',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_igamma_out
torch_igamma_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'igamma_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_igammac
torch_igammac <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'igammac',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_igammac_out
torch_igammac_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'igammac_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_im2col
torch_im2col <- function(self, kernel_size, dilation, padding, stride) {
  args <- mget(x = c("self", "kernel_size", "dilation", "padding", "stride"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", dilation = "IntArrayRef", 
    padding = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("self", "kernel_size", "dilation", "padding", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'im2col',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_im2col_out
torch_im2col_out <- function(out, self, kernel_size, dilation, padding, stride) {
  args <- mget(x = c("out", "self", "kernel_size", "dilation", "padding", "stride"))
expected_types <- list(out = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    dilation = "IntArrayRef", padding = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("out", "self", "kernel_size", "dilation", "padding", "stride"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'im2col_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_imag
torch_imag <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'imag',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index
torch_index <- function(self, indices) {
  args <- mget(x = c("self", "indices"))
expected_types <- list(self = "Tensor", indices = "const c10::List<c10::optional<Tensor>> &")
nd_args <- c("self", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_add
torch_index_add <- function(self, dim, index, source, alpha = 1L) {
  args <- mget(x = c("self", "dim", "index", "source", "alpha"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), index = "Tensor", 
    source = "Tensor", alpha = "Scalar")
nd_args <- c("self", "dim", "index", "source")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_add',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_add_out
torch_index_add_out <- function(out, self, dim, index, source, alpha = 1L) {
  args <- mget(x = c("out", "self", "dim", "index", "source", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", index = "Tensor", 
    source = "Tensor", alpha = "Scalar")
nd_args <- c("out", "self", "dim", "index", "source")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_add_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_copy
torch_index_copy <- function(self, dim, index, source) {
  args <- mget(x = c("self", "dim", "index", "source"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), index = "Tensor", 
    source = "Tensor")
nd_args <- c("self", "dim", "index", "source")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_copy_out
torch_index_copy_out <- function(out, self, dim, index, source) {
  args <- mget(x = c("out", "self", "dim", "index", "source"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", index = "Tensor", 
    source = "Tensor")
nd_args <- c("out", "self", "dim", "index", "source")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_fill
torch_index_fill <- function(self, dim, index, value) {
  args <- mget(x = c("self", "dim", "index", "value"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), index = "Tensor", 
    value = c("Scalar", "Tensor"))
nd_args <- c("self", "dim", "index", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_fill',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_fill_out
torch_index_fill_out <- function(out, self, dim, index, value) {
  args <- mget(x = c("out", "self", "dim", "index", "value"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", index = "Tensor", 
    value = c("Scalar", "Tensor"))
nd_args <- c("out", "self", "dim", "index", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_fill_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_out
torch_index_out <- function(out, self, indices) {
  args <- mget(x = c("out", "self", "indices"))
expected_types <- list(out = "Tensor", self = "Tensor", indices = "const c10::List<c10::optional<Tensor>> &")
nd_args <- c("out", "self", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_put
torch_index_put <- function(self, indices, values, accumulate = FALSE) {
  args <- mget(x = c("self", "indices", "values", "accumulate"))
expected_types <- list(self = "Tensor", indices = "const c10::List<c10::optional<Tensor>> &", 
    values = "Tensor", accumulate = "bool")
nd_args <- c("self", "indices", "values")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_put',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_put_
torch_index_put_ <- function(self, indices, values, accumulate = FALSE) {
  args <- mget(x = c("self", "indices", "values", "accumulate"))
expected_types <- list(self = "Tensor", indices = "const c10::List<c10::optional<Tensor>> &", 
    values = "Tensor", accumulate = "bool")
nd_args <- c("self", "indices", "values")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_put_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_put_out
torch_index_put_out <- function(out, self, indices, values, accumulate = FALSE) {
  args <- mget(x = c("out", "self", "indices", "values", "accumulate"))
expected_types <- list(out = "Tensor", self = "Tensor", indices = "const c10::List<c10::optional<Tensor>> &", 
    values = "Tensor", accumulate = "bool")
nd_args <- c("out", "self", "indices", "values")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_put_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_reduce
torch_index_reduce <- function(self, dim, index, source, reduce, include_self = TRUE) {
  args <- mget(x = c("self", "dim", "index", "source", "reduce", "include_self"))
expected_types <- list(self = "Tensor", dim = "int64_t", index = "Tensor", source = "Tensor", 
    reduce = "c10::string_view", include_self = "bool")
nd_args <- c("self", "dim", "index", "source", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_reduce',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_reduce_out
torch_index_reduce_out <- function(out, self, dim, index, source, reduce, include_self = TRUE) {
  args <- mget(x = c("out", "self", "dim", "index", "source", "reduce", "include_self"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", index = "Tensor", 
    source = "Tensor", reduce = "c10::string_view", include_self = "bool")
nd_args <- c("out", "self", "dim", "index", "source", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_reduce_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_select
torch_index_select <- function(self, dim, index) {
  args <- mget(x = c("self", "dim", "index"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), index = "Tensor")
nd_args <- c("self", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_select',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_select_backward
torch_index_select_backward <- function(grad, self_sizes, dim, index) {
  args <- mget(x = c("grad", "self_sizes", "dim", "index"))
expected_types <- list(grad = "Tensor", self_sizes = "IntArrayRef", dim = "int64_t", 
    index = "Tensor")
nd_args <- c("grad", "self_sizes", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_select_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_index_select_out
torch_index_select_out <- function(out, self, dim, index) {
  args <- mget(x = c("out", "self", "dim", "index"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("int64_t", "Dimname"
), index = "Tensor")
nd_args <- c("out", "self", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'index_select_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_indices_copy
torch_indices_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'indices_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_indices_copy_out
torch_indices_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'indices_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_infinitely_differentiable_gelu_backward
torch_infinitely_differentiable_gelu_backward <- function(grad, self) {
  args <- mget(x = c("grad", "self"))
expected_types <- list(grad = "Tensor", self = "Tensor")
nd_args <- c("grad", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'infinitely_differentiable_gelu_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_inner
torch_inner <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'inner',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_inner_out
torch_inner_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'inner_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_instance_norm
torch_instance_norm <- function(input, weight, bias, running_mean, running_var, use_input_stats, momentum, eps, cudnn_enabled) {
  args <- mget(x = c("input", "weight", "bias", "running_mean", "running_var", "use_input_stats", "momentum", "eps", "cudnn_enabled"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", use_input_stats = "bool", momentum = "double", 
    eps = "double", cudnn_enabled = "bool")
nd_args <- c("input", "weight", "bias", "running_mean", "running_var", "use_input_stats", 
"momentum", "eps", "cudnn_enabled")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'instance_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_int_repr
torch_int_repr <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'int_repr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_int_repr_out
torch_int_repr_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'int_repr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_inverse
torch_inverse <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'inverse',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_inverse_out
torch_inverse_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'inverse_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_is_complex
torch_is_complex <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = 'is_complex',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_is_conj
torch_is_conj <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = 'is_conj',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_is_distributed
torch_is_distributed <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = 'is_distributed',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_is_floating_point
torch_is_floating_point <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = 'is_floating_point',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_is_inference
torch_is_inference <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = 'is_inference',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_is_neg
torch_is_neg <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = 'is_neg',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_is_nonzero
torch_is_nonzero <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = 'is_nonzero',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_is_same_size
torch_is_same_size <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('bool'))
call_c_function(
fun_name = 'is_same_size',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_is_signed
torch_is_signed <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('bool'))
call_c_function(
fun_name = 'is_signed',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isclose
torch_isclose <- function(self, other, rtol = 1e-05, atol = 1e-08, equal_nan = FALSE) {
  args <- mget(x = c("self", "other", "rtol", "atol", "equal_nan"))
expected_types <- list(self = "Tensor", other = "Tensor", rtol = "double", atol = "double", 
    equal_nan = "bool")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isclose',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isfinite
torch_isfinite <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isfinite',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isin
torch_isin <- function(element, elements, test_element, test_elements, assume_unique = FALSE, invert = FALSE) {
  args <- mget(x = c("element", "elements", "test_element", "test_elements", "assume_unique", "invert"))
expected_types <- list(element = "Scalar", elements = "Tensor", test_element = "Scalar", 
    test_elements = "Tensor", assume_unique = "bool", invert = "bool")
nd_args <- c("element", "elements", "test_element", "test_elements")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isin_out
torch_isin_out <- function(out, element, elements, test_element, test_elements, assume_unique = FALSE, invert = FALSE) {
  args <- mget(x = c("out", "element", "elements", "test_element", "test_elements", "assume_unique", "invert"))
expected_types <- list(out = "Tensor", element = "Scalar", elements = "Tensor", 
    test_element = "Scalar", test_elements = "Tensor", assume_unique = "bool", 
    invert = "bool")
nd_args <- c("out", "element", "elements", "test_element", "test_elements"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isinf
torch_isinf <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isinf',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isinf_out
torch_isinf_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isinf_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isnan
torch_isnan <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isnan',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isnan_out
torch_isnan_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isnan_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isneginf
torch_isneginf <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isneginf',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isneginf_out
torch_isneginf_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isneginf_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isposinf
torch_isposinf <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isposinf',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isposinf_out
torch_isposinf_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isposinf_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_isreal
torch_isreal <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'isreal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_istft
torch_istft <- function(self, n_fft, hop_length = NULL, win_length = NULL, window = list(), center = TRUE, normalized = FALSE, onesided = NULL, length = NULL, return_complex = FALSE) {
  args <- mget(x = c("self", "n_fft", "hop_length", "win_length", "window", "center", "normalized", "onesided", "length", "return_complex"))
expected_types <- list(self = "Tensor", n_fft = "int64_t", hop_length = "int64_t", 
    win_length = "int64_t", window = "Tensor", center = "bool", 
    normalized = "bool", onesided = "bool", length = "int64_t", 
    return_complex = "bool")
nd_args <- c("self", "n_fft")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'istft',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_kaiser_window
.torch_kaiser_window <- function(window_length, periodic, beta, options = list()) {
  args <- mget(x = c("window_length", "periodic", "beta", "options"))
expected_types <- list(window_length = "int64_t", periodic = "bool", beta = "double", 
    options = "TensorOptions")
nd_args <- c("window_length", "periodic", "beta")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'kaiser_window',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_kaiser_window_out
torch_kaiser_window_out <- function(out, window_length, periodic, beta) {
  args <- mget(x = c("out", "window_length", "periodic", "beta"))
expected_types <- list(out = "Tensor", window_length = "int64_t", periodic = "bool", 
    beta = "double")
nd_args <- c("out", "window_length", "periodic", "beta")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'kaiser_window_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_kl_div
torch_kl_div <- function(self, target, reduction = torch_reduction_mean(), log_target = FALSE) {
  args <- mget(x = c("self", "target", "reduction", "log_target"))
expected_types <- list(self = "Tensor", target = "Tensor", reduction = "int64_t", 
    log_target = "bool")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'kl_div',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_kron
torch_kron <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'kron',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_kron_out
torch_kron_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'kron_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_kthvalue
torch_kthvalue <- function(self, k, dim = -1L, keepdim = FALSE) {
  args <- mget(x = c("self", "k", "dim", "keepdim"))
expected_types <- list(self = "Tensor", k = "int64_t", dim = c("int64_t", "Dimname"
), keepdim = "bool")
nd_args <- c("self", "k", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'kthvalue',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_kthvalue_out
torch_kthvalue_out <- function(values, indices, self, k, dim = -1L, keepdim = FALSE) {
  args <- mget(x = c("values", "indices", "self", "k", "dim", "keepdim"))
expected_types <- list(values = "Tensor", indices = "Tensor", self = "Tensor", 
    k = "int64_t", dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("values", "indices", "self", "k", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'kthvalue_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_l1_loss
torch_l1_loss <- function(self, target, reduction = torch_reduction_mean()) {
  args <- mget(x = c("self", "target", "reduction"))
expected_types <- list(self = "Tensor", target = "Tensor", reduction = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'l1_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_layer_norm
torch_layer_norm <- function(input, normalized_shape, weight = list(), bias = list(), eps = 1e-05, cudnn_enable = TRUE) {
  args <- mget(x = c("input", "normalized_shape", "weight", "bias", "eps", "cudnn_enable"))
expected_types <- list(input = "Tensor", normalized_shape = "IntArrayRef", weight = "Tensor", 
    bias = "Tensor", eps = "double", cudnn_enable = "bool")
nd_args <- c("input", "normalized_shape")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'layer_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lcm
torch_lcm <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lcm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lcm_
torch_lcm_ <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lcm_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lcm_out
torch_lcm_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lcm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ldexp
torch_ldexp <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ldexp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ldexp_
torch_ldexp_ <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ldexp_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ldexp_out
torch_ldexp_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ldexp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_le
torch_le <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'le',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_le_out
torch_le_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'le_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_leaky_relu
torch_leaky_relu <- function(self, negative_slope = 0.01) {
  args <- mget(x = c("self", "negative_slope"))
expected_types <- list(self = "Tensor", negative_slope = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'leaky_relu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_leaky_relu_
torch_leaky_relu_ <- function(self, negative_slope = 0.01) {
  args <- mget(x = c("self", "negative_slope"))
expected_types <- list(self = "Tensor", negative_slope = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'leaky_relu_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_leaky_relu_backward
torch_leaky_relu_backward <- function(grad_output, self, negative_slope, self_is_result) {
  args <- mget(x = c("grad_output", "self", "negative_slope", "self_is_result"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", negative_slope = "Scalar", 
    self_is_result = "bool")
nd_args <- c("grad_output", "self", "negative_slope", "self_is_result")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'leaky_relu_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_leaky_relu_backward_out
torch_leaky_relu_backward_out <- function(grad_input, grad_output, self, negative_slope, self_is_result) {
  args <- mget(x = c("grad_input", "grad_output", "self", "negative_slope", "self_is_result"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    negative_slope = "Scalar", self_is_result = "bool")
nd_args <- c("grad_input", "grad_output", "self", "negative_slope", "self_is_result"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'leaky_relu_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_leaky_relu_out
torch_leaky_relu_out <- function(out, self, negative_slope = 0.01) {
  args <- mget(x = c("out", "self", "negative_slope"))
expected_types <- list(out = "Tensor", self = "Tensor", negative_slope = "Scalar")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'leaky_relu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lerp
torch_lerp <- function(self, end, weight) {
  args <- mget(x = c("self", "end", "weight"))
expected_types <- list(self = "Tensor", end = "Tensor", weight = c("Scalar", "Tensor"
))
nd_args <- c("self", "end", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lerp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lerp_out
torch_lerp_out <- function(out, self, end, weight) {
  args <- mget(x = c("out", "self", "end", "weight"))
expected_types <- list(out = "Tensor", self = "Tensor", end = "Tensor", weight = c("Scalar", 
"Tensor"))
nd_args <- c("out", "self", "end", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lerp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_less
torch_less <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'less',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_less_equal
torch_less_equal <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'less_equal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_less_equal_out
torch_less_equal_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'less_equal_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_less_out
torch_less_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'less_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lgamma
torch_lgamma <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lgamma',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lgamma_out
torch_lgamma_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lgamma_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lift
torch_lift <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lift',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lift_fresh
torch_lift_fresh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lift_fresh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lift_fresh_copy
torch_lift_fresh_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lift_fresh_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lift_fresh_copy_out
torch_lift_fresh_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lift_fresh_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lift_out
torch_lift_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lift_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_cholesky
torch_linalg_cholesky <- function(self, upper = FALSE) {
  args <- mget(x = c("self", "upper"))
expected_types <- list(self = "Tensor", upper = "bool")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_cholesky',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_cholesky_ex
torch_linalg_cholesky_ex <- function(self, upper = FALSE, check_errors = FALSE) {
  args <- mget(x = c("self", "upper", "check_errors"))
expected_types <- list(self = "Tensor", upper = "bool", check_errors = "bool")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_cholesky_ex',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_cholesky_ex_out
torch_linalg_cholesky_ex_out <- function(L, info, self, upper = FALSE, check_errors = FALSE) {
  args <- mget(x = c("L", "info", "self", "upper", "check_errors"))
expected_types <- list(L = "Tensor", info = "Tensor", self = "Tensor", upper = "bool", 
    check_errors = "bool")
nd_args <- c("L", "info", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_cholesky_ex_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_cholesky_out
torch_linalg_cholesky_out <- function(out, self, upper = FALSE) {
  args <- mget(x = c("out", "self", "upper"))
expected_types <- list(out = "Tensor", self = "Tensor", upper = "bool")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_cholesky_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_cond
torch_linalg_cond <- function(self, p = NULL) {
  args <- mget(x = c("self", "p"))
expected_types <- list(self = "Tensor", p = c("Scalar", "c10::string_view"))
nd_args <- c("self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_cond',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_cond_out
torch_linalg_cond_out <- function(out, self, p = NULL) {
  args <- mget(x = c("out", "self", "p"))
expected_types <- list(out = "Tensor", self = "Tensor", p = c("Scalar", "c10::string_view"
))
nd_args <- c("out", "self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_cond_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_cross
torch_linalg_cross <- function(self, other, dim = -1L) {
  args <- mget(x = c("self", "other", "dim"))
expected_types <- list(self = "Tensor", other = "Tensor", dim = "int64_t")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_cross',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_cross_out
torch_linalg_cross_out <- function(out, self, other, dim = -1L) {
  args <- mget(x = c("out", "self", "other", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor", dim = "int64_t")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_cross_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_det
torch_linalg_det <- function(A) {
  args <- mget(x = c("A"))
expected_types <- list(A = "Tensor")
nd_args <- "A"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_det',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_det_out
torch_linalg_det_out <- function(out, A) {
  args <- mget(x = c("out", "A"))
expected_types <- list(out = "Tensor", A = "Tensor")
nd_args <- c("out", "A")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_det_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_diagonal
torch_linalg_diagonal <- function(A, offset = 0L, dim1 = -2L, dim2 = -1L) {
  args <- mget(x = c("A", "offset", "dim1", "dim2"))
expected_types <- list(A = "Tensor", offset = "int64_t", dim1 = "int64_t", dim2 = "int64_t")
nd_args <- "A"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_diagonal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_eig
torch_linalg_eig <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_eig',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_eig_out
torch_linalg_eig_out <- function(eigenvalues, eigenvectors, self) {
  args <- mget(x = c("eigenvalues", "eigenvectors", "self"))
expected_types <- list(eigenvalues = "Tensor", eigenvectors = "Tensor", self = "Tensor")
nd_args <- c("eigenvalues", "eigenvectors", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_eig_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_eigh
torch_linalg_eigh <- function(self, UPLO = "L") {
  args <- mget(x = c("self", "UPLO"))
expected_types <- list(self = "Tensor", UPLO = "c10::string_view")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_eigh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_eigh_out
torch_linalg_eigh_out <- function(eigvals, eigvecs, self, UPLO = "L") {
  args <- mget(x = c("eigvals", "eigvecs", "self", "UPLO"))
expected_types <- list(eigvals = "Tensor", eigvecs = "Tensor", self = "Tensor", 
    UPLO = "c10::string_view")
nd_args <- c("eigvals", "eigvecs", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_eigh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_eigvals
torch_linalg_eigvals <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_eigvals',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_eigvals_out
torch_linalg_eigvals_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_eigvals_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_eigvalsh
torch_linalg_eigvalsh <- function(self, UPLO = "L") {
  args <- mget(x = c("self", "UPLO"))
expected_types <- list(self = "Tensor", UPLO = "c10::string_view")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_eigvalsh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_eigvalsh_out
torch_linalg_eigvalsh_out <- function(out, self, UPLO = "L") {
  args <- mget(x = c("out", "self", "UPLO"))
expected_types <- list(out = "Tensor", self = "Tensor", UPLO = "c10::string_view")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_eigvalsh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_householder_product
torch_linalg_householder_product <- function(input, tau) {
  args <- mget(x = c("input", "tau"))
expected_types <- list(input = "Tensor", tau = "Tensor")
nd_args <- c("input", "tau")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_householder_product',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_householder_product_out
torch_linalg_householder_product_out <- function(out, input, tau) {
  args <- mget(x = c("out", "input", "tau"))
expected_types <- list(out = "Tensor", input = "Tensor", tau = "Tensor")
nd_args <- c("out", "input", "tau")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_householder_product_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_inv
torch_linalg_inv <- function(A) {
  args <- mget(x = c("A"))
expected_types <- list(A = "Tensor")
nd_args <- "A"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_inv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_inv_ex
torch_linalg_inv_ex <- function(A, check_errors = FALSE) {
  args <- mget(x = c("A", "check_errors"))
expected_types <- list(A = "Tensor", check_errors = "bool")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_inv_ex',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_inv_ex_out
torch_linalg_inv_ex_out <- function(inverse, info, A, check_errors = FALSE) {
  args <- mget(x = c("inverse", "info", "A", "check_errors"))
expected_types <- list(inverse = "Tensor", info = "Tensor", A = "Tensor", check_errors = "bool")
nd_args <- c("inverse", "info", "A")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_inv_ex_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_inv_out
torch_linalg_inv_out <- function(out, A) {
  args <- mget(x = c("out", "A"))
expected_types <- list(out = "Tensor", A = "Tensor")
nd_args <- c("out", "A")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_inv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_ldl_factor
torch_linalg_ldl_factor <- function(self, hermitian = FALSE) {
  args <- mget(x = c("self", "hermitian"))
expected_types <- list(self = "Tensor", hermitian = "bool")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_ldl_factor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_ldl_factor_ex
torch_linalg_ldl_factor_ex <- function(self, hermitian = FALSE, check_errors = FALSE) {
  args <- mget(x = c("self", "hermitian", "check_errors"))
expected_types <- list(self = "Tensor", hermitian = "bool", check_errors = "bool")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_ldl_factor_ex',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_ldl_factor_ex_out
torch_linalg_ldl_factor_ex_out <- function(LD, pivots, info, self, hermitian = FALSE, check_errors = FALSE) {
  args <- mget(x = c("LD", "pivots", "info", "self", "hermitian", "check_errors"))
expected_types <- list(LD = "Tensor", pivots = "Tensor", info = "Tensor", self = "Tensor", 
    hermitian = "bool", check_errors = "bool")
nd_args <- c("LD", "pivots", "info", "self")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_ldl_factor_ex_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_ldl_factor_out
torch_linalg_ldl_factor_out <- function(LD, pivots, self, hermitian = FALSE) {
  args <- mget(x = c("LD", "pivots", "self", "hermitian"))
expected_types <- list(LD = "Tensor", pivots = "Tensor", self = "Tensor", hermitian = "bool")
nd_args <- c("LD", "pivots", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_ldl_factor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_ldl_solve
torch_linalg_ldl_solve <- function(LD, pivots, B, hermitian = FALSE) {
  args <- mget(x = c("LD", "pivots", "B", "hermitian"))
expected_types <- list(LD = "Tensor", pivots = "Tensor", B = "Tensor", hermitian = "bool")
nd_args <- c("LD", "pivots", "B")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_ldl_solve',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_ldl_solve_out
torch_linalg_ldl_solve_out <- function(out, LD, pivots, B, hermitian = FALSE) {
  args <- mget(x = c("out", "LD", "pivots", "B", "hermitian"))
expected_types <- list(out = "Tensor", LD = "Tensor", pivots = "Tensor", B = "Tensor", 
    hermitian = "bool")
nd_args <- c("out", "LD", "pivots", "B")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_ldl_solve_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lstsq
torch_linalg_lstsq <- function(self, b, rcond = NULL, driver = NULL) {
  args <- mget(x = c("self", "b", "rcond", "driver"))
expected_types <- list(self = "Tensor", b = "Tensor", rcond = "double", driver = "c10::string_view")
nd_args <- c("self", "b")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_lstsq',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lstsq_out
torch_linalg_lstsq_out <- function(solution, residuals, rank, singular_values, self, b, rcond = NULL, driver = NULL) {
  args <- mget(x = c("solution", "residuals", "rank", "singular_values", "self", "b", "rcond", "driver"))
expected_types <- list(solution = "Tensor", residuals = "Tensor", rank = "Tensor", 
    singular_values = "Tensor", self = "Tensor", b = "Tensor", 
    rcond = "double", driver = "c10::string_view")
nd_args <- c("solution", "residuals", "rank", "singular_values", "self", 
"b")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_lstsq_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lu
torch_linalg_lu <- function(A, pivot = TRUE) {
  args <- mget(x = c("A", "pivot"))
expected_types <- list(A = "Tensor", pivot = "bool")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_lu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lu_factor
torch_linalg_lu_factor <- function(A, pivot = TRUE) {
  args <- mget(x = c("A", "pivot"))
expected_types <- list(A = "Tensor", pivot = "bool")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_lu_factor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lu_factor_ex
torch_linalg_lu_factor_ex <- function(A, pivot = TRUE, check_errors = FALSE) {
  args <- mget(x = c("A", "pivot", "check_errors"))
expected_types <- list(A = "Tensor", pivot = "bool", check_errors = "bool")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_lu_factor_ex',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lu_factor_ex_out
torch_linalg_lu_factor_ex_out <- function(LU, pivots, info, A, pivot = TRUE, check_errors = FALSE) {
  args <- mget(x = c("LU", "pivots", "info", "A", "pivot", "check_errors"))
expected_types <- list(LU = "Tensor", pivots = "Tensor", info = "Tensor", A = "Tensor", 
    pivot = "bool", check_errors = "bool")
nd_args <- c("LU", "pivots", "info", "A")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_lu_factor_ex_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lu_factor_out
torch_linalg_lu_factor_out <- function(LU, pivots, A, pivot = TRUE) {
  args <- mget(x = c("LU", "pivots", "A", "pivot"))
expected_types <- list(LU = "Tensor", pivots = "Tensor", A = "Tensor", pivot = "bool")
nd_args <- c("LU", "pivots", "A")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_lu_factor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lu_out
torch_linalg_lu_out <- function(P, L, U, A, pivot = TRUE) {
  args <- mget(x = c("P", "L", "U", "A", "pivot"))
expected_types <- list(P = "Tensor", L = "Tensor", U = "Tensor", A = "Tensor", 
    pivot = "bool")
nd_args <- c("P", "L", "U", "A")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_lu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lu_solve
torch_linalg_lu_solve <- function(LU, pivots, B, left = TRUE, adjoint = FALSE) {
  args <- mget(x = c("LU", "pivots", "B", "left", "adjoint"))
expected_types <- list(LU = "Tensor", pivots = "Tensor", B = "Tensor", left = "bool", 
    adjoint = "bool")
nd_args <- c("LU", "pivots", "B")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_lu_solve',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_lu_solve_out
torch_linalg_lu_solve_out <- function(out, LU, pivots, B, left = TRUE, adjoint = FALSE) {
  args <- mget(x = c("out", "LU", "pivots", "B", "left", "adjoint"))
expected_types <- list(out = "Tensor", LU = "Tensor", pivots = "Tensor", B = "Tensor", 
    left = "bool", adjoint = "bool")
nd_args <- c("out", "LU", "pivots", "B")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_lu_solve_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matmul
torch_linalg_matmul <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matmul',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matmul_out
torch_linalg_matmul_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matmul_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matrix_exp
torch_linalg_matrix_exp <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matrix_exp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matrix_exp_out
torch_linalg_matrix_exp_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matrix_exp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matrix_norm
torch_linalg_matrix_norm <- function(self, ord = "fro", dim = c(-2,-1), keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "ord", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", ord = c("Scalar", "c10::string_view"), 
    dim = "IntArrayRef", keepdim = "bool", dtype = "ScalarType")
nd_args <- c("self", "ord")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matrix_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matrix_norm_out
torch_linalg_matrix_norm_out <- function(out, self, ord = "fro", dim = c(-2,-1), keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "ord", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", ord = c("Scalar", "c10::string_view"
), dim = "IntArrayRef", keepdim = "bool", dtype = "ScalarType")
nd_args <- c("out", "self", "ord")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matrix_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matrix_power
torch_linalg_matrix_power <- function(self, n) {
  args <- mget(x = c("self", "n"))
expected_types <- list(self = "Tensor", n = "int64_t")
nd_args <- c("self", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matrix_power',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matrix_power_out
torch_linalg_matrix_power_out <- function(out, self, n) {
  args <- mget(x = c("out", "self", "n"))
expected_types <- list(out = "Tensor", self = "Tensor", n = "int64_t")
nd_args <- c("out", "self", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matrix_power_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matrix_rank
torch_linalg_matrix_rank <- function(input, self, atol = list(), tol, rtol = list(), hermitian = FALSE) {
  args <- mget(x = c("input", "self", "atol", "tol", "rtol", "hermitian"))
expected_types <- list(input = "Tensor", self = "Tensor", atol = c("Tensor", "double"
), tol = c("double", "Tensor"), rtol = c("Tensor", "double"), 
    hermitian = "bool")
nd_args <- c("input", "self", "atol", "tol", "rtol")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matrix_rank',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_matrix_rank_out
torch_linalg_matrix_rank_out <- function(out, input, self, atol = list(), tol, rtol = list(), hermitian = FALSE) {
  args <- mget(x = c("out", "input", "self", "atol", "tol", "rtol", "hermitian"))
expected_types <- list(out = "Tensor", input = "Tensor", self = "Tensor", atol = c("Tensor", 
"double"), tol = c("double", "Tensor"), rtol = c("Tensor", "double"
), hermitian = "bool")
nd_args <- c("out", "input", "self", "atol", "tol", "rtol")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_matrix_rank_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_multi_dot
torch_linalg_multi_dot <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_multi_dot',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_multi_dot_out
torch_linalg_multi_dot_out <- function(out, tensors) {
  args <- mget(x = c("out", "tensors"))
expected_types <- list(out = "Tensor", tensors = "TensorList")
nd_args <- c("out", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_multi_dot_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_norm
torch_linalg_norm <- function(self, ord = NULL, dim = NULL, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "ord", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", ord = c("Scalar", "c10::string_view"), 
    dim = "IntArrayRef", keepdim = "bool", dtype = "ScalarType")
nd_args <- c("self", "ord")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_norm_out
torch_linalg_norm_out <- function(out, self, ord = NULL, dim = NULL, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "ord", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", ord = c("Scalar", "c10::string_view"
), dim = "IntArrayRef", keepdim = "bool", dtype = "ScalarType")
nd_args <- c("out", "self", "ord")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_pinv
torch_linalg_pinv <- function(self, atol = list(), rcond, rtol = list(), hermitian = FALSE) {
  args <- mget(x = c("self", "atol", "rcond", "rtol", "hermitian"))
expected_types <- list(self = "Tensor", atol = c("Tensor", "double"), rcond = c("double", 
"Tensor"), rtol = c("Tensor", "double"), hermitian = "bool")
nd_args <- c("self", "atol", "rcond", "rtol")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_pinv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_pinv_out
torch_linalg_pinv_out <- function(out, self, atol = list(), rcond, rtol = list(), hermitian = FALSE) {
  args <- mget(x = c("out", "self", "atol", "rcond", "rtol", "hermitian"))
expected_types <- list(out = "Tensor", self = "Tensor", atol = c("Tensor", "double"
), rcond = c("double", "Tensor"), rtol = c("Tensor", "double"
), hermitian = "bool")
nd_args <- c("out", "self", "atol", "rcond", "rtol")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_pinv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_qr
torch_linalg_qr <- function(A, mode = "reduced") {
  args <- mget(x = c("A", "mode"))
expected_types <- list(A = "Tensor", mode = "c10::string_view")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_qr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_qr_out
torch_linalg_qr_out <- function(Q, R, A, mode = "reduced") {
  args <- mget(x = c("Q", "R", "A", "mode"))
expected_types <- list(Q = "Tensor", R = "Tensor", A = "Tensor", mode = "c10::string_view")
nd_args <- c("Q", "R", "A")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_qr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_slogdet
torch_linalg_slogdet <- function(A) {
  args <- mget(x = c("A"))
expected_types <- list(A = "Tensor")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_slogdet',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_slogdet_out
torch_linalg_slogdet_out <- function(sign, logabsdet, A) {
  args <- mget(x = c("sign", "logabsdet", "A"))
expected_types <- list(sign = "Tensor", logabsdet = "Tensor", A = "Tensor")
nd_args <- c("sign", "logabsdet", "A")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_slogdet_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_solve
torch_linalg_solve <- function(A, B, left = TRUE) {
  args <- mget(x = c("A", "B", "left"))
expected_types <- list(A = "Tensor", B = "Tensor", left = "bool")
nd_args <- c("A", "B")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_solve',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_solve_ex
torch_linalg_solve_ex <- function(A, B, left = TRUE, check_errors = FALSE) {
  args <- mget(x = c("A", "B", "left", "check_errors"))
expected_types <- list(A = "Tensor", B = "Tensor", left = "bool", check_errors = "bool")
nd_args <- c("A", "B")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_solve_ex',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_solve_ex_out
torch_linalg_solve_ex_out <- function(result, info, A, B, left = TRUE, check_errors = FALSE) {
  args <- mget(x = c("result", "info", "A", "B", "left", "check_errors"))
expected_types <- list(result = "Tensor", info = "Tensor", A = "Tensor", B = "Tensor", 
    left = "bool", check_errors = "bool")
nd_args <- c("result", "info", "A", "B")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_solve_ex_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_solve_out
torch_linalg_solve_out <- function(out, A, B, left = TRUE) {
  args <- mget(x = c("out", "A", "B", "left"))
expected_types <- list(out = "Tensor", A = "Tensor", B = "Tensor", left = "bool")
nd_args <- c("out", "A", "B")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_solve_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_solve_triangular
torch_linalg_solve_triangular <- function(self, B, upper, left = TRUE, unitriangular = FALSE) {
  args <- mget(x = c("self", "B", "upper", "left", "unitriangular"))
expected_types <- list(self = "Tensor", B = "Tensor", upper = "bool", left = "bool", 
    unitriangular = "bool")
nd_args <- c("self", "B", "upper")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_solve_triangular',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_solve_triangular_out
torch_linalg_solve_triangular_out <- function(out, self, B, upper, left = TRUE, unitriangular = FALSE) {
  args <- mget(x = c("out", "self", "B", "upper", "left", "unitriangular"))
expected_types <- list(out = "Tensor", self = "Tensor", B = "Tensor", upper = "bool", 
    left = "bool", unitriangular = "bool")
nd_args <- c("out", "self", "B", "upper")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_solve_triangular_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_svd
torch_linalg_svd <- function(A, full_matrices = TRUE, driver = NULL) {
  args <- mget(x = c("A", "full_matrices", "driver"))
expected_types <- list(A = "Tensor", full_matrices = "bool", driver = "c10::string_view")
nd_args <- "A"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_svd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_svd_out
torch_linalg_svd_out <- function(U, S, Vh, A, full_matrices = TRUE, driver = NULL) {
  args <- mget(x = c("U", "S", "Vh", "A", "full_matrices", "driver"))
expected_types <- list(U = "Tensor", S = "Tensor", Vh = "Tensor", A = "Tensor", 
    full_matrices = "bool", driver = "c10::string_view")
nd_args <- c("U", "S", "Vh", "A")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linalg_svd_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_svdvals
torch_linalg_svdvals <- function(A, driver = NULL) {
  args <- mget(x = c("A", "driver"))
expected_types <- list(A = "Tensor", driver = "c10::string_view")
nd_args <- "A"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_svdvals',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_svdvals_out
torch_linalg_svdvals_out <- function(out, A, driver = NULL) {
  args <- mget(x = c("out", "A", "driver"))
expected_types <- list(out = "Tensor", A = "Tensor", driver = "c10::string_view")
nd_args <- c("out", "A")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_svdvals_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_tensorinv
torch_linalg_tensorinv <- function(self, ind = 2L) {
  args <- mget(x = c("self", "ind"))
expected_types <- list(self = "Tensor", ind = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_tensorinv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_tensorinv_out
torch_linalg_tensorinv_out <- function(out, self, ind = 2L) {
  args <- mget(x = c("out", "self", "ind"))
expected_types <- list(out = "Tensor", self = "Tensor", ind = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_tensorinv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_tensorsolve
torch_linalg_tensorsolve <- function(self, other, dims = NULL) {
  args <- mget(x = c("self", "other", "dims"))
expected_types <- list(self = "Tensor", other = "Tensor", dims = "IntArrayRef")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_tensorsolve',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_tensorsolve_out
torch_linalg_tensorsolve_out <- function(out, self, other, dims = NULL) {
  args <- mget(x = c("out", "self", "other", "dims"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor", dims = "IntArrayRef")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_tensorsolve_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_vander
torch_linalg_vander <- function(x, False = NULL) {
  args <- mget(x = c("x", "False"))
expected_types <- list(x = "Tensor", False = "int64_t")
nd_args <- "x"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_vander',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_vecdot
torch_linalg_vecdot <- function(x, y, dim = -1L) {
  args <- mget(x = c("x", "y", "dim"))
expected_types <- list(x = "Tensor", y = "Tensor", dim = "int64_t")
nd_args <- c("x", "y")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_vecdot',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_vecdot_out
torch_linalg_vecdot_out <- function(out, x, y, dim = -1L) {
  args <- mget(x = c("out", "x", "y", "dim"))
expected_types <- list(out = "Tensor", x = "Tensor", y = "Tensor", dim = "int64_t")
nd_args <- c("out", "x", "y")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_vecdot_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_vector_norm
torch_linalg_vector_norm <- function(self, ord = 2L, dim = NULL, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "ord", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", ord = "Scalar", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_vector_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linalg_vector_norm_out
torch_linalg_vector_norm_out <- function(out, self, ord = 2L, dim = NULL, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "ord", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", ord = "Scalar", dim = "IntArrayRef", 
    keepdim = "bool", dtype = "ScalarType")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linalg_vector_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linear
torch_linear <- function(input, weight, bias = list()) {
  args <- mget(x = c("input", "weight", "bias"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor")
nd_args <- c("input", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linear',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linear_backward
torch_linear_backward <- function(self, grad_output, weight, output_mask) {
  args <- mget(x = c("self", "grad_output", "weight", "output_mask"))
expected_types <- list(self = "Tensor", grad_output = "Tensor", weight = "Tensor", 
    output_mask = "::std::array<bool,3>")
nd_args <- c("self", "grad_output", "weight", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linear_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linear_backward_out
torch_linear_backward_out <- function(out0, out1, out2, self, grad_output, weight, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "self", "grad_output", "weight", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", self = "Tensor", 
    grad_output = "Tensor", weight = "Tensor", output_mask = "::std::array<bool,3>")
nd_args <- c("out0", "out1", "out2", "self", "grad_output", "weight", "output_mask"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'linear_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linear_out
torch_linear_out <- function(out, input, weight, bias = list()) {
  args <- mget(x = c("out", "input", "weight", "bias"))
expected_types <- list(out = "Tensor", input = "Tensor", weight = "Tensor", bias = "Tensor")
nd_args <- c("out", "input", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linear_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_linspace
.torch_linspace <- function(start, end, steps, options = list()) {
  args <- mget(x = c("start", "end", "steps", "options"))
expected_types <- list(start = "Scalar", end = "Scalar", steps = "int64_t", options = "TensorOptions")
nd_args <- c("start", "end", "steps")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linspace',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_linspace_out
torch_linspace_out <- function(out, start, end, steps) {
  args <- mget(x = c("out", "start", "end", "steps"))
expected_types <- list(out = "Tensor", start = "Scalar", end = "Scalar", steps = "int64_t")
nd_args <- c("out", "start", "end", "steps")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'linspace_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log
torch_log <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_
torch_log_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_normal
torch_log_normal <- function(self, mean = 1L, std = 2L, generator = NULL) {
  args <- mget(x = c("self", "mean", "std", "generator"))
expected_types <- list(self = "Tensor", mean = "double", std = "double", generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_normal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_normal_out
torch_log_normal_out <- function(out, self, mean = 1L, std = 2L, generator = NULL) {
  args <- mget(x = c("out", "self", "mean", "std", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", mean = "double", std = "double", 
    generator = "Generator")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_normal_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_out
torch_log_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_sigmoid
torch_log_sigmoid <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_sigmoid',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_sigmoid_backward
torch_log_sigmoid_backward <- function(grad_output, self, buffer) {
  args <- mget(x = c("grad_output", "self", "buffer"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", buffer = "Tensor")
nd_args <- c("grad_output", "self", "buffer")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_sigmoid_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_sigmoid_backward_out
torch_log_sigmoid_backward_out <- function(grad_input, grad_output, self, buffer) {
  args <- mget(x = c("grad_input", "grad_output", "self", "buffer"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    buffer = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "buffer")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_sigmoid_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_sigmoid_forward
torch_log_sigmoid_forward <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'log_sigmoid_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_sigmoid_forward_out
torch_log_sigmoid_forward_out <- function(output, buffer, self) {
  args <- mget(x = c("output", "buffer", "self"))
expected_types <- list(output = "Tensor", buffer = "Tensor", self = "Tensor")
nd_args <- c("output", "buffer", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'log_sigmoid_forward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_sigmoid_out
torch_log_sigmoid_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_sigmoid_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_softmax
torch_log_softmax <- function(self, dim, dtype = NULL) {
  args <- mget(x = c("self", "dim", "dtype"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_softmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log_softmax_out
torch_log_softmax_out <- function(out, self, dim, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", dtype = "ScalarType")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log_softmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log10
torch_log10 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log10',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log10_
torch_log10_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log10_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log10_out
torch_log10_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log10_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log1p
torch_log1p <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log1p',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log1p_
torch_log1p_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log1p_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log1p_out
torch_log1p_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log1p_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log2
torch_log2 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log2_
torch_log2_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log2_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_log2_out
torch_log2_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'log2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logaddexp
torch_logaddexp <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logaddexp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logaddexp_out
torch_logaddexp_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logaddexp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logaddexp2
torch_logaddexp2 <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logaddexp2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logaddexp2_out
torch_logaddexp2_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logaddexp2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logcumsumexp
torch_logcumsumexp <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"))
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logcumsumexp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logcumsumexp_out
torch_logcumsumexp_out <- function(out, self, dim) {
  args <- mget(x = c("out", "self", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("int64_t", "Dimname"
))
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logcumsumexp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logdet
torch_logdet <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logdet',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logical_and
torch_logical_and <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logical_and',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logical_and_out
torch_logical_and_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logical_and_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_logical_not
.torch_logical_not <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logical_not',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logical_not_out
torch_logical_not_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logical_not_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logical_or
torch_logical_or <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logical_or',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logical_or_out
torch_logical_or_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logical_or_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logical_xor
torch_logical_xor <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logical_xor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logical_xor_out
torch_logical_xor_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logical_xor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logit
torch_logit <- function(self, eps = NULL) {
  args <- mget(x = c("self", "eps"))
expected_types <- list(self = "Tensor", eps = "double")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logit',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logit_
torch_logit_ <- function(self, eps = NULL) {
  args <- mget(x = c("self", "eps"))
expected_types <- list(self = "Tensor", eps = "double")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logit_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logit_backward
torch_logit_backward <- function(grad_output, self, eps = NULL) {
  args <- mget(x = c("grad_output", "self", "eps"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", eps = "double")
nd_args <- c("grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logit_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logit_backward_out
torch_logit_backward_out <- function(grad_input, grad_output, self, eps = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "self", "eps"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    eps = "double")
nd_args <- c("grad_input", "grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logit_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logit_out
torch_logit_out <- function(out, self, eps = NULL) {
  args <- mget(x = c("out", "self", "eps"))
expected_types <- list(out = "Tensor", self = "Tensor", eps = "double")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logit_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_logspace
.torch_logspace <- function(start, end, steps, base = 10, options = list()) {
  args <- mget(x = c("start", "end", "steps", "base", "options"))
expected_types <- list(start = "Scalar", end = "Scalar", steps = "int64_t", base = "double", 
    options = "TensorOptions")
nd_args <- c("start", "end", "steps")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logspace',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logspace_out
torch_logspace_out <- function(out, start, end, steps, base = 10) {
  args <- mget(x = c("out", "start", "end", "steps", "base"))
expected_types <- list(out = "Tensor", start = "Scalar", end = "Scalar", steps = "int64_t", 
    base = "double")
nd_args <- c("out", "start", "end", "steps")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logspace_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logsumexp
torch_logsumexp <- function(self, dim, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("IntArrayRef", "DimnameList"), 
    keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logsumexp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_logsumexp_out
torch_logsumexp_out <- function(out, self, dim, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("IntArrayRef", 
"DimnameList"), keepdim = "bool")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'logsumexp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lstm
torch_lstm <- function(data, input, batch_sizes, hx, params, has_biases, num_layers, dropout, train, batch_first, bidirectional) {
  args <- mget(x = c("data", "input", "batch_sizes", "hx", "params", "has_biases", "num_layers", "dropout", "train", "batch_first", "bidirectional"))
expected_types <- list(data = "Tensor", input = "Tensor", batch_sizes = "Tensor", 
    hx = "TensorList", params = "TensorList", has_biases = "bool", 
    num_layers = "int64_t", dropout = "double", train = "bool", 
    batch_first = "bool", bidirectional = "bool")
nd_args <- c("data", "input", "batch_sizes", "hx", "params", "has_biases", 
"num_layers", "dropout", "train", "batch_first", "bidirectional"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'lstm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lstm_cell
torch_lstm_cell <- function(input, hx, w_ih, w_hh, b_ih = list(), b_hh = list()) {
  args <- mget(x = c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh"))
expected_types <- list(input = "Tensor", hx = "TensorList", w_ih = "Tensor", w_hh = "Tensor", 
    b_ih = "Tensor", b_hh = "Tensor")
nd_args <- c("input", "hx", "w_ih", "w_hh")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'lstm_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lstm_mps_backward
torch_lstm_mps_backward <- function(grad_y, grad_hy, grad_cy, z_state, cell_state_fwd, input, layersOutputs, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first) {
  args <- mget(x = c("grad_y", "grad_hy", "grad_cy", "z_state", "cell_state_fwd", "input", "layersOutputs", "hx", "params", "has_biases", "num_layers", "dropout", "train", "bidirectional", "batch_first"))
expected_types <- list(grad_y = "Tensor", grad_hy = "Tensor", grad_cy = "Tensor", 
    z_state = "Tensor", cell_state_fwd = "Tensor", input = "Tensor", 
    layersOutputs = "Tensor", hx = "TensorList", params = "TensorList", 
    has_biases = "bool", num_layers = "int64_t", dropout = "double", 
    train = "bool", bidirectional = "bool", batch_first = "bool")
nd_args <- c("grad_y", "grad_hy", "grad_cy", "z_state", "cell_state_fwd", 
"input", "layersOutputs", "hx", "params", "has_biases", "num_layers", 
"dropout", "train", "bidirectional", "batch_first")
return_types <- list(list("Tensor", "TensorList", "TensorList"))
call_c_function(
fun_name = 'lstm_mps_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lstm_mps_backward_out
torch_lstm_mps_backward_out <- function(out0, out1, out2, grad_y, grad_hy, grad_cy, z_state, cell_state_fwd, input, layersOutputs, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first) {
  args <- mget(x = c("out0", "out1", "out2", "grad_y", "grad_hy", "grad_cy", "z_state", "cell_state_fwd", "input", "layersOutputs", "hx", "params", "has_biases", "num_layers", "dropout", "train", "bidirectional", "batch_first"))
expected_types <- list(out0 = "Tensor", out1 = "TensorList", out2 = "TensorList", 
    grad_y = "Tensor", grad_hy = "Tensor", grad_cy = "Tensor", 
    z_state = "Tensor", cell_state_fwd = "Tensor", input = "Tensor", 
    layersOutputs = "Tensor", hx = "TensorList", params = "TensorList", 
    has_biases = "bool", num_layers = "int64_t", dropout = "double", 
    train = "bool", bidirectional = "bool", batch_first = "bool")
nd_args <- c("out0", "out1", "out2", "grad_y", "grad_hy", "grad_cy", "z_state", 
"cell_state_fwd", "input", "layersOutputs", "hx", "params", "has_biases", 
"num_layers", "dropout", "train", "bidirectional", "batch_first"
)
return_types <- list(list("void"))
call_c_function(
fun_name = 'lstm_mps_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lt
torch_lt <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lt',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lt_out
torch_lt_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lt_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lu_solve
torch_lu_solve <- function(self, LU_data, LU_pivots) {
  args <- mget(x = c("self", "LU_data", "LU_pivots"))
expected_types <- list(self = "Tensor", LU_data = "Tensor", LU_pivots = "Tensor")
nd_args <- c("self", "LU_data", "LU_pivots")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lu_solve',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lu_solve_out
torch_lu_solve_out <- function(out, self, LU_data, LU_pivots) {
  args <- mget(x = c("out", "self", "LU_data", "LU_pivots"))
expected_types <- list(out = "Tensor", self = "Tensor", LU_data = "Tensor", LU_pivots = "Tensor")
nd_args <- c("out", "self", "LU_data", "LU_pivots")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'lu_solve_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lu_unpack
torch_lu_unpack <- function(LU_data, LU_pivots, unpack_data = TRUE, unpack_pivots = TRUE) {
  args <- mget(x = c("LU_data", "LU_pivots", "unpack_data", "unpack_pivots"))
expected_types <- list(LU_data = "Tensor", LU_pivots = "Tensor", unpack_data = "bool", 
    unpack_pivots = "bool")
nd_args <- c("LU_data", "LU_pivots")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'lu_unpack',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_lu_unpack_out
torch_lu_unpack_out <- function(P, L, U, LU_data, LU_pivots, unpack_data = TRUE, unpack_pivots = TRUE) {
  args <- mget(x = c("P", "L", "U", "LU_data", "LU_pivots", "unpack_data", "unpack_pivots"))
expected_types <- list(P = "Tensor", L = "Tensor", U = "Tensor", LU_data = "Tensor", 
    LU_pivots = "Tensor", unpack_data = "bool", unpack_pivots = "bool")
nd_args <- c("P", "L", "U", "LU_data", "LU_pivots")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'lu_unpack_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_margin_ranking_loss
torch_margin_ranking_loss <- function(input1, input2, target, margin = 0L, reduction = torch_reduction_mean()) {
  args <- mget(x = c("input1", "input2", "target", "margin", "reduction"))
expected_types <- list(input1 = "Tensor", input2 = "Tensor", target = "Tensor", 
    margin = "double", reduction = "int64_t")
nd_args <- c("input1", "input2", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'margin_ranking_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_masked_fill
torch_masked_fill <- function(self, mask, value) {
  args <- mget(x = c("self", "mask", "value"))
expected_types <- list(self = "Tensor", mask = "Tensor", value = c("Scalar", "Tensor"
))
nd_args <- c("self", "mask", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'masked_fill',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_masked_fill_out
torch_masked_fill_out <- function(out, self, mask, value) {
  args <- mget(x = c("out", "self", "mask", "value"))
expected_types <- list(out = "Tensor", self = "Tensor", mask = "Tensor", value = c("Scalar", 
"Tensor"))
nd_args <- c("out", "self", "mask", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'masked_fill_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_masked_scatter
torch_masked_scatter <- function(self, mask, source) {
  args <- mget(x = c("self", "mask", "source"))
expected_types <- list(self = "Tensor", mask = "Tensor", source = "Tensor")
nd_args <- c("self", "mask", "source")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'masked_scatter',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_masked_scatter_out
torch_masked_scatter_out <- function(out, self, mask, source) {
  args <- mget(x = c("out", "self", "mask", "source"))
expected_types <- list(out = "Tensor", self = "Tensor", mask = "Tensor", source = "Tensor")
nd_args <- c("out", "self", "mask", "source")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'masked_scatter_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_masked_select
torch_masked_select <- function(self, mask) {
  args <- mget(x = c("self", "mask"))
expected_types <- list(self = "Tensor", mask = "Tensor")
nd_args <- c("self", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'masked_select',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_masked_select_backward
torch_masked_select_backward <- function(grad, input, mask) {
  args <- mget(x = c("grad", "input", "mask"))
expected_types <- list(grad = "Tensor", input = "Tensor", mask = "Tensor")
nd_args <- c("grad", "input", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'masked_select_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_masked_select_out
torch_masked_select_out <- function(out, self, mask) {
  args <- mget(x = c("out", "self", "mask"))
expected_types <- list(out = "Tensor", self = "Tensor", mask = "Tensor")
nd_args <- c("out", "self", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'masked_select_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_matmul
torch_matmul <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'matmul',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_matmul_backward
torch_matmul_backward <- function(grad, self, other, mask) {
  args <- mget(x = c("grad", "self", "other", "mask"))
expected_types <- list(grad = "Tensor", self = "Tensor", other = "Tensor", mask = "::std::array<bool,2>")
nd_args <- c("grad", "self", "other", "mask")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'matmul_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_matmul_backward_out
torch_matmul_backward_out <- function(out0, out1, grad, self, other, mask) {
  args <- mget(x = c("out0", "out1", "grad", "self", "other", "mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", grad = "Tensor", self = "Tensor", 
    other = "Tensor", mask = "::std::array<bool,2>")
nd_args <- c("out0", "out1", "grad", "self", "other", "mask")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'matmul_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_matmul_out
torch_matmul_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'matmul_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_matrix_exp
torch_matrix_exp <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'matrix_exp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_matrix_exp_backward
torch_matrix_exp_backward <- function(self, grad) {
  args <- mget(x = c("self", "grad"))
expected_types <- list(self = "Tensor", grad = "Tensor")
nd_args <- c("self", "grad")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'matrix_exp_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_matrix_power
torch_matrix_power <- function(self, n) {
  args <- mget(x = c("self", "n"))
expected_types <- list(self = "Tensor", n = "int64_t")
nd_args <- c("self", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'matrix_power',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_matrix_power_out
torch_matrix_power_out <- function(out, self, n) {
  args <- mget(x = c("out", "self", "n"))
expected_types <- list(out = "Tensor", self = "Tensor", n = "int64_t")
nd_args <- c("out", "self", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'matrix_power_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_max
.torch_max <- function(self, dim, other, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "other", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), other = "Tensor", 
    keepdim = "bool")
nd_args <- c("self", "dim", "other")
return_types <- list(list("Tensor", "Tensor"), list('Tensor'))
call_c_function(
fun_name = 'max',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_max_out
.torch_max_out <- function(max, out, max_values, other, self, dim, keepdim = FALSE) {
  args <- mget(x = c("max", "out", "max_values", "other", "self", "dim", "keepdim"))
expected_types <- list(max = "Tensor", out = "Tensor", max_values = "Tensor", other = "Tensor", 
    self = "Tensor", dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("max", "out", "max_values", "other", "self", "dim")
return_types <- list(list("Tensor", "Tensor"), list('Tensor'))
call_c_function(
fun_name = 'max_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_pool1d
torch_max_pool1d <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_pool1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_max_pool1d_with_indices
.torch_max_pool1d_with_indices <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'max_pool1d_with_indices',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_pool2d
torch_max_pool2d <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_pool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_pool2d_backward
torch_max_pool2d_backward <- function(grad_output, self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("grad_output", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    ceil_mode = "bool")
nd_args <- c("grad_output", "self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_pool2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_pool2d_backward_out
torch_max_pool2d_backward_out <- function(out, grad_output, self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("out", "grad_output", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", self = "Tensor", 
    kernel_size = "IntArrayRef", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("out", "grad_output", "self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_pool2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_max_pool2d_with_indices
.torch_max_pool2d_with_indices <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'max_pool2d_with_indices',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_pool2d_with_indices_backward
torch_max_pool2d_with_indices_backward <- function(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices) {
  args <- mget(x = c("grad_output", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode", "indices"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    ceil_mode = "bool", indices = "Tensor")
nd_args <- c("grad_output", "self", "kernel_size", "stride", "padding", 
"dilation", "ceil_mode", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_pool2d_with_indices_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_pool2d_with_indices_backward_out
torch_max_pool2d_with_indices_backward_out <- function(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices) {
  args <- mget(x = c("grad_input", "grad_output", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode", "indices"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    kernel_size = "IntArrayRef", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef", ceil_mode = "bool", indices = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "kernel_size", "stride", 
"padding", "dilation", "ceil_mode", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_pool2d_with_indices_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_max_pool2d_with_indices_out
.torch_max_pool2d_with_indices_out <- function(out, indices, self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("out", "indices", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(out = "Tensor", indices = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    ceil_mode = "bool")
nd_args <- c("out", "indices", "self", "kernel_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'max_pool2d_with_indices_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_pool3d
torch_max_pool3d <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_pool3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_max_pool3d_with_indices
.torch_max_pool3d_with_indices <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'max_pool3d_with_indices',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_pool3d_with_indices_backward
torch_max_pool3d_with_indices_backward <- function(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices) {
  args <- mget(x = c("grad_output", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode", "indices"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    ceil_mode = "bool", indices = "Tensor")
nd_args <- c("grad_output", "self", "kernel_size", "stride", "padding", 
"dilation", "ceil_mode", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_pool3d_with_indices_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_pool3d_with_indices_backward_out
torch_max_pool3d_with_indices_backward_out <- function(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices) {
  args <- mget(x = c("grad_input", "grad_output", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode", "indices"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    kernel_size = "IntArrayRef", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef", ceil_mode = "bool", indices = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "kernel_size", "stride", 
"padding", "dilation", "ceil_mode", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_pool3d_with_indices_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_max_pool3d_with_indices_out
.torch_max_pool3d_with_indices_out <- function(out, indices, self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("out", "indices", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(out = "Tensor", indices = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    ceil_mode = "bool")
nd_args <- c("out", "indices", "self", "kernel_size")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'max_pool3d_with_indices_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_unpool2d
torch_max_unpool2d <- function(self, indices, output_size) {
  args <- mget(x = c("self", "indices", "output_size"))
expected_types <- list(self = "Tensor", indices = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "indices", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_unpool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_unpool2d_out
torch_max_unpool2d_out <- function(out, self, indices, output_size) {
  args <- mget(x = c("out", "self", "indices", "output_size"))
expected_types <- list(out = "Tensor", self = "Tensor", indices = "Tensor", output_size = "IntArrayRef")
nd_args <- c("out", "self", "indices", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_unpool2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_unpool3d
torch_max_unpool3d <- function(self, indices, output_size, stride, padding) {
  args <- mget(x = c("self", "indices", "output_size", "stride", "padding"))
expected_types <- list(self = "Tensor", indices = "Tensor", output_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("self", "indices", "output_size", "stride", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_unpool3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_max_unpool3d_out
torch_max_unpool3d_out <- function(out, self, indices, output_size, stride, padding) {
  args <- mget(x = c("out", "self", "indices", "output_size", "stride", "padding"))
expected_types <- list(out = "Tensor", self = "Tensor", indices = "Tensor", output_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("out", "self", "indices", "output_size", "stride", "padding"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'max_unpool3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_maximum
torch_maximum <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'maximum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_maximum_out
torch_maximum_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'maximum_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mean
torch_mean <- function(self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", dim = c("IntArrayRef", "DimnameList"), 
    keepdim = "bool", dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mean',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mean_out
torch_mean_out <- function(out, self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("IntArrayRef", 
"DimnameList"), keepdim = "bool", dtype = "ScalarType")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mean_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_median
torch_median <- function(self, dim, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'), list("Tensor", "Tensor"))
call_c_function(
fun_name = 'median',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_median_out
torch_median_out <- function(out, values, indices, self, dim, keepdim = FALSE) {
  args <- mget(x = c("out", "values", "indices", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", values = "Tensor", indices = "Tensor", self = "Tensor", 
    dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("out", "values", "indices", "self", "dim")
return_types <- list(list("Tensor", "Tensor"), list('Tensor'))
call_c_function(
fun_name = 'median_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_meshgrid
torch_meshgrid <- function(tensors, indexing) {
  args <- mget(x = c("tensors", "indexing"))
expected_types <- list(tensors = "TensorList", indexing = "c10::string_view")
nd_args <- c("tensors", "indexing")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'meshgrid',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_min
.torch_min <- function(self, dim, other, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "other", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), other = "Tensor", 
    keepdim = "bool")
nd_args <- c("self", "dim", "other")
return_types <- list(list("Tensor", "Tensor"), list('Tensor'))
call_c_function(
fun_name = 'min',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_min_out
.torch_min_out <- function(min, out, min_indices, other, self, dim, keepdim = FALSE) {
  args <- mget(x = c("min", "out", "min_indices", "other", "self", "dim", "keepdim"))
expected_types <- list(min = "Tensor", out = "Tensor", min_indices = "Tensor", 
    other = "Tensor", self = "Tensor", dim = c("int64_t", "Dimname"
    ), keepdim = "bool")
nd_args <- c("min", "out", "min_indices", "other", "self", "dim")
return_types <- list(list("Tensor", "Tensor"), list('Tensor'))
call_c_function(
fun_name = 'min_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_minimum
torch_minimum <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'minimum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_minimum_out
torch_minimum_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'minimum_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_batch_norm
torch_miopen_batch_norm <- function(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon) {
  args <- mget(x = c("input", "weight", "bias", "running_mean", "running_var", "training", "exponential_average_factor", "epsilon"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", exponential_average_factor = "double", 
    epsilon = "double")
nd_args <- c("input", "weight", "bias", "running_mean", "running_var", "training", 
"exponential_average_factor", "epsilon")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'miopen_batch_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_batch_norm_backward
torch_miopen_batch_norm_backward <- function(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon) {
  args <- mget(x = c("input", "grad_output", "weight", "running_mean", "running_var", "save_mean", "save_var", "epsilon"))
expected_types <- list(input = "Tensor", grad_output = "Tensor", weight = "Tensor", 
    running_mean = "Tensor", running_var = "Tensor", save_mean = "Tensor", 
    save_var = "Tensor", epsilon = "double")
nd_args <- c("input", "grad_output", "weight", "running_mean", "running_var", 
"save_mean", "save_var", "epsilon")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'miopen_batch_norm_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_batch_norm_backward_out
torch_miopen_batch_norm_backward_out <- function(out0, out1, out2, input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon) {
  args <- mget(x = c("out0", "out1", "out2", "input", "grad_output", "weight", "running_mean", "running_var", "save_mean", "save_var", "epsilon"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", input = "Tensor", 
    grad_output = "Tensor", weight = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", save_mean = "Tensor", save_var = "Tensor", 
    epsilon = "double")
nd_args <- c("out0", "out1", "out2", "input", "grad_output", "weight", "running_mean", 
"running_var", "save_mean", "save_var", "epsilon")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'miopen_batch_norm_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_batch_norm_out
torch_miopen_batch_norm_out <- function(out0, out1, out2, input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon) {
  args <- mget(x = c("out0", "out1", "out2", "input", "weight", "bias", "running_mean", "running_var", "training", "exponential_average_factor", "epsilon"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", input = "Tensor", 
    weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", exponential_average_factor = "double", 
    epsilon = "double")
nd_args <- c("out0", "out1", "out2", "input", "weight", "bias", "running_mean", 
"running_var", "training", "exponential_average_factor", "epsilon"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'miopen_batch_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_convolution
torch_miopen_convolution <- function(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic) {
  args <- mget(x = c("self", "weight", "bias", "padding", "stride", "dilation", "groups", "benchmark", "deterministic"))
expected_types <- list(self = "Tensor", weight = "Tensor", bias = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t", 
    benchmark = "bool", deterministic = "bool")
nd_args <- c("self", "weight", "bias", "padding", "stride", "dilation", 
"groups", "benchmark", "deterministic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'miopen_convolution',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_convolution_add_relu
torch_miopen_convolution_add_relu <- function(self, weight, z, alpha, bias, stride, padding, dilation, groups) {
  args <- mget(x = c("self", "weight", "z", "alpha", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(self = "Tensor", weight = "Tensor", z = "Tensor", alpha = "Scalar", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef", groups = "int64_t")
nd_args <- c("self", "weight", "z", "alpha", "bias", "stride", "padding", 
"dilation", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'miopen_convolution_add_relu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_convolution_out
torch_miopen_convolution_out <- function(out, self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic) {
  args <- mget(x = c("out", "self", "weight", "bias", "padding", "stride", "dilation", "groups", "benchmark", "deterministic"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", bias = "Tensor", 
    padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t", benchmark = "bool", deterministic = "bool")
nd_args <- c("out", "self", "weight", "bias", "padding", "stride", "dilation", 
"groups", "benchmark", "deterministic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'miopen_convolution_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_convolution_relu
torch_miopen_convolution_relu <- function(self, weight, bias, stride, padding, dilation, groups) {
  args <- mget(x = c("self", "weight", "bias", "stride", "padding", "dilation", "groups"))
expected_types <- list(self = "Tensor", weight = "Tensor", bias = "Tensor", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t")
nd_args <- c("self", "weight", "bias", "stride", "padding", "dilation", 
"groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'miopen_convolution_relu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_convolution_transpose
torch_miopen_convolution_transpose <- function(self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic) {
  args <- mget(x = c("self", "weight", "bias", "padding", "output_padding", "stride", "dilation", "groups", "benchmark", "deterministic"))
expected_types <- list(self = "Tensor", weight = "Tensor", bias = "Tensor", padding = "IntArrayRef", 
    output_padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t", benchmark = "bool", deterministic = "bool")
nd_args <- c("self", "weight", "bias", "padding", "output_padding", "stride", 
"dilation", "groups", "benchmark", "deterministic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'miopen_convolution_transpose',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_convolution_transpose_out
torch_miopen_convolution_transpose_out <- function(out, self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic) {
  args <- mget(x = c("out", "self", "weight", "bias", "padding", "output_padding", "stride", "dilation", "groups", "benchmark", "deterministic"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", bias = "Tensor", 
    padding = "IntArrayRef", output_padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t", 
    benchmark = "bool", deterministic = "bool")
nd_args <- c("out", "self", "weight", "bias", "padding", "output_padding", 
"stride", "dilation", "groups", "benchmark", "deterministic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'miopen_convolution_transpose_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_depthwise_convolution
torch_miopen_depthwise_convolution <- function(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic) {
  args <- mget(x = c("self", "weight", "bias", "padding", "stride", "dilation", "groups", "benchmark", "deterministic"))
expected_types <- list(self = "Tensor", weight = "Tensor", bias = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t", 
    benchmark = "bool", deterministic = "bool")
nd_args <- c("self", "weight", "bias", "padding", "stride", "dilation", 
"groups", "benchmark", "deterministic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'miopen_depthwise_convolution',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_depthwise_convolution_out
torch_miopen_depthwise_convolution_out <- function(out, self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic) {
  args <- mget(x = c("out", "self", "weight", "bias", "padding", "stride", "dilation", "groups", "benchmark", "deterministic"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", bias = "Tensor", 
    padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t", benchmark = "bool", deterministic = "bool")
nd_args <- c("out", "self", "weight", "bias", "padding", "stride", "dilation", 
"groups", "benchmark", "deterministic")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'miopen_depthwise_convolution_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_rnn
torch_miopen_rnn <- function(input, weight, weight_stride0, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state) {
  args <- mget(x = c("input", "weight", "weight_stride0", "hx", "cx", "mode", "hidden_size", "num_layers", "batch_first", "dropout", "train", "bidirectional", "batch_sizes", "dropout_state"))
expected_types <- list(input = "Tensor", weight = "TensorList", weight_stride0 = "int64_t", 
    hx = "Tensor", cx = "Tensor", mode = "int64_t", hidden_size = "int64_t", 
    num_layers = "int64_t", batch_first = "bool", dropout = "double", 
    train = "bool", bidirectional = "bool", batch_sizes = "IntArrayRef", 
    dropout_state = "Tensor")
nd_args <- c("input", "weight", "weight_stride0", "hx", "cx", "mode", "hidden_size", 
"num_layers", "batch_first", "dropout", "train", "bidirectional", 
"batch_sizes", "dropout_state")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'miopen_rnn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_rnn_backward
torch_miopen_rnn_backward <- function(input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, reserve, output_mask) {
  args <- mget(x = c("input", "weight", "weight_stride0", "weight_buf", "hx", "cx", "output", "grad_output", "grad_hy", "grad_cy", "mode", "hidden_size", "num_layers", "batch_first", "dropout", "train", "bidirectional", "batch_sizes", "dropout_state", "reserve", "output_mask"))
expected_types <- list(input = "Tensor", weight = "TensorList", weight_stride0 = "int64_t", 
    weight_buf = "Tensor", hx = "Tensor", cx = "Tensor", output = "Tensor", 
    grad_output = "Tensor", grad_hy = "Tensor", grad_cy = "Tensor", 
    mode = "int64_t", hidden_size = "int64_t", num_layers = "int64_t", 
    batch_first = "bool", dropout = "double", train = "bool", 
    bidirectional = "bool", batch_sizes = "IntArrayRef", dropout_state = "Tensor", 
    reserve = "Tensor", output_mask = "::std::array<bool,4>")
nd_args <- c("input", "weight", "weight_stride0", "weight_buf", "hx", "cx", 
"output", "grad_output", "grad_hy", "grad_cy", "mode", "hidden_size", 
"num_layers", "batch_first", "dropout", "train", "bidirectional", 
"batch_sizes", "dropout_state", "reserve", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor", "TensorList"))
call_c_function(
fun_name = 'miopen_rnn_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_rnn_backward_out
torch_miopen_rnn_backward_out <- function(out0, out1, out2, out3, input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, reserve, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "input", "weight", "weight_stride0", "weight_buf", "hx", "cx", "output", "grad_output", "grad_hy", "grad_cy", "mode", "hidden_size", "num_layers", "batch_first", "dropout", "train", "bidirectional", "batch_sizes", "dropout_state", "reserve", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "TensorList", 
    input = "Tensor", weight = "TensorList", weight_stride0 = "int64_t", 
    weight_buf = "Tensor", hx = "Tensor", cx = "Tensor", output = "Tensor", 
    grad_output = "Tensor", grad_hy = "Tensor", grad_cy = "Tensor", 
    mode = "int64_t", hidden_size = "int64_t", num_layers = "int64_t", 
    batch_first = "bool", dropout = "double", train = "bool", 
    bidirectional = "bool", batch_sizes = "IntArrayRef", dropout_state = "Tensor", 
    reserve = "Tensor", output_mask = "::std::array<bool,4>")
nd_args <- c("out0", "out1", "out2", "out3", "input", "weight", "weight_stride0", 
"weight_buf", "hx", "cx", "output", "grad_output", "grad_hy", 
"grad_cy", "mode", "hidden_size", "num_layers", "batch_first", 
"dropout", "train", "bidirectional", "batch_sizes", "dropout_state", 
"reserve", "output_mask")
return_types <- list(list("void"))
call_c_function(
fun_name = 'miopen_rnn_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_miopen_rnn_out
torch_miopen_rnn_out <- function(out0, out1, out2, out3, out4, input, weight, weight_stride0, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "out4", "input", "weight", "weight_stride0", "hx", "cx", "mode", "hidden_size", "num_layers", "batch_first", "dropout", "train", "bidirectional", "batch_sizes", "dropout_state"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    out4 = "Tensor", input = "Tensor", weight = "TensorList", 
    weight_stride0 = "int64_t", hx = "Tensor", cx = "Tensor", 
    mode = "int64_t", hidden_size = "int64_t", num_layers = "int64_t", 
    batch_first = "bool", dropout = "double", train = "bool", 
    bidirectional = "bool", batch_sizes = "IntArrayRef", dropout_state = "Tensor")
nd_args <- c("out0", "out1", "out2", "out3", "out4", "input", "weight", 
"weight_stride0", "hx", "cx", "mode", "hidden_size", "num_layers", 
"batch_first", "dropout", "train", "bidirectional", "batch_sizes", 
"dropout_state")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'miopen_rnn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mish
torch_mish <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mish',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mish_
torch_mish_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mish_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mish_backward
torch_mish_backward <- function(grad_output, self) {
  args <- mget(x = c("grad_output", "self"))
expected_types <- list(grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mish_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mish_out
torch_mish_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mish_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_adaptive_avg_pool2d
torch_mkldnn_adaptive_avg_pool2d <- function(self, output_size) {
  args <- mget(x = c("self", "output_size"))
expected_types <- list(self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_adaptive_avg_pool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_adaptive_avg_pool2d_backward
torch_mkldnn_adaptive_avg_pool2d_backward <- function(grad_output, self) {
  args <- mget(x = c("grad_output", "self"))
expected_types <- list(grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_adaptive_avg_pool2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_adaptive_avg_pool2d_backward_out
torch_mkldnn_adaptive_avg_pool2d_backward_out <- function(out, grad_output, self) {
  args <- mget(x = c("out", "grad_output", "self"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", self = "Tensor")
nd_args <- c("out", "grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_adaptive_avg_pool2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_adaptive_avg_pool2d_out
torch_mkldnn_adaptive_avg_pool2d_out <- function(out, self, output_size) {
  args <- mget(x = c("out", "self", "output_size"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_adaptive_avg_pool2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_convolution
torch_mkldnn_convolution <- function(self, weight, bias, padding, stride, dilation, groups) {
  args <- mget(x = c("self", "weight", "bias", "padding", "stride", "dilation", "groups"))
expected_types <- list(self = "Tensor", weight = "Tensor", bias = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t")
nd_args <- c("self", "weight", "bias", "padding", "stride", "dilation", 
"groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_convolution',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_convolution_out
torch_mkldnn_convolution_out <- function(out, self, weight, bias, padding, stride, dilation, groups) {
  args <- mget(x = c("out", "self", "weight", "bias", "padding", "stride", "dilation", "groups"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", bias = "Tensor", 
    padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t")
nd_args <- c("out", "self", "weight", "bias", "padding", "stride", "dilation", 
"groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_convolution_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_linear
torch_mkldnn_linear <- function(self, weight, bias = list()) {
  args <- mget(x = c("self", "weight", "bias"))
expected_types <- list(self = "Tensor", weight = "Tensor", bias = "Tensor")
nd_args <- c("self", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_linear',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_linear_backward
torch_mkldnn_linear_backward <- function(self, grad_output, weight, output_mask) {
  args <- mget(x = c("self", "grad_output", "weight", "output_mask"))
expected_types <- list(self = "Tensor", grad_output = "Tensor", weight = "Tensor", 
    output_mask = "::std::array<bool,3>")
nd_args <- c("self", "grad_output", "weight", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'mkldnn_linear_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_linear_backward_input
torch_mkldnn_linear_backward_input <- function(input_size, grad_output, weight) {
  args <- mget(x = c("input_size", "grad_output", "weight"))
expected_types <- list(input_size = "IntArrayRef", grad_output = "Tensor", weight = "Tensor")
nd_args <- c("input_size", "grad_output", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_linear_backward_input',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_linear_backward_input_out
torch_mkldnn_linear_backward_input_out <- function(out, input_size, grad_output, weight) {
  args <- mget(x = c("out", "input_size", "grad_output", "weight"))
expected_types <- list(out = "Tensor", input_size = "IntArrayRef", grad_output = "Tensor", 
    weight = "Tensor")
nd_args <- c("out", "input_size", "grad_output", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_linear_backward_input_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_linear_backward_out
torch_mkldnn_linear_backward_out <- function(out0, out1, out2, self, grad_output, weight, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "self", "grad_output", "weight", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", self = "Tensor", 
    grad_output = "Tensor", weight = "Tensor", output_mask = "::std::array<bool,3>")
nd_args <- c("out0", "out1", "out2", "self", "grad_output", "weight", "output_mask"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'mkldnn_linear_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_linear_backward_weights
torch_mkldnn_linear_backward_weights <- function(grad_output, input, weight, bias_defined) {
  args <- mget(x = c("grad_output", "input", "weight", "bias_defined"))
expected_types <- list(grad_output = "Tensor", input = "Tensor", weight = "Tensor", 
    bias_defined = "bool")
nd_args <- c("grad_output", "input", "weight", "bias_defined")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'mkldnn_linear_backward_weights',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_linear_backward_weights_out
torch_mkldnn_linear_backward_weights_out <- function(out0, out1, grad_output, input, weight, bias_defined) {
  args <- mget(x = c("out0", "out1", "grad_output", "input", "weight", "bias_defined"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", grad_output = "Tensor", 
    input = "Tensor", weight = "Tensor", bias_defined = "bool")
nd_args <- c("out0", "out1", "grad_output", "input", "weight", "bias_defined"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'mkldnn_linear_backward_weights_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_linear_out
torch_mkldnn_linear_out <- function(out, self, weight, bias = list()) {
  args <- mget(x = c("out", "self", "weight", "bias"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", bias = "Tensor")
nd_args <- c("out", "self", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_linear_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_max_pool2d
torch_mkldnn_max_pool2d <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_max_pool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_max_pool2d_backward
torch_mkldnn_max_pool2d_backward <- function(grad_output, output, input, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("grad_output", "output", "input", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(grad_output = "Tensor", output = "Tensor", input = "Tensor", 
    kernel_size = "IntArrayRef", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("grad_output", "output", "input", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_max_pool2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_max_pool2d_backward_out
torch_mkldnn_max_pool2d_backward_out <- function(out, grad_output, output, input, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("out", "grad_output", "output", "input", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", output = "Tensor", 
    input = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("out", "grad_output", "output", "input", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_max_pool2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_max_pool2d_out
torch_mkldnn_max_pool2d_out <- function(out, self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("out", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(out = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    ceil_mode = "bool")
nd_args <- c("out", "self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_max_pool2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_max_pool3d
torch_mkldnn_max_pool3d <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_max_pool3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_max_pool3d_backward
torch_mkldnn_max_pool3d_backward <- function(grad_output, output, input, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("grad_output", "output", "input", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(grad_output = "Tensor", output = "Tensor", input = "Tensor", 
    kernel_size = "IntArrayRef", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("grad_output", "output", "input", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_max_pool3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_max_pool3d_backward_out
torch_mkldnn_max_pool3d_backward_out <- function(out, grad_output, output, input, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("out", "grad_output", "output", "input", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", output = "Tensor", 
    input = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("out", "grad_output", "output", "input", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_max_pool3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_max_pool3d_out
torch_mkldnn_max_pool3d_out <- function(out, self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("out", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(out = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    ceil_mode = "bool")
nd_args <- c("out", "self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_max_pool3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_reorder_conv2d_weight
torch_mkldnn_reorder_conv2d_weight <- function(self, padding = 0L, stride = 1L, dilation = 1L, groups = 1L, input_size = NULL) {
  args <- mget(x = c("self", "padding", "stride", "dilation", "groups", "input_size"))
expected_types <- list(self = "Tensor", padding = "IntArrayRef", stride = "IntArrayRef", 
    dilation = "IntArrayRef", groups = "int64_t", input_size = "IntArrayRef")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_reorder_conv2d_weight',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_reorder_conv2d_weight_out
torch_mkldnn_reorder_conv2d_weight_out <- function(out, self, padding = 0L, stride = 1L, dilation = 1L, groups = 1L, input_size = NULL) {
  args <- mget(x = c("out", "self", "padding", "stride", "dilation", "groups", "input_size"))
expected_types <- list(out = "Tensor", self = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t", 
    input_size = "IntArrayRef")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_reorder_conv2d_weight_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_reorder_conv3d_weight
torch_mkldnn_reorder_conv3d_weight <- function(self, padding = 0L, stride = 1L, dilation = 1L, groups = 1L) {
  args <- mget(x = c("self", "padding", "stride", "dilation", "groups"))
expected_types <- list(self = "Tensor", padding = "IntArrayRef", stride = "IntArrayRef", 
    dilation = "IntArrayRef", groups = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_reorder_conv3d_weight',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_reorder_conv3d_weight_out
torch_mkldnn_reorder_conv3d_weight_out <- function(out, self, padding = 0L, stride = 1L, dilation = 1L, groups = 1L) {
  args <- mget(x = c("out", "self", "padding", "stride", "dilation", "groups"))
expected_types <- list(out = "Tensor", self = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mkldnn_reorder_conv3d_weight_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_rnn_layer
torch_mkldnn_rnn_layer <- function(input, weight0, weight1, weight2, weight3, hx_, cx_, reverse, batch_sizes, mode, hidden_size, num_layers, has_biases, bidirectional, batch_first, train) {
  args <- mget(x = c("input", "weight0", "weight1", "weight2", "weight3", "hx_", "cx_", "reverse", "batch_sizes", "mode", "hidden_size", "num_layers", "has_biases", "bidirectional", "batch_first", "train"))
expected_types <- list(input = "Tensor", weight0 = "Tensor", weight1 = "Tensor", 
    weight2 = "Tensor", weight3 = "Tensor", hx_ = "Tensor", cx_ = "Tensor", 
    reverse = "bool", batch_sizes = "IntArrayRef", mode = "int64_t", 
    hidden_size = "int64_t", num_layers = "int64_t", has_biases = "bool", 
    bidirectional = "bool", batch_first = "bool", train = "bool")
nd_args <- c("input", "weight0", "weight1", "weight2", "weight3", "hx_", 
"cx_", "reverse", "batch_sizes", "mode", "hidden_size", "num_layers", 
"has_biases", "bidirectional", "batch_first", "train")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'mkldnn_rnn_layer',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_rnn_layer_backward
torch_mkldnn_rnn_layer_backward <- function(input, weight1, weight2, weight3, weight4, hx_, cx_tmp, output, hy_, cy_, grad_output, grad_hy, grad_cy, reverse, mode, hidden_size, num_layers, has_biases, train, bidirectional, batch_sizes, batch_first, workspace) {
  args <- mget(x = c("input", "weight1", "weight2", "weight3", "weight4", "hx_", "cx_tmp", "output", "hy_", "cy_", "grad_output", "grad_hy", "grad_cy", "reverse", "mode", "hidden_size", "num_layers", "has_biases", "train", "bidirectional", "batch_sizes", "batch_first", "workspace"))
expected_types <- list(input = "Tensor", weight1 = "Tensor", weight2 = "Tensor", 
    weight3 = "Tensor", weight4 = "Tensor", hx_ = "Tensor", cx_tmp = "Tensor", 
    output = "Tensor", hy_ = "Tensor", cy_ = "Tensor", grad_output = "Tensor", 
    grad_hy = "Tensor", grad_cy = "Tensor", reverse = "bool", 
    mode = "int64_t", hidden_size = "int64_t", num_layers = "int64_t", 
    has_biases = "bool", train = "bool", bidirectional = "bool", 
    batch_sizes = "IntArrayRef", batch_first = "bool", workspace = "Tensor")
nd_args <- c("input", "weight1", "weight2", "weight3", "weight4", "hx_", 
"cx_tmp", "output", "hy_", "cy_", "grad_output", "grad_hy", "grad_cy", 
"reverse", "mode", "hidden_size", "num_layers", "has_biases", 
"train", "bidirectional", "batch_sizes", "batch_first", "workspace"
)
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor", "Tensor",     "Tensor"))
call_c_function(
fun_name = 'mkldnn_rnn_layer_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_rnn_layer_backward_out
torch_mkldnn_rnn_layer_backward_out <- function(out0, out1, out2, out3, out4, out5, out6, input, weight1, weight2, weight3, weight4, hx_, cx_tmp, output, hy_, cy_, grad_output, grad_hy, grad_cy, reverse, mode, hidden_size, num_layers, has_biases, train, bidirectional, batch_sizes, batch_first, workspace) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "out4", "out5", "out6", "input", "weight1", "weight2", "weight3", "weight4", "hx_", "cx_tmp", "output", "hy_", "cy_", "grad_output", "grad_hy", "grad_cy", "reverse", "mode", "hidden_size", "num_layers", "has_biases", "train", "bidirectional", "batch_sizes", "batch_first", "workspace"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    out4 = "Tensor", out5 = "Tensor", out6 = "Tensor", input = "Tensor", 
    weight1 = "Tensor", weight2 = "Tensor", weight3 = "Tensor", 
    weight4 = "Tensor", hx_ = "Tensor", cx_tmp = "Tensor", output = "Tensor", 
    hy_ = "Tensor", cy_ = "Tensor", grad_output = "Tensor", grad_hy = "Tensor", 
    grad_cy = "Tensor", reverse = "bool", mode = "int64_t", hidden_size = "int64_t", 
    num_layers = "int64_t", has_biases = "bool", train = "bool", 
    bidirectional = "bool", batch_sizes = "IntArrayRef", batch_first = "bool", 
    workspace = "Tensor")
nd_args <- c("out0", "out1", "out2", "out3", "out4", "out5", "out6", "input", 
"weight1", "weight2", "weight3", "weight4", "hx_", "cx_tmp", 
"output", "hy_", "cy_", "grad_output", "grad_hy", "grad_cy", 
"reverse", "mode", "hidden_size", "num_layers", "has_biases", 
"train", "bidirectional", "batch_sizes", "batch_first", "workspace"
)
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor", "Tensor", "Tensor",     "Tensor"))
call_c_function(
fun_name = 'mkldnn_rnn_layer_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mkldnn_rnn_layer_out
torch_mkldnn_rnn_layer_out <- function(out0, out1, out2, out3, input, weight0, weight1, weight2, weight3, hx_, cx_, reverse, batch_sizes, mode, hidden_size, num_layers, has_biases, bidirectional, batch_first, train) {
  args <- mget(x = c("out0", "out1", "out2", "out3", "input", "weight0", "weight1", "weight2", "weight3", "hx_", "cx_", "reverse", "batch_sizes", "mode", "hidden_size", "num_layers", "has_biases", "bidirectional", "batch_first", "train"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", out3 = "Tensor", 
    input = "Tensor", weight0 = "Tensor", weight1 = "Tensor", 
    weight2 = "Tensor", weight3 = "Tensor", hx_ = "Tensor", cx_ = "Tensor", 
    reverse = "bool", batch_sizes = "IntArrayRef", mode = "int64_t", 
    hidden_size = "int64_t", num_layers = "int64_t", has_biases = "bool", 
    bidirectional = "bool", batch_first = "bool", train = "bool")
nd_args <- c("out0", "out1", "out2", "out3", "input", "weight0", "weight1", 
"weight2", "weight3", "hx_", "cx_", "reverse", "batch_sizes", 
"mode", "hidden_size", "num_layers", "has_biases", "bidirectional", 
"batch_first", "train")
return_types <- list(list("Tensor", "Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'mkldnn_rnn_layer_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mm
torch_mm <- function(self, mat2) {
  args <- mget(x = c("self", "mat2"))
expected_types <- list(self = "Tensor", mat2 = "Tensor")
nd_args <- c("self", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mm_out
torch_mm_out <- function(out, self, mat2) {
  args <- mget(x = c("out", "self", "mat2"))
expected_types <- list(out = "Tensor", self = "Tensor", mat2 = "Tensor")
nd_args <- c("out", "self", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mode
torch_mode <- function(self, dim = -1L, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'mode',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mode_out
torch_mode_out <- function(values, indices, self, dim = -1L, keepdim = FALSE) {
  args <- mget(x = c("values", "indices", "self", "dim", "keepdim"))
expected_types <- list(values = "Tensor", indices = "Tensor", self = "Tensor", 
    dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("values", "indices", "self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'mode_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_moveaxis
torch_moveaxis <- function(self, source, destination) {
  args <- mget(x = c("self", "source", "destination"))
expected_types <- list(self = "Tensor", source = c("IntArrayRef", "int64_t"), destination = c("IntArrayRef", 
"int64_t"))
nd_args <- c("self", "source", "destination")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'moveaxis',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_movedim
.torch_movedim <- function(self, source, destination) {
  args <- mget(x = c("self", "source", "destination"))
expected_types <- list(self = "Tensor", source = c("IntArrayRef", "int64_t"), destination = c("IntArrayRef", 
"int64_t"))
nd_args <- c("self", "source", "destination")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'movedim',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mps_convolution_backward
torch_mps_convolution_backward <- function(self, grad_output, weight, padding, stride, dilation, groups, output_mask) {
  args <- mget(x = c("self", "grad_output", "weight", "padding", "stride", "dilation", "groups", "output_mask"))
expected_types <- list(self = "Tensor", grad_output = "Tensor", weight = "Tensor", 
    padding = "IntArrayRef", stride = "IntArrayRef", dilation = "IntArrayRef", 
    groups = "int64_t", output_mask = "::std::array<bool,3>")
nd_args <- c("self", "grad_output", "weight", "padding", "stride", "dilation", 
"groups", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'mps_convolution_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mps_convolution_backward_out
torch_mps_convolution_backward_out <- function(out0, out1, out2, self, grad_output, weight, padding, stride, dilation, groups, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "self", "grad_output", "weight", "padding", "stride", "dilation", "groups", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", self = "Tensor", 
    grad_output = "Tensor", weight = "Tensor", padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t", 
    output_mask = "::std::array<bool,3>")
nd_args <- c("out0", "out1", "out2", "self", "grad_output", "weight", "padding", 
"stride", "dilation", "groups", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'mps_convolution_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mps_convolution_transpose_backward
torch_mps_convolution_transpose_backward <- function(self, grad_output, weight, padding, output_padding, stride, dilation, groups, output_mask) {
  args <- mget(x = c("self", "grad_output", "weight", "padding", "output_padding", "stride", "dilation", "groups", "output_mask"))
expected_types <- list(self = "Tensor", grad_output = "Tensor", weight = "Tensor", 
    padding = "IntArrayRef", output_padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t", 
    output_mask = "::std::array<bool,2>")
nd_args <- c("self", "grad_output", "weight", "padding", "output_padding", 
"stride", "dilation", "groups", "output_mask")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'mps_convolution_transpose_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mps_convolution_transpose_backward_out
torch_mps_convolution_transpose_backward_out <- function(out0, out1, self, grad_output, weight, padding, output_padding, stride, dilation, groups, output_mask) {
  args <- mget(x = c("out0", "out1", "self", "grad_output", "weight", "padding", "output_padding", "stride", "dilation", "groups", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", self = "Tensor", grad_output = "Tensor", 
    weight = "Tensor", padding = "IntArrayRef", output_padding = "IntArrayRef", 
    stride = "IntArrayRef", dilation = "IntArrayRef", groups = "int64_t", 
    output_mask = "::std::array<bool,2>")
nd_args <- c("out0", "out1", "self", "grad_output", "weight", "padding", 
"output_padding", "stride", "dilation", "groups", "output_mask"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'mps_convolution_transpose_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mse_loss
torch_mse_loss <- function(self, target, reduction = torch_reduction_mean()) {
  args <- mget(x = c("self", "target", "reduction"))
expected_types <- list(self = "Tensor", target = "Tensor", reduction = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mse_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mse_loss_backward
torch_mse_loss_backward <- function(grad_output, self, target, reduction) {
  args <- mget(x = c("grad_output", "self", "target", "reduction"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", target = "Tensor", 
    reduction = "int64_t")
nd_args <- c("grad_output", "self", "target", "reduction")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mse_loss_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mse_loss_backward_out
torch_mse_loss_backward_out <- function(grad_input, grad_output, self, target, reduction) {
  args <- mget(x = c("grad_input", "grad_output", "self", "target", "reduction"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    target = "Tensor", reduction = "int64_t")
nd_args <- c("grad_input", "grad_output", "self", "target", "reduction")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mse_loss_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mse_loss_out
torch_mse_loss_out <- function(out, self, target, reduction = torch_reduction_mean()) {
  args <- mget(x = c("out", "self", "target", "reduction"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", reduction = "int64_t")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mse_loss_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_msort
torch_msort <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'msort',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_msort_out
torch_msort_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'msort_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mul
torch_mul <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mul',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mul_out
torch_mul_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Tensor", "Scalar"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mul_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_multi_margin_loss
.torch_multi_margin_loss <- function(self, target, p = 1L, margin = 1L, weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("self", "target", "p", "margin", "weight", "reduction"))
expected_types <- list(self = "Tensor", target = "Tensor", p = "Scalar", margin = "Scalar", 
    weight = "Tensor", reduction = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multi_margin_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multi_margin_loss_backward
torch_multi_margin_loss_backward <- function(grad_output, self, target, p, margin, weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("grad_output", "self", "target", "p", "margin", "weight", "reduction"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", target = "Tensor", 
    p = "Scalar", margin = "Scalar", weight = "Tensor", reduction = "int64_t")
nd_args <- c("grad_output", "self", "target", "p", "margin")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multi_margin_loss_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multi_margin_loss_backward_out
torch_multi_margin_loss_backward_out <- function(grad_input, grad_output, self, target, p, margin, weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("grad_input", "grad_output", "self", "target", "p", "margin", "weight", "reduction"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    target = "Tensor", p = "Scalar", margin = "Scalar", weight = "Tensor", 
    reduction = "int64_t")
nd_args <- c("grad_input", "grad_output", "self", "target", "p", "margin"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multi_margin_loss_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multi_margin_loss_out
torch_multi_margin_loss_out <- function(out, self, target, p = 1L, margin = 1L, weight = list(), reduction = torch_reduction_mean()) {
  args <- mget(x = c("out", "self", "target", "p", "margin", "weight", "reduction"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", p = "Scalar", 
    margin = "Scalar", weight = "Tensor", reduction = "int64_t")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multi_margin_loss_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_multilabel_margin_loss
.torch_multilabel_margin_loss <- function(self, target, reduction = torch_reduction_mean()) {
  args <- mget(x = c("self", "target", "reduction"))
expected_types <- list(self = "Tensor", target = "Tensor", reduction = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multilabel_margin_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multilabel_margin_loss_backward
torch_multilabel_margin_loss_backward <- function(grad_output, self, target, reduction, is_target) {
  args <- mget(x = c("grad_output", "self", "target", "reduction", "is_target"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", target = "Tensor", 
    reduction = "int64_t", is_target = "Tensor")
nd_args <- c("grad_output", "self", "target", "reduction", "is_target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multilabel_margin_loss_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multilabel_margin_loss_backward_out
torch_multilabel_margin_loss_backward_out <- function(grad_input, grad_output, self, target, reduction, is_target) {
  args <- mget(x = c("grad_input", "grad_output", "self", "target", "reduction", "is_target"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    target = "Tensor", reduction = "int64_t", is_target = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "target", "reduction", 
"is_target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multilabel_margin_loss_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multilabel_margin_loss_forward
torch_multilabel_margin_loss_forward <- function(self, target, reduction) {
  args <- mget(x = c("self", "target", "reduction"))
expected_types <- list(self = "Tensor", target = "Tensor", reduction = "int64_t")
nd_args <- c("self", "target", "reduction")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'multilabel_margin_loss_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multilabel_margin_loss_forward_out
torch_multilabel_margin_loss_forward_out <- function(output, is_target, self, target, reduction) {
  args <- mget(x = c("output", "is_target", "self", "target", "reduction"))
expected_types <- list(output = "Tensor", is_target = "Tensor", self = "Tensor", 
    target = "Tensor", reduction = "int64_t")
nd_args <- c("output", "is_target", "self", "target", "reduction")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'multilabel_margin_loss_forward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multilabel_margin_loss_out
torch_multilabel_margin_loss_out <- function(out, self, target, reduction = torch_reduction_mean()) {
  args <- mget(x = c("out", "self", "target", "reduction"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", reduction = "int64_t")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multilabel_margin_loss_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_multinomial
.torch_multinomial <- function(self, num_samples, replacement = FALSE, generator = NULL) {
  args <- mget(x = c("self", "num_samples", "replacement", "generator"))
expected_types <- list(self = "Tensor", num_samples = "int64_t", replacement = "bool", 
    generator = "Generator")
nd_args <- c("self", "num_samples")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multinomial',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multinomial_out
torch_multinomial_out <- function(out, self, num_samples, replacement = FALSE, generator = NULL) {
  args <- mget(x = c("out", "self", "num_samples", "replacement", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", num_samples = "int64_t", 
    replacement = "bool", generator = "Generator")
nd_args <- c("out", "self", "num_samples")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multinomial_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multiply
torch_multiply <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multiply',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_multiply_out
torch_multiply_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'multiply_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mv
torch_mv <- function(self, vec) {
  args <- mget(x = c("self", "vec"))
expected_types <- list(self = "Tensor", vec = "Tensor")
nd_args <- c("self", "vec")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mv_out
torch_mv_out <- function(out, self, vec) {
  args <- mget(x = c("out", "self", "vec"))
expected_types <- list(out = "Tensor", self = "Tensor", vec = "Tensor")
nd_args <- c("out", "self", "vec")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mvlgamma
torch_mvlgamma <- function(self, p) {
  args <- mget(x = c("self", "p"))
expected_types <- list(self = "Tensor", p = "int64_t")
nd_args <- c("self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mvlgamma',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_mvlgamma_out
torch_mvlgamma_out <- function(out, self, p) {
  args <- mget(x = c("out", "self", "p"))
expected_types <- list(out = "Tensor", self = "Tensor", p = "int64_t")
nd_args <- c("out", "self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'mvlgamma_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nan_to_num
torch_nan_to_num <- function(self, nan = NULL, posinf = NULL, neginf = NULL) {
  args <- mget(x = c("self", "nan", "posinf", "neginf"))
expected_types <- list(self = "Tensor", nan = "double", posinf = "double", neginf = "double")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nan_to_num',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nan_to_num_
torch_nan_to_num_ <- function(self, nan = NULL, posinf = NULL, neginf = NULL) {
  args <- mget(x = c("self", "nan", "posinf", "neginf"))
expected_types <- list(self = "Tensor", nan = "double", posinf = "double", neginf = "double")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nan_to_num_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nan_to_num_out
torch_nan_to_num_out <- function(out, self, nan = NULL, posinf = NULL, neginf = NULL) {
  args <- mget(x = c("out", "self", "nan", "posinf", "neginf"))
expected_types <- list(out = "Tensor", self = "Tensor", nan = "double", posinf = "double", 
    neginf = "double")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nan_to_num_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nanmean
torch_nanmean <- function(self, dim = NULL, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nanmean',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nanmean_out
torch_nanmean_out <- function(out, self, dim = NULL, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nanmean_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nanmedian
torch_nanmedian <- function(self, dim, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'), list("Tensor", "Tensor"))
call_c_function(
fun_name = 'nanmedian',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nanmedian_out
torch_nanmedian_out <- function(out, values, indices, self, dim, keepdim = FALSE) {
  args <- mget(x = c("out", "values", "indices", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", values = "Tensor", indices = "Tensor", self = "Tensor", 
    dim = c("int64_t", "Dimname"), keepdim = "bool")
nd_args <- c("out", "values", "indices", "self", "dim")
return_types <- list(list("Tensor", "Tensor"), list('Tensor'))
call_c_function(
fun_name = 'nanmedian_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nanquantile
torch_nanquantile <- function(self, q, dim = NULL, keepdim = FALSE, interpolation = "linear") {
  args <- mget(x = c("self", "q", "dim", "keepdim", "interpolation"))
expected_types <- list(self = "Tensor", q = c("Tensor", "double"), dim = "int64_t", 
    keepdim = "bool", interpolation = "c10::string_view")
nd_args <- c("self", "q")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nanquantile',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nanquantile_out
torch_nanquantile_out <- function(out, self, q, dim = NULL, keepdim = FALSE, interpolation = "linear") {
  args <- mget(x = c("out", "self", "q", "dim", "keepdim", "interpolation"))
expected_types <- list(out = "Tensor", self = "Tensor", q = c("Tensor", "double"
), dim = "int64_t", keepdim = "bool", interpolation = "c10::string_view")
nd_args <- c("out", "self", "q")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nanquantile_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nansum
torch_nansum <- function(self, dim = NULL, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nansum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nansum_out
torch_nansum_out <- function(out, self, dim = NULL, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nansum_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_narrow
.torch_narrow <- function(self, dim, start, length) {
  args <- mget(x = c("self", "dim", "start", "length"))
expected_types <- list(self = "Tensor", dim = "int64_t", start = c("int64_t", "Tensor"
), length = "int64_t")
nd_args <- c("self", "dim", "start", "length")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'narrow',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_narrow_copy
torch_narrow_copy <- function(self, dim, start, length) {
  args <- mget(x = c("self", "dim", "start", "length"))
expected_types <- list(self = "Tensor", dim = "int64_t", start = "int64_t", length = "int64_t")
nd_args <- c("self", "dim", "start", "length")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'narrow_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_narrow_copy_out
torch_narrow_copy_out <- function(out, self, dim, start, length) {
  args <- mget(x = c("out", "self", "dim", "start", "length"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", start = "int64_t", 
    length = "int64_t")
nd_args <- c("out", "self", "dim", "start", "length")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'narrow_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_batch_norm
torch_native_batch_norm <- function(input, weight, bias, running_mean, running_var, training, momentum, eps) {
  args <- mget(x = c("input", "weight", "bias", "running_mean", "running_var", "training", "momentum", "eps"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", momentum = "double", 
    eps = "double")
nd_args <- c("input", "weight", "bias", "running_mean", "running_var", "training", 
"momentum", "eps")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_batch_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_batch_norm_backward
torch_native_batch_norm_backward <- function(grad_out, input, weight, running_mean, running_var, save_mean, save_invstd, train, eps, output_mask) {
  args <- mget(x = c("grad_out", "input", "weight", "running_mean", "running_var", "save_mean", "save_invstd", "train", "eps", "output_mask"))
expected_types <- list(grad_out = "Tensor", input = "Tensor", weight = "Tensor", 
    running_mean = "Tensor", running_var = "Tensor", save_mean = "Tensor", 
    save_invstd = "Tensor", train = "bool", eps = "double", output_mask = "::std::array<bool,3>")
nd_args <- c("grad_out", "input", "weight", "running_mean", "running_var", 
"save_mean", "save_invstd", "train", "eps", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_batch_norm_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_batch_norm_backward_out
torch_native_batch_norm_backward_out <- function(out0, out1, out2, grad_out, input, weight, running_mean, running_var, save_mean, save_invstd, train, eps, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "grad_out", "input", "weight", "running_mean", "running_var", "save_mean", "save_invstd", "train", "eps", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", grad_out = "Tensor", 
    input = "Tensor", weight = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", save_mean = "Tensor", save_invstd = "Tensor", 
    train = "bool", eps = "double", output_mask = "::std::array<bool,3>")
nd_args <- c("out0", "out1", "out2", "grad_out", "input", "weight", "running_mean", 
"running_var", "save_mean", "save_invstd", "train", "eps", "output_mask"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_batch_norm_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_batch_norm_out
torch_native_batch_norm_out <- function(out, save_mean, save_invstd, input, weight, bias, running_mean, running_var, training, momentum, eps) {
  args <- mget(x = c("out", "save_mean", "save_invstd", "input", "weight", "bias", "running_mean", "running_var", "training", "momentum", "eps"))
expected_types <- list(out = "Tensor", save_mean = "Tensor", save_invstd = "Tensor", 
    input = "Tensor", weight = "Tensor", bias = "Tensor", running_mean = "Tensor", 
    running_var = "Tensor", training = "bool", momentum = "double", 
    eps = "double")
nd_args <- c("out", "save_mean", "save_invstd", "input", "weight", "bias", 
"running_mean", "running_var", "training", "momentum", "eps")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_batch_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_channel_shuffle
torch_native_channel_shuffle <- function(self, groups) {
  args <- mget(x = c("self", "groups"))
expected_types <- list(self = "Tensor", groups = "int64_t")
nd_args <- c("self", "groups")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'native_channel_shuffle',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_dropout
torch_native_dropout <- function(input, p, train) {
  args <- mget(x = c("input", "p", "train"))
expected_types <- list(input = "Tensor", p = "double", train = "bool")
nd_args <- c("input", "p", "train")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'native_dropout',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_dropout_backward
torch_native_dropout_backward <- function(grad_output, mask, scale) {
  args <- mget(x = c("grad_output", "mask", "scale"))
expected_types <- list(grad_output = "Tensor", mask = "Tensor", scale = "double")
nd_args <- c("grad_output", "mask", "scale")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'native_dropout_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_dropout_backward_out
torch_native_dropout_backward_out <- function(out, grad_output, mask, scale) {
  args <- mget(x = c("out", "grad_output", "mask", "scale"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", mask = "Tensor", 
    scale = "double")
nd_args <- c("out", "grad_output", "mask", "scale")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'native_dropout_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_dropout_out
torch_native_dropout_out <- function(out0, out1, input, p, train) {
  args <- mget(x = c("out0", "out1", "input", "p", "train"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", input = "Tensor", p = "double", 
    train = "bool")
nd_args <- c("out0", "out1", "input", "p", "train")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'native_dropout_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_group_norm
torch_native_group_norm <- function(input, weight, bias, False, C, HxW, group, eps) {
  args <- mget(x = c("input", "weight", "bias", "False", "C", "HxW", "group", "eps"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", False = "int64_t", 
    C = "int64_t", HxW = "int64_t", group = "int64_t", eps = "double")
nd_args <- c("input", "weight", "bias", "False", "C", "HxW", "group", "eps"
)
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_group_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_group_norm_backward
torch_native_group_norm_backward <- function(grad_out, input, mean, rstd, weight, False, C, HxW, group, output_mask) {
  args <- mget(x = c("grad_out", "input", "mean", "rstd", "weight", "False", "C", "HxW", "group", "output_mask"))
expected_types <- list(grad_out = "Tensor", input = "Tensor", mean = "Tensor", 
    rstd = "Tensor", weight = "Tensor", False = "int64_t", C = "int64_t", 
    HxW = "int64_t", group = "int64_t", output_mask = "::std::array<bool,3>")
nd_args <- c("grad_out", "input", "mean", "rstd", "weight", "False", "C", 
"HxW", "group", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_group_norm_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_group_norm_backward_out
torch_native_group_norm_backward_out <- function(out0, out1, out2, grad_out, input, mean, rstd, weight, False, C, HxW, group, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "grad_out", "input", "mean", "rstd", "weight", "False", "C", "HxW", "group", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", grad_out = "Tensor", 
    input = "Tensor", mean = "Tensor", rstd = "Tensor", weight = "Tensor", 
    False = "int64_t", C = "int64_t", HxW = "int64_t", group = "int64_t", 
    output_mask = "::std::array<bool,3>")
nd_args <- c("out0", "out1", "out2", "grad_out", "input", "mean", "rstd", 
"weight", "False", "C", "HxW", "group", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_group_norm_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_group_norm_out
torch_native_group_norm_out <- function(out0, out1, out2, input, weight, bias, False, C, HxW, group, eps) {
  args <- mget(x = c("out0", "out1", "out2", "input", "weight", "bias", "False", "C", "HxW", "group", "eps"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", input = "Tensor", 
    weight = "Tensor", bias = "Tensor", False = "int64_t", C = "int64_t", 
    HxW = "int64_t", group = "int64_t", eps = "double")
nd_args <- c("out0", "out1", "out2", "input", "weight", "bias", "False", 
"C", "HxW", "group", "eps")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_group_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_layer_norm
torch_native_layer_norm <- function(input, normalized_shape, weight, bias, eps) {
  args <- mget(x = c("input", "normalized_shape", "weight", "bias", "eps"))
expected_types <- list(input = "Tensor", normalized_shape = "IntArrayRef", weight = "Tensor", 
    bias = "Tensor", eps = "double")
nd_args <- c("input", "normalized_shape", "weight", "bias", "eps")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_layer_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_layer_norm_backward
torch_native_layer_norm_backward <- function(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask) {
  args <- mget(x = c("grad_out", "input", "normalized_shape", "mean", "rstd", "weight", "bias", "output_mask"))
expected_types <- list(grad_out = "Tensor", input = "Tensor", normalized_shape = "IntArrayRef", 
    mean = "Tensor", rstd = "Tensor", weight = "Tensor", bias = "Tensor", 
    output_mask = "::std::array<bool,3>")
nd_args <- c("grad_out", "input", "normalized_shape", "mean", "rstd", "weight", 
"bias", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_layer_norm_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_layer_norm_backward_out
torch_native_layer_norm_backward_out <- function(out0, out1, out2, grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask) {
  args <- mget(x = c("out0", "out1", "out2", "grad_out", "input", "normalized_shape", "mean", "rstd", "weight", "bias", "output_mask"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", grad_out = "Tensor", 
    input = "Tensor", normalized_shape = "IntArrayRef", mean = "Tensor", 
    rstd = "Tensor", weight = "Tensor", bias = "Tensor", output_mask = "::std::array<bool,3>")
nd_args <- c("out0", "out1", "out2", "grad_out", "input", "normalized_shape", 
"mean", "rstd", "weight", "bias", "output_mask")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_layer_norm_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_layer_norm_out
torch_native_layer_norm_out <- function(out0, out1, out2, input, normalized_shape, weight, bias, eps) {
  args <- mget(x = c("out0", "out1", "out2", "input", "normalized_shape", "weight", "bias", "eps"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", input = "Tensor", 
    normalized_shape = "IntArrayRef", weight = "Tensor", bias = "Tensor", 
    eps = "double")
nd_args <- c("out0", "out1", "out2", "input", "normalized_shape", "weight", 
"bias", "eps")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'native_layer_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_norm
torch_native_norm <- function(self, p = 2L, dim, keepdim, dtype) {
  args <- mget(x = c("self", "p", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", p = "Scalar", dim = "IntArrayRef", keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- c("self", "p", "dim", "keepdim", "dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'native_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_native_norm_out
torch_native_norm_out <- function(out, self, p = 2L, dim, keepdim, dtype) {
  args <- mget(x = c("out", "self", "p", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", p = "Scalar", dim = "IntArrayRef", 
    keepdim = "bool", dtype = "ScalarType")
nd_args <- c("out", "self", "p", "dim", "keepdim", "dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'native_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ne
torch_ne <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ne',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ne_out
torch_ne_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ne_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_neg
torch_neg <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'neg',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_neg_
torch_neg_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'neg_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_neg_out
torch_neg_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'neg_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_negative
torch_negative <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'negative',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_negative_
torch_negative_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'negative_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_negative_out
torch_negative_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'negative_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nested_to_padded_tensor
torch_nested_to_padded_tensor <- function(self, padding, output_size = NULL) {
  args <- mget(x = c("self", "padding", "output_size"))
expected_types <- list(self = "Tensor", padding = "double", output_size = "IntArrayRef")
nd_args <- c("self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nested_to_padded_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_new_empty_out
torch_new_empty_out <- function(out, self, size) {
  args <- mget(x = c("out", "self", "size"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef")
nd_args <- c("out", "self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'new_empty_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_new_empty_strided_out
torch_new_empty_strided_out <- function(out, self, size, stride) {
  args <- mget(x = c("out", "self", "size", "stride"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("out", "self", "size", "stride")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'new_empty_strided_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_new_full_out
torch_new_full_out <- function(out, self, size, fill_value) {
  args <- mget(x = c("out", "self", "size", "fill_value"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef", fill_value = "Scalar")
nd_args <- c("out", "self", "size", "fill_value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'new_full_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_new_ones_out
torch_new_ones_out <- function(out, self, size) {
  args <- mget(x = c("out", "self", "size"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef")
nd_args <- c("out", "self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'new_ones_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_new_zeros_out
torch_new_zeros_out <- function(out, self, size) {
  args <- mget(x = c("out", "self", "size"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef")
nd_args <- c("out", "self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'new_zeros_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nextafter
torch_nextafter <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nextafter',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nextafter_out
torch_nextafter_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nextafter_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_nll_loss
.torch_nll_loss <- function(self, target, weight = list(), reduction = torch_reduction_mean(), ignore_index = -100L) {
  args <- mget(x = c("self", "target", "weight", "reduction", "ignore_index"))
expected_types <- list(self = "Tensor", target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nll_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss_backward
torch_nll_loss_backward <- function(grad_output, self, target, weight, reduction, ignore_index, total_weight) {
  args <- mget(x = c("grad_output", "self", "target", "weight", "reduction", "ignore_index", "total_weight"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", target = "Tensor", 
    weight = "Tensor", reduction = "int64_t", ignore_index = "int64_t", 
    total_weight = "Tensor")
nd_args <- c("grad_output", "self", "target", "weight", "reduction", "ignore_index", 
"total_weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nll_loss_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss_backward_out
torch_nll_loss_backward_out <- function(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight) {
  args <- mget(x = c("grad_input", "grad_output", "self", "target", "weight", "reduction", "ignore_index", "total_weight"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t", total_weight = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "target", "weight", "reduction", 
"ignore_index", "total_weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nll_loss_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss_forward
torch_nll_loss_forward <- function(self, target, weight, reduction, ignore_index) {
  args <- mget(x = c("self", "target", "weight", "reduction", "ignore_index"))
expected_types <- list(self = "Tensor", target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t")
nd_args <- c("self", "target", "weight", "reduction", "ignore_index")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'nll_loss_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss_forward_out
torch_nll_loss_forward_out <- function(output, total_weight, self, target, weight, reduction, ignore_index) {
  args <- mget(x = c("output", "total_weight", "self", "target", "weight", "reduction", "ignore_index"))
expected_types <- list(output = "Tensor", total_weight = "Tensor", self = "Tensor", 
    target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t")
nd_args <- c("output", "total_weight", "self", "target", "weight", "reduction", 
"ignore_index")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'nll_loss_forward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_nll_loss_nd
.torch_nll_loss_nd <- function(self, target, weight = list(), reduction = torch_reduction_mean(), ignore_index = -100L) {
  args <- mget(x = c("self", "target", "weight", "reduction", "ignore_index"))
expected_types <- list(self = "Tensor", target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nll_loss_nd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss_out
torch_nll_loss_out <- function(out, self, target, weight = list(), reduction = torch_reduction_mean(), ignore_index = -100L) {
  args <- mget(x = c("out", "self", "target", "weight", "reduction", "ignore_index"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", weight = "Tensor", 
    reduction = "int64_t", ignore_index = "int64_t")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nll_loss_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_nll_loss2d
.torch_nll_loss2d <- function(self, target, weight = list(), reduction = torch_reduction_mean(), ignore_index = -100L) {
  args <- mget(x = c("self", "target", "weight", "reduction", "ignore_index"))
expected_types <- list(self = "Tensor", target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nll_loss2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss2d_backward
torch_nll_loss2d_backward <- function(grad_output, self, target, weight, reduction, ignore_index, total_weight) {
  args <- mget(x = c("grad_output", "self", "target", "weight", "reduction", "ignore_index", "total_weight"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", target = "Tensor", 
    weight = "Tensor", reduction = "int64_t", ignore_index = "int64_t", 
    total_weight = "Tensor")
nd_args <- c("grad_output", "self", "target", "weight", "reduction", "ignore_index", 
"total_weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nll_loss2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss2d_backward_out
torch_nll_loss2d_backward_out <- function(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight) {
  args <- mget(x = c("grad_input", "grad_output", "self", "target", "weight", "reduction", "ignore_index", "total_weight"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t", total_weight = "Tensor")
nd_args <- c("grad_input", "grad_output", "self", "target", "weight", "reduction", 
"ignore_index", "total_weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nll_loss2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss2d_forward
torch_nll_loss2d_forward <- function(self, target, weight, reduction, ignore_index) {
  args <- mget(x = c("self", "target", "weight", "reduction", "ignore_index"))
expected_types <- list(self = "Tensor", target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t")
nd_args <- c("self", "target", "weight", "reduction", "ignore_index")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'nll_loss2d_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss2d_forward_out
torch_nll_loss2d_forward_out <- function(output, total_weight, self, target, weight, reduction, ignore_index) {
  args <- mget(x = c("output", "total_weight", "self", "target", "weight", "reduction", "ignore_index"))
expected_types <- list(output = "Tensor", total_weight = "Tensor", self = "Tensor", 
    target = "Tensor", weight = "Tensor", reduction = "int64_t", 
    ignore_index = "int64_t")
nd_args <- c("output", "total_weight", "self", "target", "weight", "reduction", 
"ignore_index")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'nll_loss2d_forward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nll_loss2d_out
torch_nll_loss2d_out <- function(out, self, target, weight = list(), reduction = torch_reduction_mean(), ignore_index = -100L) {
  args <- mget(x = c("out", "self", "target", "weight", "reduction", "ignore_index"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", weight = "Tensor", 
    reduction = "int64_t", ignore_index = "int64_t")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nll_loss2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_nonzero
.torch_nonzero <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nonzero',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nonzero_numpy
torch_nonzero_numpy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'nonzero_numpy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nonzero_out
torch_nonzero_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nonzero_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_norm
.torch_norm <- function(self, p = 2L, dim, keepdim = FALSE, dtype) {
  args <- mget(x = c("self", "p", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", p = "Scalar", dim = c("IntArrayRef", "DimnameList"
), keepdim = "bool", dtype = "ScalarType")
nd_args <- c("self", "p", "dim", "keepdim", "dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_norm_except_dim
torch_norm_except_dim <- function(v, pow = 2L, dim = 1L) {
  args <- mget(x = c("v", "pow", "dim"))
expected_types <- list(v = "Tensor", pow = "int64_t", dim = "int64_t")
nd_args <- "v"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'norm_except_dim',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_norm_out
torch_norm_out <- function(out, self, p = 2L, dim, keepdim = FALSE, dtype) {
  args <- mget(x = c("out", "self", "p", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", p = "Scalar", dim = c("IntArrayRef", 
"DimnameList"), keepdim = "bool", dtype = "ScalarType")
nd_args <- c("out", "self", "p", "dim", "keepdim", "dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_normal
.torch_normal <- function(mean, std = 1L, size, generator = NULL, options = list()) {
  args <- mget(x = c("mean", "std", "size", "generator", "options"))
expected_types <- list(mean = c("Tensor", "double"), std = c("double", "Tensor"
), size = "IntArrayRef", generator = "Generator", options = "TensorOptions")
nd_args <- c("mean", "std", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'normal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_normal_functional
torch_normal_functional <- function(self, mean = 0L, std = 1L, generator = NULL) {
  args <- mget(x = c("self", "mean", "std", "generator"))
expected_types <- list(self = "Tensor", mean = "double", std = "double", generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'normal_functional',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_normal_out
torch_normal_out <- function(out, self, mean = 0L, size, std = 1L, generator = NULL) {
  args <- mget(x = c("out", "self", "mean", "size", "std", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", mean = c("Tensor", "double"
), size = "IntArrayRef", std = c("double", "Tensor"), generator = "Generator")
nd_args <- c("out", "self", "mean", "size", "std")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'normal_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_not_equal
torch_not_equal <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Scalar", "Tensor"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'not_equal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_not_equal_out
torch_not_equal_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Scalar", "Tensor"
))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'not_equal_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nuclear_norm
torch_nuclear_norm <- function(self, dim, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nuclear_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_nuclear_norm_out
torch_nuclear_norm_out <- function(out, self, dim, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'nuclear_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_one_hot
.torch_one_hot <- function(self, num_classes = -1L) {
  args <- mget(x = c("self", "num_classes"))
expected_types <- list(self = "Tensor", num_classes = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'one_hot',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_ones
.torch_ones <- function(size, names, options = list()) {
  args <- mget(x = c("size", "names", "options"))
expected_types <- list(size = "IntArrayRef", names = "DimnameList", options = "TensorOptions")
nd_args <- c("size", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ones',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_ones_like
.torch_ones_like <- function(self, options = list(), memory_format = NULL) {
  args <- mget(x = c("self", "options", "memory_format"))
expected_types <- list(self = "Tensor", options = "TensorOptions", memory_format = "MemoryFormat")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ones_like',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ones_like_out
torch_ones_like_out <- function(out, self, memory_format = NULL) {
  args <- mget(x = c("out", "self", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", memory_format = "MemoryFormat")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ones_like_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ones_out
torch_ones_out <- function(out, size, names) {
  args <- mget(x = c("out", "size", "names"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", names = "DimnameList")
nd_args <- c("out", "size", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ones_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_orgqr
torch_orgqr <- function(self, input2) {
  args <- mget(x = c("self", "input2"))
expected_types <- list(self = "Tensor", input2 = "Tensor")
nd_args <- c("self", "input2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'orgqr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_orgqr_out
torch_orgqr_out <- function(out, self, input2) {
  args <- mget(x = c("out", "self", "input2"))
expected_types <- list(out = "Tensor", self = "Tensor", input2 = "Tensor")
nd_args <- c("out", "self", "input2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'orgqr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ormqr
torch_ormqr <- function(self, input2, input3, left = TRUE, transpose = FALSE) {
  args <- mget(x = c("self", "input2", "input3", "left", "transpose"))
expected_types <- list(self = "Tensor", input2 = "Tensor", input3 = "Tensor", left = "bool", 
    transpose = "bool")
nd_args <- c("self", "input2", "input3")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ormqr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ormqr_out
torch_ormqr_out <- function(out, self, input2, input3, left = TRUE, transpose = FALSE) {
  args <- mget(x = c("out", "self", "input2", "input3", "left", "transpose"))
expected_types <- list(out = "Tensor", self = "Tensor", input2 = "Tensor", input3 = "Tensor", 
    left = "bool", transpose = "bool")
nd_args <- c("out", "self", "input2", "input3")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ormqr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_outer
torch_outer <- function(self, vec2) {
  args <- mget(x = c("self", "vec2"))
expected_types <- list(self = "Tensor", vec2 = "Tensor")
nd_args <- c("self", "vec2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'outer',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_outer_out
torch_outer_out <- function(out, self, vec2) {
  args <- mget(x = c("out", "self", "vec2"))
expected_types <- list(out = "Tensor", self = "Tensor", vec2 = "Tensor")
nd_args <- c("out", "self", "vec2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'outer_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pad
torch_pad <- function(self, pad, mode = "constant", value = NULL) {
  args <- mget(x = c("self", "pad", "mode", "value"))
expected_types <- list(self = "Tensor", pad = "IntArrayRef", mode = "c10::string_view", 
    value = "double")
nd_args <- c("self", "pad")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pad',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pad_sequence
torch_pad_sequence <- function(sequences, batch_first = FALSE, padding_value = 0L) {
  args <- mget(x = c("sequences", "batch_first", "padding_value"))
expected_types <- list(sequences = "TensorList", batch_first = "bool", padding_value = "double")
nd_args <- "sequences"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pad_sequence',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pairwise_distance
torch_pairwise_distance <- function(x1, x2, p = 2L, eps = 1e-06, keepdim = FALSE) {
  args <- mget(x = c("x1", "x2", "p", "eps", "keepdim"))
expected_types <- list(x1 = "Tensor", x2 = "Tensor", p = "double", eps = "double", 
    keepdim = "bool")
nd_args <- c("x1", "x2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pairwise_distance',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pdist
torch_pdist <- function(self, p = 2L) {
  args <- mget(x = c("self", "p"))
expected_types <- list(self = "Tensor", p = "double")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pdist',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_permute
torch_permute <- function(self, dims) {
  args <- mget(x = c("self", "dims"))
expected_types <- list(self = "Tensor", dims = "IntArrayRef")
nd_args <- c("self", "dims")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'permute',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_permute_copy
torch_permute_copy <- function(self, dims) {
  args <- mget(x = c("self", "dims"))
expected_types <- list(self = "Tensor", dims = "IntArrayRef")
nd_args <- c("self", "dims")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'permute_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_permute_copy_out
torch_permute_copy_out <- function(out, self, dims) {
  args <- mget(x = c("out", "self", "dims"))
expected_types <- list(out = "Tensor", self = "Tensor", dims = "IntArrayRef")
nd_args <- c("out", "self", "dims")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'permute_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pinverse
torch_pinverse <- function(self, rcond = 1e-15) {
  args <- mget(x = c("self", "rcond"))
expected_types <- list(self = "Tensor", rcond = "double")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pinverse',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pixel_shuffle
torch_pixel_shuffle <- function(self, upscale_factor) {
  args <- mget(x = c("self", "upscale_factor"))
expected_types <- list(self = "Tensor", upscale_factor = "int64_t")
nd_args <- c("self", "upscale_factor")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pixel_shuffle',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pixel_shuffle_out
torch_pixel_shuffle_out <- function(out, self, upscale_factor) {
  args <- mget(x = c("out", "self", "upscale_factor"))
expected_types <- list(out = "Tensor", self = "Tensor", upscale_factor = "int64_t")
nd_args <- c("out", "self", "upscale_factor")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pixel_shuffle_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pixel_unshuffle
torch_pixel_unshuffle <- function(self, downscale_factor) {
  args <- mget(x = c("self", "downscale_factor"))
expected_types <- list(self = "Tensor", downscale_factor = "int64_t")
nd_args <- c("self", "downscale_factor")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pixel_unshuffle',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pixel_unshuffle_out
torch_pixel_unshuffle_out <- function(out, self, downscale_factor) {
  args <- mget(x = c("out", "self", "downscale_factor"))
expected_types <- list(out = "Tensor", self = "Tensor", downscale_factor = "int64_t")
nd_args <- c("out", "self", "downscale_factor")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pixel_unshuffle_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_poisson
torch_poisson <- function(self, generator = NULL) {
  args <- mget(x = c("self", "generator"))
expected_types <- list(self = "Tensor", generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'poisson',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_poisson_nll_loss
torch_poisson_nll_loss <- function(input, target, log_input, full, eps, reduction) {
  args <- mget(x = c("input", "target", "log_input", "full", "eps", "reduction"))
expected_types <- list(input = "Tensor", target = "Tensor", log_input = "bool", 
    full = "bool", eps = "double", reduction = "int64_t")
nd_args <- c("input", "target", "log_input", "full", "eps", "reduction")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'poisson_nll_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_poisson_out
torch_poisson_out <- function(out, self, generator = NULL) {
  args <- mget(x = c("out", "self", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", generator = "Generator")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'poisson_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_polar
torch_polar <- function(abs, angle) {
  args <- mget(x = c("abs", "angle"))
expected_types <- list(abs = "Tensor", angle = "Tensor")
nd_args <- c("abs", "angle")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'polar',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_polar_out
torch_polar_out <- function(out, abs, angle) {
  args <- mget(x = c("out", "abs", "angle"))
expected_types <- list(out = "Tensor", abs = "Tensor", angle = "Tensor")
nd_args <- c("out", "abs", "angle")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'polar_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_polygamma_out
torch_polygamma_out <- function(out, n, self) {
  args <- mget(x = c("out", "n", "self"))
expected_types <- list(out = "Tensor", n = "int64_t", self = "Tensor")
nd_args <- c("out", "n", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'polygamma_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_positive
torch_positive <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'positive',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pow
torch_pow <- function(self, exponent) {
  args <- mget(x = c("self", "exponent"))
expected_types <- list(self = c("Tensor", "Scalar"), exponent = c("Tensor", "Scalar"
))
nd_args <- c("self", "exponent")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pow',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_pow_out
torch_pow_out <- function(out, self, exponent) {
  args <- mget(x = c("out", "self", "exponent"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), exponent = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "exponent")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'pow_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_prelu
torch_prelu <- function(self, weight) {
  args <- mget(x = c("self", "weight"))
expected_types <- list(self = "Tensor", weight = "Tensor")
nd_args <- c("self", "weight")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'prelu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_prod
torch_prod <- function(self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), keepdim = "bool", 
    dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'prod',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_prod_out
torch_prod_out <- function(out, self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("int64_t", "Dimname"
), keepdim = "bool", dtype = "ScalarType")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'prod_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_promote_types
torch_promote_types <- function(type1, type2) {
  args <- mget(x = c("type1", "type2"))
expected_types <- list(type1 = "ScalarType", type2 = "ScalarType")
nd_args <- c("type1", "type2")
return_types <- list(list('ScalarType'))
call_c_function(
fun_name = 'promote_types',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_put
torch_put <- function(self, index, source, accumulate = FALSE) {
  args <- mget(x = c("self", "index", "source", "accumulate"))
expected_types <- list(self = "Tensor", index = "Tensor", source = "Tensor", accumulate = "bool")
nd_args <- c("self", "index", "source")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'put',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_put_out
torch_put_out <- function(out, self, index, source, accumulate = FALSE) {
  args <- mget(x = c("out", "self", "index", "source", "accumulate"))
expected_types <- list(out = "Tensor", self = "Tensor", index = "Tensor", source = "Tensor", 
    accumulate = "bool")
nd_args <- c("out", "self", "index", "source")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'put_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_q_per_channel_axis
torch_q_per_channel_axis <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('int64_t'))
call_c_function(
fun_name = 'q_per_channel_axis',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_q_per_channel_scales
torch_q_per_channel_scales <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'q_per_channel_scales',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_q_per_channel_scales_out
torch_q_per_channel_scales_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'q_per_channel_scales_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_q_per_channel_zero_points
torch_q_per_channel_zero_points <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'q_per_channel_zero_points',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_q_per_channel_zero_points_out
torch_q_per_channel_zero_points_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'q_per_channel_zero_points_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_q_scale
torch_q_scale <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('double'))
call_c_function(
fun_name = 'q_scale',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_q_zero_point
torch_q_zero_point <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('int64_t'))
call_c_function(
fun_name = 'q_zero_point',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_qr
torch_qr <- function(self, some = TRUE) {
  args <- mget(x = c("self", "some"))
expected_types <- list(self = "Tensor", some = "bool")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'qr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_qr_out
torch_qr_out <- function(Q, R, self, some = TRUE) {
  args <- mget(x = c("Q", "R", "self", "some"))
expected_types <- list(Q = "Tensor", R = "Tensor", self = "Tensor", some = "bool")
nd_args <- c("Q", "R", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'qr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantile
torch_quantile <- function(self, q, dim = NULL, keepdim = FALSE, interpolation = "linear") {
  args <- mget(x = c("self", "q", "dim", "keepdim", "interpolation"))
expected_types <- list(self = "Tensor", q = c("Tensor", "double"), dim = "int64_t", 
    keepdim = "bool", interpolation = "c10::string_view")
nd_args <- c("self", "q")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantile',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantile_out
torch_quantile_out <- function(out, self, q, dim = NULL, keepdim = FALSE, interpolation = "linear") {
  args <- mget(x = c("out", "self", "q", "dim", "keepdim", "interpolation"))
expected_types <- list(out = "Tensor", self = "Tensor", q = c("Tensor", "double"
), dim = "int64_t", keepdim = "bool", interpolation = "c10::string_view")
nd_args <- c("out", "self", "q")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantile_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantize_per_channel
torch_quantize_per_channel <- function(self, scales, zero_points, axis, dtype) {
  args <- mget(x = c("self", "scales", "zero_points", "axis", "dtype"))
expected_types <- list(self = "Tensor", scales = "Tensor", zero_points = "Tensor", 
    axis = "int64_t", dtype = "ScalarType")
nd_args <- c("self", "scales", "zero_points", "axis", "dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantize_per_channel',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantize_per_channel_out
torch_quantize_per_channel_out <- function(out, self, scales, zero_points, axis, dtype) {
  args <- mget(x = c("out", "self", "scales", "zero_points", "axis", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", scales = "Tensor", zero_points = "Tensor", 
    axis = "int64_t", dtype = "ScalarType")
nd_args <- c("out", "self", "scales", "zero_points", "axis", "dtype")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantize_per_channel_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_quantize_per_tensor
.torch_quantize_per_tensor <- function(self, tensors, scale, scales, zero_point, zero_points, dtype) {
  args <- mget(x = c("self", "tensors", "scale", "scales", "zero_point", "zero_points", "dtype"))
expected_types <- list(self = "Tensor", tensors = "TensorList", scale = c("double", 
"Tensor"), scales = "Tensor", zero_point = c("int64_t", "Tensor"
), zero_points = "Tensor", dtype = "ScalarType")
nd_args <- c("self", "tensors", "scale", "scales", "zero_point", "zero_points", 
"dtype")
return_types <- list(list('Tensor'), list('TensorList'))
call_c_function(
fun_name = 'quantize_per_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantize_per_tensor_dynamic
torch_quantize_per_tensor_dynamic <- function(self, dtype, reduce_range) {
  args <- mget(x = c("self", "dtype", "reduce_range"))
expected_types <- list(self = "Tensor", dtype = "ScalarType", reduce_range = "bool")
nd_args <- c("self", "dtype", "reduce_range")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantize_per_tensor_dynamic',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantize_per_tensor_dynamic_out
torch_quantize_per_tensor_dynamic_out <- function(out, self, dtype, reduce_range) {
  args <- mget(x = c("out", "self", "dtype", "reduce_range"))
expected_types <- list(out = "Tensor", self = "Tensor", dtype = "ScalarType", reduce_range = "bool")
nd_args <- c("out", "self", "dtype", "reduce_range")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantize_per_tensor_dynamic_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantize_per_tensor_out
torch_quantize_per_tensor_out <- function(out, self, tensors, scale, scales, zero_point, zero_points, dtype) {
  args <- mget(x = c("out", "self", "tensors", "scale", "scales", "zero_point", "zero_points", "dtype"))
expected_types <- list(out = c("Tensor", "TensorList"), self = "Tensor", tensors = "TensorList", 
    scale = c("double", "Tensor"), scales = "Tensor", zero_point = c("int64_t", 
    "Tensor"), zero_points = "Tensor", dtype = "ScalarType")
nd_args <- c("out", "self", "tensors", "scale", "scales", "zero_point", 
"zero_points", "dtype")
return_types <- list(list('Tensor'), list("void"))
call_c_function(
fun_name = 'quantize_per_tensor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_batch_norm
torch_quantized_batch_norm <- function(input, weight, bias, mean, var, eps, output_scale, output_zero_point) {
  args <- mget(x = c("input", "weight", "bias", "mean", "var", "eps", "output_scale", "output_zero_point"))
expected_types <- list(input = "Tensor", weight = "Tensor", bias = "Tensor", mean = "Tensor", 
    var = "Tensor", eps = "double", output_scale = "double", 
    output_zero_point = "int64_t")
nd_args <- c("input", "weight", "bias", "mean", "var", "eps", "output_scale", 
"output_zero_point")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantized_batch_norm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_batch_norm_out
torch_quantized_batch_norm_out <- function(out, input, weight, bias, mean, var, eps, output_scale, output_zero_point) {
  args <- mget(x = c("out", "input", "weight", "bias", "mean", "var", "eps", "output_scale", "output_zero_point"))
expected_types <- list(out = "Tensor", input = "Tensor", weight = "Tensor", bias = "Tensor", 
    mean = "Tensor", var = "Tensor", eps = "double", output_scale = "double", 
    output_zero_point = "int64_t")
nd_args <- c("out", "input", "weight", "bias", "mean", "var", "eps", "output_scale", 
"output_zero_point")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantized_batch_norm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_gru_cell
torch_quantized_gru_cell <- function(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh) {
  args <- mget(x = c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh", "packed_ih", "packed_hh", "col_offsets_ih", "col_offsets_hh", "scale_ih", "scale_hh", "zero_point_ih", "zero_point_hh"))
expected_types <- list(input = "Tensor", hx = "Tensor", w_ih = "Tensor", w_hh = "Tensor", 
    b_ih = "Tensor", b_hh = "Tensor", packed_ih = "Tensor", packed_hh = "Tensor", 
    col_offsets_ih = "Tensor", col_offsets_hh = "Tensor", scale_ih = "Scalar", 
    scale_hh = "Scalar", zero_point_ih = "Scalar", zero_point_hh = "Scalar")
nd_args <- c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh", "packed_ih", 
"packed_hh", "col_offsets_ih", "col_offsets_hh", "scale_ih", 
"scale_hh", "zero_point_ih", "zero_point_hh")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantized_gru_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_lstm_cell
torch_quantized_lstm_cell <- function(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh) {
  args <- mget(x = c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh", "packed_ih", "packed_hh", "col_offsets_ih", "col_offsets_hh", "scale_ih", "scale_hh", "zero_point_ih", "zero_point_hh"))
expected_types <- list(input = "Tensor", hx = "TensorList", w_ih = "Tensor", w_hh = "Tensor", 
    b_ih = "Tensor", b_hh = "Tensor", packed_ih = "Tensor", packed_hh = "Tensor", 
    col_offsets_ih = "Tensor", col_offsets_hh = "Tensor", scale_ih = "Scalar", 
    scale_hh = "Scalar", zero_point_ih = "Scalar", zero_point_hh = "Scalar")
nd_args <- c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh", "packed_ih", 
"packed_hh", "col_offsets_ih", "col_offsets_hh", "scale_ih", 
"scale_hh", "zero_point_ih", "zero_point_hh")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'quantized_lstm_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_max_pool1d
torch_quantized_max_pool1d <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantized_max_pool1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_max_pool1d_out
torch_quantized_max_pool1d_out <- function(out, self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("out", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(out = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    ceil_mode = "bool")
nd_args <- c("out", "self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantized_max_pool1d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_max_pool2d
torch_quantized_max_pool2d <- function(self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(self = "Tensor", kernel_size = "IntArrayRef", stride = "IntArrayRef", 
    padding = "IntArrayRef", dilation = "IntArrayRef", ceil_mode = "bool")
nd_args <- c("self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantized_max_pool2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_max_pool2d_out
torch_quantized_max_pool2d_out <- function(out, self, kernel_size, stride = list(), padding = 0L, dilation = 1L, ceil_mode = FALSE) {
  args <- mget(x = c("out", "self", "kernel_size", "stride", "padding", "dilation", "ceil_mode"))
expected_types <- list(out = "Tensor", self = "Tensor", kernel_size = "IntArrayRef", 
    stride = "IntArrayRef", padding = "IntArrayRef", dilation = "IntArrayRef", 
    ceil_mode = "bool")
nd_args <- c("out", "self", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantized_max_pool2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_rnn_relu_cell
torch_quantized_rnn_relu_cell <- function(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh) {
  args <- mget(x = c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh", "packed_ih", "packed_hh", "col_offsets_ih", "col_offsets_hh", "scale_ih", "scale_hh", "zero_point_ih", "zero_point_hh"))
expected_types <- list(input = "Tensor", hx = "Tensor", w_ih = "Tensor", w_hh = "Tensor", 
    b_ih = "Tensor", b_hh = "Tensor", packed_ih = "Tensor", packed_hh = "Tensor", 
    col_offsets_ih = "Tensor", col_offsets_hh = "Tensor", scale_ih = "Scalar", 
    scale_hh = "Scalar", zero_point_ih = "Scalar", zero_point_hh = "Scalar")
nd_args <- c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh", "packed_ih", 
"packed_hh", "col_offsets_ih", "col_offsets_hh", "scale_ih", 
"scale_hh", "zero_point_ih", "zero_point_hh")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantized_rnn_relu_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_quantized_rnn_tanh_cell
torch_quantized_rnn_tanh_cell <- function(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh) {
  args <- mget(x = c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh", "packed_ih", "packed_hh", "col_offsets_ih", "col_offsets_hh", "scale_ih", "scale_hh", "zero_point_ih", "zero_point_hh"))
expected_types <- list(input = "Tensor", hx = "Tensor", w_ih = "Tensor", w_hh = "Tensor", 
    b_ih = "Tensor", b_hh = "Tensor", packed_ih = "Tensor", packed_hh = "Tensor", 
    col_offsets_ih = "Tensor", col_offsets_hh = "Tensor", scale_ih = "Scalar", 
    scale_hh = "Scalar", zero_point_ih = "Scalar", zero_point_hh = "Scalar")
nd_args <- c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh", "packed_ih", 
"packed_hh", "col_offsets_ih", "col_offsets_hh", "scale_ih", 
"scale_hh", "zero_point_ih", "zero_point_hh")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'quantized_rnn_tanh_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rad2deg
torch_rad2deg <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rad2deg',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rad2deg_
torch_rad2deg_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rad2deg_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rad2deg_out
torch_rad2deg_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rad2deg_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_rand
.torch_rand <- function(size, generator, names, options = list()) {
  args <- mget(x = c("size", "generator", "names", "options"))
expected_types <- list(size = "IntArrayRef", generator = "Generator", names = "DimnameList", 
    options = "TensorOptions")
nd_args <- c("size", "generator", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rand',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_rand_like
.torch_rand_like <- function(self, options = list(), memory_format = NULL) {
  args <- mget(x = c("self", "options", "memory_format"))
expected_types <- list(self = "Tensor", options = "TensorOptions", memory_format = "MemoryFormat")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rand_like',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rand_like_out
torch_rand_like_out <- function(out, self, memory_format = NULL) {
  args <- mget(x = c("out", "self", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", memory_format = "MemoryFormat")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rand_like_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rand_out
torch_rand_out <- function(out, size, generator, names) {
  args <- mget(x = c("out", "size", "generator", "names"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", generator = "Generator", 
    names = "DimnameList")
nd_args <- c("out", "size", "generator", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rand_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_randint
.torch_randint <- function(low, high, size, generator, options = torch_long()) {
  args <- mget(x = c("low", "high", "size", "generator", "options"))
expected_types <- list(low = "int64_t", high = "int64_t", size = "IntArrayRef", 
    generator = "Generator", options = "TensorOptions")
nd_args <- c("low", "high", "size", "generator")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randint',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_randint_like
.torch_randint_like <- function(self, low, high, options = list(), memory_format = NULL) {
  args <- mget(x = c("self", "low", "high", "options", "memory_format"))
expected_types <- list(self = "Tensor", low = "int64_t", high = "int64_t", options = "TensorOptions", 
    memory_format = "MemoryFormat")
nd_args <- c("self", "low", "high")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randint_like',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_randint_like_out
torch_randint_like_out <- function(out, self, low, high, memory_format = NULL) {
  args <- mget(x = c("out", "self", "low", "high", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", low = "int64_t", high = "int64_t", 
    memory_format = "MemoryFormat")
nd_args <- c("out", "self", "low", "high")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randint_like_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_randint_out
torch_randint_out <- function(out, low, high, size, generator) {
  args <- mget(x = c("out", "low", "high", "size", "generator"))
expected_types <- list(out = "Tensor", low = "int64_t", high = "int64_t", size = "IntArrayRef", 
    generator = "Generator")
nd_args <- c("out", "low", "high", "size", "generator")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randint_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_randn
.torch_randn <- function(size, generator, names, options = list()) {
  args <- mget(x = c("size", "generator", "names", "options"))
expected_types <- list(size = "IntArrayRef", generator = "Generator", names = "DimnameList", 
    options = "TensorOptions")
nd_args <- c("size", "generator", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_randn_like
.torch_randn_like <- function(self, options = list(), memory_format = NULL) {
  args <- mget(x = c("self", "options", "memory_format"))
expected_types <- list(self = "Tensor", options = "TensorOptions", memory_format = "MemoryFormat")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randn_like',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_randn_like_out
torch_randn_like_out <- function(out, self, memory_format = NULL) {
  args <- mget(x = c("out", "self", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", memory_format = "MemoryFormat")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randn_like_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_randn_out
torch_randn_out <- function(out, size, generator, names) {
  args <- mget(x = c("out", "size", "generator", "names"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", generator = "Generator", 
    names = "DimnameList")
nd_args <- c("out", "size", "generator", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_random
torch_random <- function(self, from, to, generator = NULL) {
  args <- mget(x = c("self", "from", "to", "generator"))
expected_types <- list(self = "Tensor", from = "int64_t", to = "int64_t", generator = "Generator")
nd_args <- c("self", "from", "to")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'random',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_random_out
torch_random_out <- function(out, self, from, to, generator = NULL) {
  args <- mget(x = c("out", "self", "from", "to", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", from = "int64_t", to = "int64_t", 
    generator = "Generator")
nd_args <- c("out", "self", "from", "to")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'random_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_randperm
.torch_randperm <- function(n, generator, options = torch_long()) {
  args <- mget(x = c("n", "generator", "options"))
expected_types <- list(n = "int64_t", generator = "Generator", options = "TensorOptions")
nd_args <- c("n", "generator")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randperm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_randperm_out
torch_randperm_out <- function(out, n, generator) {
  args <- mget(x = c("out", "n", "generator"))
expected_types <- list(out = "Tensor", n = "int64_t", generator = "Generator")
nd_args <- c("out", "n", "generator")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'randperm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_range
.torch_range <- function(start, end, step = 1L, options = list()) {
  args <- mget(x = c("start", "end", "step", "options"))
expected_types <- list(start = "Scalar", end = "Scalar", step = "Scalar", options = "TensorOptions")
nd_args <- c("start", "end")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'range',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_range_out
torch_range_out <- function(out, start, end, step = 1L) {
  args <- mget(x = c("out", "start", "end", "step"))
expected_types <- list(out = "Tensor", start = "Scalar", end = "Scalar", step = "Scalar")
nd_args <- c("out", "start", "end")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'range_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_ravel
torch_ravel <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'ravel',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_real
torch_real <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'real',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reciprocal
torch_reciprocal <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reciprocal',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reciprocal_
torch_reciprocal_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reciprocal_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reciprocal_out
torch_reciprocal_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reciprocal_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad1d
torch_reflection_pad1d <- function(self, padding) {
  args <- mget(x = c("self", "padding"))
expected_types <- list(self = "Tensor", padding = "IntArrayRef")
nd_args <- c("self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad1d_backward
torch_reflection_pad1d_backward <- function(grad_output, self, padding) {
  args <- mget(x = c("grad_output", "self", "padding"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad1d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad1d_backward_out
torch_reflection_pad1d_backward_out <- function(grad_input, grad_output, self, padding) {
  args <- mget(x = c("grad_input", "grad_output", "self", "padding"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    padding = "IntArrayRef")
nd_args <- c("grad_input", "grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad1d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad1d_out
torch_reflection_pad1d_out <- function(out, self, padding) {
  args <- mget(x = c("out", "self", "padding"))
expected_types <- list(out = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("out", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad1d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad2d
torch_reflection_pad2d <- function(self, padding) {
  args <- mget(x = c("self", "padding"))
expected_types <- list(self = "Tensor", padding = "IntArrayRef")
nd_args <- c("self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad2d_backward
torch_reflection_pad2d_backward <- function(grad_output, self, padding) {
  args <- mget(x = c("grad_output", "self", "padding"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad2d_backward_out
torch_reflection_pad2d_backward_out <- function(grad_input, grad_output, self, padding) {
  args <- mget(x = c("grad_input", "grad_output", "self", "padding"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    padding = "IntArrayRef")
nd_args <- c("grad_input", "grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad2d_out
torch_reflection_pad2d_out <- function(out, self, padding) {
  args <- mget(x = c("out", "self", "padding"))
expected_types <- list(out = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("out", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad3d
torch_reflection_pad3d <- function(self, padding) {
  args <- mget(x = c("self", "padding"))
expected_types <- list(self = "Tensor", padding = "IntArrayRef")
nd_args <- c("self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad3d_backward
torch_reflection_pad3d_backward <- function(grad_output, self, padding) {
  args <- mget(x = c("grad_output", "self", "padding"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad3d_backward_out
torch_reflection_pad3d_backward_out <- function(grad_input, grad_output, self, padding) {
  args <- mget(x = c("grad_input", "grad_output", "self", "padding"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    padding = "IntArrayRef")
nd_args <- c("grad_input", "grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reflection_pad3d_out
torch_reflection_pad3d_out <- function(out, self, padding) {
  args <- mget(x = c("out", "self", "padding"))
expected_types <- list(out = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("out", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reflection_pad3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_relu
torch_relu <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'relu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_relu_
torch_relu_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'relu_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_relu_out
torch_relu_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'relu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_relu6
torch_relu6 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'relu6',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_relu6_
torch_relu6_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'relu6_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_remainder
torch_remainder <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Scalar", "Tensor"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'remainder',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_remainder_out
torch_remainder_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Scalar", 
"Tensor"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'remainder_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_renorm
torch_renorm <- function(self, p, dim, maxnorm) {
  args <- mget(x = c("self", "p", "dim", "maxnorm"))
expected_types <- list(self = "Tensor", p = "Scalar", dim = "int64_t", maxnorm = "Scalar")
nd_args <- c("self", "p", "dim", "maxnorm")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'renorm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_renorm_out
torch_renorm_out <- function(out, self, p, dim, maxnorm) {
  args <- mget(x = c("out", "self", "p", "dim", "maxnorm"))
expected_types <- list(out = "Tensor", self = "Tensor", p = "Scalar", dim = "int64_t", 
    maxnorm = "Scalar")
nd_args <- c("out", "self", "p", "dim", "maxnorm")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'renorm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_repeat_interleave
torch_repeat_interleave <- function(self, repeats, dim = NULL, output_size = NULL) {
  args <- mget(x = c("self", "repeats", "dim", "output_size"))
expected_types <- list(self = "Tensor", repeats = c("Tensor", "int64_t"), dim = "int64_t", 
    output_size = "int64_t")
nd_args <- c("self", "repeats")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'repeat_interleave',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_repeat_interleave_out
torch_repeat_interleave_out <- function(out, repeats, output_size = NULL) {
  args <- mget(x = c("out", "repeats", "output_size"))
expected_types <- list(out = "Tensor", repeats = "Tensor", output_size = "int64_t")
nd_args <- c("out", "repeats")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'repeat_interleave_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_repeat_out
torch_repeat_out <- function(out, self, repeats) {
  args <- mget(x = c("out", "self", "repeats"))
expected_types <- list(out = "Tensor", self = "Tensor", repeats = "IntArrayRef")
nd_args <- c("out", "self", "repeats")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'repeat_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad1d
torch_replication_pad1d <- function(self, padding) {
  args <- mget(x = c("self", "padding"))
expected_types <- list(self = "Tensor", padding = "IntArrayRef")
nd_args <- c("self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad1d_backward
torch_replication_pad1d_backward <- function(grad_output, self, padding) {
  args <- mget(x = c("grad_output", "self", "padding"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad1d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad1d_backward_out
torch_replication_pad1d_backward_out <- function(grad_input, grad_output, self, padding) {
  args <- mget(x = c("grad_input", "grad_output", "self", "padding"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    padding = "IntArrayRef")
nd_args <- c("grad_input", "grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad1d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad1d_out
torch_replication_pad1d_out <- function(out, self, padding) {
  args <- mget(x = c("out", "self", "padding"))
expected_types <- list(out = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("out", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad1d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad2d
torch_replication_pad2d <- function(self, padding) {
  args <- mget(x = c("self", "padding"))
expected_types <- list(self = "Tensor", padding = "IntArrayRef")
nd_args <- c("self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad2d_backward
torch_replication_pad2d_backward <- function(grad_output, self, padding) {
  args <- mget(x = c("grad_output", "self", "padding"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad2d_backward_out
torch_replication_pad2d_backward_out <- function(grad_input, grad_output, self, padding) {
  args <- mget(x = c("grad_input", "grad_output", "self", "padding"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    padding = "IntArrayRef")
nd_args <- c("grad_input", "grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad2d_out
torch_replication_pad2d_out <- function(out, self, padding) {
  args <- mget(x = c("out", "self", "padding"))
expected_types <- list(out = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("out", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad3d
torch_replication_pad3d <- function(self, padding) {
  args <- mget(x = c("self", "padding"))
expected_types <- list(self = "Tensor", padding = "IntArrayRef")
nd_args <- c("self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad3d_backward
torch_replication_pad3d_backward <- function(grad_output, self, padding) {
  args <- mget(x = c("grad_output", "self", "padding"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad3d_backward_out
torch_replication_pad3d_backward_out <- function(grad_input, grad_output, self, padding) {
  args <- mget(x = c("grad_input", "grad_output", "self", "padding"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    padding = "IntArrayRef")
nd_args <- c("grad_input", "grad_output", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_replication_pad3d_out
torch_replication_pad3d_out <- function(out, self, padding) {
  args <- mget(x = c("out", "self", "padding"))
expected_types <- list(out = "Tensor", self = "Tensor", padding = "IntArrayRef")
nd_args <- c("out", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'replication_pad3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_reshape
torch_reshape <- function(self, shape) {
  args <- mget(x = c("self", "shape"))
expected_types <- list(self = "Tensor", shape = "IntArrayRef")
nd_args <- c("self", "shape")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'reshape',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resize
torch_resize <- function(self, size, memory_format = NULL) {
  args <- mget(x = c("self", "size", "memory_format"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", memory_format = "MemoryFormat")
nd_args <- c("self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resize',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resize_as
torch_resize_as <- function(self, the_template, memory_format = NULL) {
  args <- mget(x = c("self", "the_template", "memory_format"))
expected_types <- list(self = "Tensor", the_template = "Tensor", memory_format = "MemoryFormat")
nd_args <- c("self", "the_template")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resize_as',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resize_as_
torch_resize_as_ <- function(self, the_template, memory_format = NULL) {
  args <- mget(x = c("self", "the_template", "memory_format"))
expected_types <- list(self = "Tensor", the_template = "Tensor", memory_format = "MemoryFormat")
nd_args <- c("self", "the_template")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resize_as_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resize_as_out
torch_resize_as_out <- function(out, self, the_template, memory_format = NULL) {
  args <- mget(x = c("out", "self", "the_template", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", the_template = "Tensor", 
    memory_format = "MemoryFormat")
nd_args <- c("out", "self", "the_template")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resize_as_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resize_as_sparse
torch_resize_as_sparse <- function(self, the_template) {
  args <- mget(x = c("self", "the_template"))
expected_types <- list(self = "Tensor", the_template = "Tensor")
nd_args <- c("self", "the_template")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resize_as_sparse',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resize_as_sparse_
torch_resize_as_sparse_ <- function(self, the_template) {
  args <- mget(x = c("self", "the_template"))
expected_types <- list(self = "Tensor", the_template = "Tensor")
nd_args <- c("self", "the_template")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resize_as_sparse_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resize_as_sparse_out
torch_resize_as_sparse_out <- function(out, self, the_template) {
  args <- mget(x = c("out", "self", "the_template"))
expected_types <- list(out = "Tensor", self = "Tensor", the_template = "Tensor")
nd_args <- c("out", "self", "the_template")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resize_as_sparse_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resize_out
torch_resize_out <- function(out, self, size, memory_format = NULL) {
  args <- mget(x = c("out", "self", "size", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef", memory_format = "MemoryFormat")
nd_args <- c("out", "self", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resize_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resolve_conj
torch_resolve_conj <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resolve_conj',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_resolve_neg
torch_resolve_neg <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'resolve_neg',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_result_type
.torch_result_type <- function(scalar, scalar1, other, scalar2, tensor) {
  args <- mget(x = c("scalar", "scalar1", "other", "scalar2", "tensor"))
expected_types <- list(scalar = "Scalar", scalar1 = "Scalar", other = c("Tensor", 
"Scalar"), scalar2 = "Scalar", tensor = "Tensor")
nd_args <- c("scalar", "scalar1", "other", "scalar2", "tensor")
return_types <- list(list('ScalarType'))
call_c_function(
fun_name = 'result_type',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rnn_relu
torch_rnn_relu <- function(data, input, batch_sizes, hx, params, has_biases, num_layers, dropout, train, batch_first, bidirectional) {
  args <- mget(x = c("data", "input", "batch_sizes", "hx", "params", "has_biases", "num_layers", "dropout", "train", "batch_first", "bidirectional"))
expected_types <- list(data = "Tensor", input = "Tensor", batch_sizes = "Tensor", 
    hx = "Tensor", params = "TensorList", has_biases = "bool", 
    num_layers = "int64_t", dropout = "double", train = "bool", 
    batch_first = "bool", bidirectional = "bool")
nd_args <- c("data", "input", "batch_sizes", "hx", "params", "has_biases", 
"num_layers", "dropout", "train", "batch_first", "bidirectional"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'rnn_relu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rnn_relu_cell
torch_rnn_relu_cell <- function(input, hx, w_ih, w_hh, b_ih = list(), b_hh = list()) {
  args <- mget(x = c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh"))
expected_types <- list(input = "Tensor", hx = "Tensor", w_ih = "Tensor", w_hh = "Tensor", 
    b_ih = "Tensor", b_hh = "Tensor")
nd_args <- c("input", "hx", "w_ih", "w_hh")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rnn_relu_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rnn_tanh
torch_rnn_tanh <- function(data, input, batch_sizes, hx, params, has_biases, num_layers, dropout, train, batch_first, bidirectional) {
  args <- mget(x = c("data", "input", "batch_sizes", "hx", "params", "has_biases", "num_layers", "dropout", "train", "batch_first", "bidirectional"))
expected_types <- list(data = "Tensor", input = "Tensor", batch_sizes = "Tensor", 
    hx = "Tensor", params = "TensorList", has_biases = "bool", 
    num_layers = "int64_t", dropout = "double", train = "bool", 
    batch_first = "bool", bidirectional = "bool")
nd_args <- c("data", "input", "batch_sizes", "hx", "params", "has_biases", 
"num_layers", "dropout", "train", "batch_first", "bidirectional"
)
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'rnn_tanh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rnn_tanh_cell
torch_rnn_tanh_cell <- function(input, hx, w_ih, w_hh, b_ih = list(), b_hh = list()) {
  args <- mget(x = c("input", "hx", "w_ih", "w_hh", "b_ih", "b_hh"))
expected_types <- list(input = "Tensor", hx = "Tensor", w_ih = "Tensor", w_hh = "Tensor", 
    b_ih = "Tensor", b_hh = "Tensor")
nd_args <- c("input", "hx", "w_ih", "w_hh")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rnn_tanh_cell',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_roll
torch_roll <- function(self, shifts, dims = list()) {
  args <- mget(x = c("self", "shifts", "dims"))
expected_types <- list(self = "Tensor", shifts = "IntArrayRef", dims = "IntArrayRef")
nd_args <- c("self", "shifts")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'roll',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_roll_out
torch_roll_out <- function(out, self, shifts, dims = list()) {
  args <- mget(x = c("out", "self", "shifts", "dims"))
expected_types <- list(out = "Tensor", self = "Tensor", shifts = "IntArrayRef", 
    dims = "IntArrayRef")
nd_args <- c("out", "self", "shifts")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'roll_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rot90
torch_rot90 <- function(self, k = 1L, dims = c(0,1)) {
  args <- mget(x = c("self", "k", "dims"))
expected_types <- list(self = "Tensor", k = "int64_t", dims = "IntArrayRef")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rot90',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rot90_out
torch_rot90_out <- function(out, self, k = 1L, dims = c(0,1)) {
  args <- mget(x = c("out", "self", "k", "dims"))
expected_types <- list(out = "Tensor", self = "Tensor", k = "int64_t", dims = "IntArrayRef")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rot90_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_round
torch_round <- function(self, decimals) {
  args <- mget(x = c("self", "decimals"))
expected_types <- list(self = "Tensor", decimals = "int64_t")
nd_args <- c("self", "decimals")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'round',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_round_
torch_round_ <- function(self, decimals) {
  args <- mget(x = c("self", "decimals"))
expected_types <- list(self = "Tensor", decimals = "int64_t")
nd_args <- c("self", "decimals")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'round_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_round_out
torch_round_out <- function(out, self, decimals) {
  args <- mget(x = c("out", "self", "decimals"))
expected_types <- list(out = "Tensor", self = "Tensor", decimals = "int64_t")
nd_args <- c("out", "self", "decimals")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'round_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_row_indices_copy
torch_row_indices_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'row_indices_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_row_indices_copy_out
torch_row_indices_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'row_indices_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_row_stack
torch_row_stack <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'row_stack',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_row_stack_out
torch_row_stack_out <- function(out, tensors) {
  args <- mget(x = c("out", "tensors"))
expected_types <- list(out = "Tensor", tensors = "TensorList")
nd_args <- c("out", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'row_stack_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rrelu
torch_rrelu <- function(self, lower = 0.125, upper = 0.333333333333333, training = FALSE, generator = NULL) {
  args <- mget(x = c("self", "lower", "upper", "training", "generator"))
expected_types <- list(self = "Tensor", lower = "Scalar", upper = "Scalar", training = "bool", 
    generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rrelu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rrelu_
torch_rrelu_ <- function(self, lower = 0.125, upper = 0.333333333333333, training = FALSE, generator = NULL) {
  args <- mget(x = c("self", "lower", "upper", "training", "generator"))
expected_types <- list(self = "Tensor", lower = "Scalar", upper = "Scalar", training = "bool", 
    generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rrelu_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rrelu_with_noise
torch_rrelu_with_noise <- function(self, noise, lower = 0.125, upper = 0.333333333333333, training = FALSE, generator = NULL) {
  args <- mget(x = c("self", "noise", "lower", "upper", "training", "generator"))
expected_types <- list(self = "Tensor", noise = "Tensor", lower = "Scalar", upper = "Scalar", 
    training = "bool", generator = "Generator")
nd_args <- c("self", "noise")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rrelu_with_noise',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rrelu_with_noise_
torch_rrelu_with_noise_ <- function(self, noise, lower = 0.125, upper = 0.333333333333333, training = FALSE, generator = NULL) {
  args <- mget(x = c("self", "noise", "lower", "upper", "training", "generator"))
expected_types <- list(self = "Tensor", noise = "Tensor", lower = "Scalar", upper = "Scalar", 
    training = "bool", generator = "Generator")
nd_args <- c("self", "noise")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rrelu_with_noise_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rrelu_with_noise_backward
torch_rrelu_with_noise_backward <- function(grad_output, self, noise, lower, upper, training, self_is_result) {
  args <- mget(x = c("grad_output", "self", "noise", "lower", "upper", "training", "self_is_result"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", noise = "Tensor", 
    lower = "Scalar", upper = "Scalar", training = "bool", self_is_result = "bool")
nd_args <- c("grad_output", "self", "noise", "lower", "upper", "training", 
"self_is_result")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rrelu_with_noise_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rrelu_with_noise_backward_out
torch_rrelu_with_noise_backward_out <- function(out, grad_output, self, noise, lower, upper, training, self_is_result) {
  args <- mget(x = c("out", "grad_output", "self", "noise", "lower", "upper", "training", "self_is_result"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", self = "Tensor", 
    noise = "Tensor", lower = "Scalar", upper = "Scalar", training = "bool", 
    self_is_result = "bool")
nd_args <- c("out", "grad_output", "self", "noise", "lower", "upper", "training", 
"self_is_result")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rrelu_with_noise_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rrelu_with_noise_out
torch_rrelu_with_noise_out <- function(out, self, noise, lower = 0.125, upper = 0.333333333333333, training = FALSE, generator = NULL) {
  args <- mget(x = c("out", "self", "noise", "lower", "upper", "training", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", noise = "Tensor", lower = "Scalar", 
    upper = "Scalar", training = "bool", generator = "Generator")
nd_args <- c("out", "self", "noise")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rrelu_with_noise_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rsqrt
torch_rsqrt <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rsqrt',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rsqrt_
torch_rsqrt_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rsqrt_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rsqrt_out
torch_rsqrt_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rsqrt_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rsub
torch_rsub <- function(self, other, alpha = 1L) {
  args <- mget(x = c("self", "other", "alpha"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"), alpha = "Scalar")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rsub',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_rsub_out
torch_rsub_out <- function(out, self, other, alpha = 1L) {
  args <- mget(x = c("out", "self", "other", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Tensor", "Scalar"
), alpha = "Scalar")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'rsub_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_scalar_tensor
.torch_scalar_tensor <- function(s, options = list()) {
  args <- mget(x = c("s", "options"))
expected_types <- list(s = "Scalar", options = "TensorOptions")
nd_args <- "s"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'scalar_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_scalar_tensor_out
torch_scalar_tensor_out <- function(out, s) {
  args <- mget(x = c("out", "s"))
expected_types <- list(out = "Tensor", s = "Scalar")
nd_args <- c("out", "s")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'scalar_tensor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_scaled_dot_product_attention
torch_scaled_dot_product_attention <- function(query, key, value, attn_mask = list(), dropout_p = 0L, is_causal = FALSE) {
  args <- mget(x = c("query", "key", "value", "attn_mask", "dropout_p", "is_causal"))
expected_types <- list(query = "Tensor", key = "Tensor", value = "Tensor", attn_mask = "Tensor", 
    dropout_p = "double", is_causal = "bool")
nd_args <- c("query", "key", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'scaled_dot_product_attention',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_scatter
torch_scatter <- function(self, dim, index, src, value, reduce) {
  args <- mget(x = c("self", "dim", "index", "src", "value", "reduce"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), index = "Tensor", 
    src = "Tensor", value = "Scalar", reduce = "c10::string_view")
nd_args <- c("self", "dim", "index", "src", "value", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'scatter',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_scatter_add
torch_scatter_add <- function(self, dim, index, src) {
  args <- mget(x = c("self", "dim", "index", "src"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), index = "Tensor", 
    src = "Tensor")
nd_args <- c("self", "dim", "index", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'scatter_add',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_scatter_add_out
torch_scatter_add_out <- function(out, self, dim, index, src) {
  args <- mget(x = c("out", "self", "dim", "index", "src"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", index = "Tensor", 
    src = "Tensor")
nd_args <- c("out", "self", "dim", "index", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'scatter_add_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_scatter_out
torch_scatter_out <- function(out, self, dim, index, src, value, reduce) {
  args <- mget(x = c("out", "self", "dim", "index", "src", "value", "reduce"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", index = "Tensor", 
    src = "Tensor", value = "Scalar", reduce = "c10::string_view")
nd_args <- c("out", "self", "dim", "index", "src", "value", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'scatter_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_scatter_reduce
torch_scatter_reduce <- function(self, dim, index, src, reduce, include_self = TRUE) {
  args <- mget(x = c("self", "dim", "index", "src", "reduce", "include_self"))
expected_types <- list(self = "Tensor", dim = "int64_t", index = "Tensor", src = "Tensor", 
    reduce = "c10::string_view", include_self = "bool")
nd_args <- c("self", "dim", "index", "src", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'scatter_reduce',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_scatter_reduce_out
torch_scatter_reduce_out <- function(out, self, dim, index, src, reduce, include_self = TRUE) {
  args <- mget(x = c("out", "self", "dim", "index", "src", "reduce", "include_self"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", index = "Tensor", 
    src = "Tensor", reduce = "c10::string_view", include_self = "bool")
nd_args <- c("out", "self", "dim", "index", "src", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'scatter_reduce_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_searchsorted
torch_searchsorted <- function(sorted_sequence, self, out_int32 = FALSE, right = FALSE, side = NULL, sorter = list()) {
  args <- mget(x = c("sorted_sequence", "self", "out_int32", "right", "side", "sorter"))
expected_types <- list(sorted_sequence = "Tensor", self = c("Tensor", "Scalar"), 
    out_int32 = "bool", right = "bool", side = "c10::string_view", 
    sorter = "Tensor")
nd_args <- c("sorted_sequence", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'searchsorted',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_searchsorted_out
torch_searchsorted_out <- function(out, sorted_sequence, self, out_int32 = FALSE, right = FALSE, side = NULL, sorter = list()) {
  args <- mget(x = c("out", "sorted_sequence", "self", "out_int32", "right", "side", "sorter"))
expected_types <- list(out = "Tensor", sorted_sequence = "Tensor", self = c("Tensor", 
"Scalar"), out_int32 = "bool", right = "bool", side = "c10::string_view", 
    sorter = "Tensor")
nd_args <- c("out", "sorted_sequence", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'searchsorted_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_segment_reduce
torch_segment_reduce <- function(data, reduce, lengths = list(), indices = list(), offsets = list(), axis = 0L, unsafe = FALSE, initial = NULL) {
  args <- mget(x = c("data", "reduce", "lengths", "indices", "offsets", "axis", "unsafe", "initial"))
expected_types <- list(data = "Tensor", reduce = "c10::string_view", lengths = "Tensor", 
    indices = "Tensor", offsets = "Tensor", axis = "int64_t", 
    unsafe = "bool", initial = "Scalar")
nd_args <- c("data", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'segment_reduce',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_segment_reduce_out
torch_segment_reduce_out <- function(out, data, reduce, lengths = list(), indices = list(), offsets = list(), axis = 0L, unsafe = FALSE, initial = NULL) {
  args <- mget(x = c("out", "data", "reduce", "lengths", "indices", "offsets", "axis", "unsafe", "initial"))
expected_types <- list(out = "Tensor", data = "Tensor", reduce = "c10::string_view", 
    lengths = "Tensor", indices = "Tensor", offsets = "Tensor", 
    axis = "int64_t", unsafe = "bool", initial = "Scalar")
nd_args <- c("out", "data", "reduce")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'segment_reduce_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_select
torch_select <- function(self, dim, index) {
  args <- mget(x = c("self", "dim", "index"))
expected_types <- list(self = "Tensor", dim = c("Dimname", "int64_t"), index = "int64_t")
nd_args <- c("self", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'select',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_select_backward
torch_select_backward <- function(grad_output, input_sizes, dim, index) {
  args <- mget(x = c("grad_output", "input_sizes", "dim", "index"))
expected_types <- list(grad_output = "Tensor", input_sizes = "IntArrayRef", dim = "int64_t", 
    index = "int64_t")
nd_args <- c("grad_output", "input_sizes", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'select_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_select_backward_out
torch_select_backward_out <- function(out, grad_output, input_sizes, dim, index) {
  args <- mget(x = c("out", "grad_output", "input_sizes", "dim", "index"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", input_sizes = "IntArrayRef", 
    dim = "int64_t", index = "int64_t")
nd_args <- c("out", "grad_output", "input_sizes", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'select_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_select_copy
torch_select_copy <- function(self, dim, index) {
  args <- mget(x = c("self", "dim", "index"))
expected_types <- list(self = "Tensor", dim = "int64_t", index = "int64_t")
nd_args <- c("self", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'select_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_select_copy_out
torch_select_copy_out <- function(out, self, dim, index) {
  args <- mget(x = c("out", "self", "dim", "index"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", index = "int64_t")
nd_args <- c("out", "self", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'select_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_select_scatter
torch_select_scatter <- function(self, src, dim, index) {
  args <- mget(x = c("self", "src", "dim", "index"))
expected_types <- list(self = "Tensor", src = "Tensor", dim = "int64_t", index = "int64_t")
nd_args <- c("self", "src", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'select_scatter',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_select_scatter_out
torch_select_scatter_out <- function(out, self, src, dim, index) {
  args <- mget(x = c("out", "self", "src", "dim", "index"))
expected_types <- list(out = "Tensor", self = "Tensor", src = "Tensor", dim = "int64_t", 
    index = "int64_t")
nd_args <- c("out", "self", "src", "dim", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'select_scatter_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_selu
torch_selu <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'selu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_selu_
torch_selu_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'selu_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_set
torch_set <- function(self, source, storage_offset, size, stride = list()) {
  args <- mget(x = c("self", "source", "storage_offset", "size", "stride"))
expected_types <- list(self = "Tensor", source = c("Storage", "Tensor"), storage_offset = "int64_t", 
    size = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("self", "source", "storage_offset", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'set',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_set_out
torch_set_out <- function(out, self, source, storage_offset, size, stride = list()) {
  args <- mget(x = c("out", "self", "source", "storage_offset", "size", "stride"))
expected_types <- list(out = "Tensor", self = "Tensor", source = c("Storage", "Tensor"
), storage_offset = "int64_t", size = "IntArrayRef", stride = "IntArrayRef")
nd_args <- c("out", "self", "source", "storage_offset", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'set_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sgn
torch_sgn <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sgn',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sgn_out
torch_sgn_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sgn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sigmoid
torch_sigmoid <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sigmoid',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sigmoid_
torch_sigmoid_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sigmoid_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sigmoid_backward
torch_sigmoid_backward <- function(grad_output, output) {
  args <- mget(x = c("grad_output", "output"))
expected_types <- list(grad_output = "Tensor", output = "Tensor")
nd_args <- c("grad_output", "output")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sigmoid_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sigmoid_backward_out
torch_sigmoid_backward_out <- function(grad_input, grad_output, output) {
  args <- mget(x = c("grad_input", "grad_output", "output"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output = "Tensor")
nd_args <- c("grad_input", "grad_output", "output")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sigmoid_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sigmoid_out
torch_sigmoid_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sigmoid_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sign
torch_sign <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sign',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sign_out
torch_sign_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sign_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_signbit
torch_signbit <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'signbit',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_signbit_out
torch_signbit_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'signbit_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_silu
torch_silu <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'silu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_silu_
torch_silu_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'silu_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_silu_backward
torch_silu_backward <- function(grad_output, self) {
  args <- mget(x = c("grad_output", "self"))
expected_types <- list(grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'silu_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_silu_backward_out
torch_silu_backward_out <- function(grad_input, grad_output, self) {
  args <- mget(x = c("grad_input", "grad_output", "self"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor")
nd_args <- c("grad_input", "grad_output", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'silu_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_silu_out
torch_silu_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'silu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sin
torch_sin <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sin',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sin_
torch_sin_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sin_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sin_out
torch_sin_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sin_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sinc
torch_sinc <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sinc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sinc_
torch_sinc_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sinc_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sinc_out
torch_sinc_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sinc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sinh
torch_sinh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sinh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sinh_
torch_sinh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sinh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sinh_out
torch_sinh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sinh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_size
torch_size <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"))
nd_args <- c("self", "dim")
return_types <- list(list('int64_t'))
call_c_function(
fun_name = 'size',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slice
torch_slice <- function(self, dim = 1L, start = NULL, end = NULL, step = 1L) {
  args <- mget(x = c("self", "dim", "start", "end", "step"))
expected_types <- list(self = "Tensor", dim = "int64_t", start = "int64_t", end = "int64_t", 
    step = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slice',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slice_backward
torch_slice_backward <- function(grad_output, input_sizes, dim, start, end, step) {
  args <- mget(x = c("grad_output", "input_sizes", "dim", "start", "end", "step"))
expected_types <- list(grad_output = "Tensor", input_sizes = "IntArrayRef", dim = "int64_t", 
    start = "int64_t", end = "int64_t", step = "int64_t")
nd_args <- c("grad_output", "input_sizes", "dim", "start", "end", "step"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slice_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slice_backward_out
torch_slice_backward_out <- function(out, grad_output, input_sizes, dim, start, end, step) {
  args <- mget(x = c("out", "grad_output", "input_sizes", "dim", "start", "end", "step"))
expected_types <- list(out = "Tensor", grad_output = "Tensor", input_sizes = "IntArrayRef", 
    dim = "int64_t", start = "int64_t", end = "int64_t", step = "int64_t")
nd_args <- c("out", "grad_output", "input_sizes", "dim", "start", "end", 
"step")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slice_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slice_copy
torch_slice_copy <- function(self, dim = 1L, start = NULL, end = NULL, step = 1L) {
  args <- mget(x = c("self", "dim", "start", "end", "step"))
expected_types <- list(self = "Tensor", dim = "int64_t", start = "int64_t", end = "int64_t", 
    step = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slice_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slice_copy_out
torch_slice_copy_out <- function(out, self, dim = 1L, start = NULL, end = NULL, step = 1L) {
  args <- mget(x = c("out", "self", "dim", "start", "end", "step"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", start = "int64_t", 
    end = "int64_t", step = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slice_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slice_scatter
torch_slice_scatter <- function(self, src, dim = 1L, start = NULL, end = NULL, step = 1L) {
  args <- mget(x = c("self", "src", "dim", "start", "end", "step"))
expected_types <- list(self = "Tensor", src = "Tensor", dim = "int64_t", start = "int64_t", 
    end = "int64_t", step = "int64_t")
nd_args <- c("self", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slice_scatter',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slice_scatter_out
torch_slice_scatter_out <- function(out, self, src, dim = 1L, start = NULL, end = NULL, step = 1L) {
  args <- mget(x = c("out", "self", "src", "dim", "start", "end", "step"))
expected_types <- list(out = "Tensor", self = "Tensor", src = "Tensor", dim = "int64_t", 
    start = "int64_t", end = "int64_t", step = "int64_t")
nd_args <- c("out", "self", "src")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slice_scatter_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slogdet
torch_slogdet <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'slogdet',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slogdet_out
torch_slogdet_out <- function(sign, logabsdet, self) {
  args <- mget(x = c("sign", "logabsdet", "self"))
expected_types <- list(sign = "Tensor", logabsdet = "Tensor", self = "Tensor")
nd_args <- c("sign", "logabsdet", "self")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'slogdet_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv_dilated2d
torch_slow_conv_dilated2d <- function(self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L, dilation = 1L) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding", "dilation"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv_dilated2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv_dilated2d_out
torch_slow_conv_dilated2d_out <- function(out, self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L, dilation = 1L) {
  args <- mget(x = c("out", "self", "weight", "kernel_size", "bias", "stride", "padding", "dilation"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef")
nd_args <- c("out", "self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv_dilated2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv_dilated3d
torch_slow_conv_dilated3d <- function(self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L, dilation = 1L) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding", "dilation"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv_dilated3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv_dilated3d_out
torch_slow_conv_dilated3d_out <- function(out, self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L, dilation = 1L) {
  args <- mget(x = c("out", "self", "weight", "kernel_size", "bias", "stride", "padding", "dilation"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    dilation = "IntArrayRef")
nd_args <- c("out", "self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv_dilated3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv_transpose2d
torch_slow_conv_transpose2d <- function(self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L, output_padding = 0L, dilation = 1L) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding", "output_padding", "dilation"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    output_padding = "IntArrayRef", dilation = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv_transpose2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv_transpose2d_out
torch_slow_conv_transpose2d_out <- function(out, self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L, output_padding = 0L, dilation = 1L) {
  args <- mget(x = c("out", "self", "weight", "kernel_size", "bias", "stride", "padding", "output_padding", "dilation"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    output_padding = "IntArrayRef", dilation = "IntArrayRef")
nd_args <- c("out", "self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv_transpose2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv_transpose3d
torch_slow_conv_transpose3d <- function(self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L, output_padding = 0L, dilation = 1L) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding", "output_padding", "dilation"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    output_padding = "IntArrayRef", dilation = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv_transpose3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv_transpose3d_out
torch_slow_conv_transpose3d_out <- function(out, self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L, output_padding = 0L, dilation = 1L) {
  args <- mget(x = c("out", "self", "weight", "kernel_size", "bias", "stride", "padding", "output_padding", "dilation"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef", 
    output_padding = "IntArrayRef", dilation = "IntArrayRef")
nd_args <- c("out", "self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv_transpose3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv3d
torch_slow_conv3d <- function(self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv3d_forward
torch_slow_conv3d_forward <- function(self, weight, kernel_size, bias, stride, padding) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size", "bias", "stride", "padding"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv3d_forward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv3d_forward_out
torch_slow_conv3d_forward_out <- function(output, self, weight, kernel_size, bias, stride, padding) {
  args <- mget(x = c("output", "self", "weight", "kernel_size", "bias", "stride", "padding"))
expected_types <- list(output = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("output", "self", "weight", "kernel_size", "bias", "stride", 
"padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv3d_forward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_slow_conv3d_out
torch_slow_conv3d_out <- function(out, self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L) {
  args <- mget(x = c("out", "self", "weight", "kernel_size", "bias", "stride", "padding"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("out", "self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'slow_conv3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_smm
torch_smm <- function(self, mat2) {
  args <- mget(x = c("self", "mat2"))
expected_types <- list(self = "Tensor", mat2 = "Tensor")
nd_args <- c("self", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'smm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_smooth_l1_loss
torch_smooth_l1_loss <- function(self, target, reduction = torch_reduction_mean(), beta = 1L) {
  args <- mget(x = c("self", "target", "reduction", "beta"))
expected_types <- list(self = "Tensor", target = "Tensor", reduction = "int64_t", 
    beta = "double")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'smooth_l1_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_smooth_l1_loss_backward
torch_smooth_l1_loss_backward <- function(grad_output, self, target, reduction, beta) {
  args <- mget(x = c("grad_output", "self", "target", "reduction", "beta"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", target = "Tensor", 
    reduction = "int64_t", beta = "double")
nd_args <- c("grad_output", "self", "target", "reduction", "beta")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'smooth_l1_loss_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_smooth_l1_loss_backward_out
torch_smooth_l1_loss_backward_out <- function(grad_input, grad_output, self, target, reduction, beta) {
  args <- mget(x = c("grad_input", "grad_output", "self", "target", "reduction", "beta"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    target = "Tensor", reduction = "int64_t", beta = "double")
nd_args <- c("grad_input", "grad_output", "self", "target", "reduction", 
"beta")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'smooth_l1_loss_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_smooth_l1_loss_out
torch_smooth_l1_loss_out <- function(out, self, target, reduction = torch_reduction_mean(), beta = 1L) {
  args <- mget(x = c("out", "self", "target", "reduction", "beta"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", reduction = "int64_t", 
    beta = "double")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'smooth_l1_loss_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_soft_margin_loss
torch_soft_margin_loss <- function(self, target, reduction = torch_reduction_mean()) {
  args <- mget(x = c("self", "target", "reduction"))
expected_types <- list(self = "Tensor", target = "Tensor", reduction = "int64_t")
nd_args <- c("self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'soft_margin_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_soft_margin_loss_backward
torch_soft_margin_loss_backward <- function(grad_output, self, target, reduction) {
  args <- mget(x = c("grad_output", "self", "target", "reduction"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", target = "Tensor", 
    reduction = "int64_t")
nd_args <- c("grad_output", "self", "target", "reduction")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'soft_margin_loss_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_soft_margin_loss_backward_out
torch_soft_margin_loss_backward_out <- function(grad_input, grad_output, self, target, reduction) {
  args <- mget(x = c("grad_input", "grad_output", "self", "target", "reduction"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    target = "Tensor", reduction = "int64_t")
nd_args <- c("grad_input", "grad_output", "self", "target", "reduction")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'soft_margin_loss_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_soft_margin_loss_out
torch_soft_margin_loss_out <- function(out, self, target, reduction = torch_reduction_mean()) {
  args <- mget(x = c("out", "self", "target", "reduction"))
expected_types <- list(out = "Tensor", self = "Tensor", target = "Tensor", reduction = "int64_t")
nd_args <- c("out", "self", "target")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'soft_margin_loss_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softmax
torch_softmax <- function(self, dim, dtype = NULL) {
  args <- mget(x = c("self", "dim", "dtype"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softmax_out
torch_softmax_out <- function(out, self, dim, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t", dtype = "ScalarType")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softmax_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softplus
torch_softplus <- function(self, beta = 1L, threshold = 20L) {
  args <- mget(x = c("self", "beta", "threshold"))
expected_types <- list(self = "Tensor", beta = "Scalar", threshold = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softplus',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softplus_backward
torch_softplus_backward <- function(grad_output, self, beta, threshold) {
  args <- mget(x = c("grad_output", "self", "beta", "threshold"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", beta = "Scalar", 
    threshold = "Scalar")
nd_args <- c("grad_output", "self", "beta", "threshold")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softplus_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softplus_backward_out
torch_softplus_backward_out <- function(grad_input, grad_output, self, beta, threshold) {
  args <- mget(x = c("grad_input", "grad_output", "self", "beta", "threshold"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    beta = "Scalar", threshold = "Scalar")
nd_args <- c("grad_input", "grad_output", "self", "beta", "threshold")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softplus_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softplus_out
torch_softplus_out <- function(out, self, beta = 1L, threshold = 20L) {
  args <- mget(x = c("out", "self", "beta", "threshold"))
expected_types <- list(out = "Tensor", self = "Tensor", beta = "Scalar", threshold = "Scalar")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softplus_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softshrink
torch_softshrink <- function(self, lambd = 0.5) {
  args <- mget(x = c("self", "lambd"))
expected_types <- list(self = "Tensor", lambd = "Scalar")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softshrink',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softshrink_backward
torch_softshrink_backward <- function(grad_output, self, lambd) {
  args <- mget(x = c("grad_output", "self", "lambd"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", lambd = "Scalar")
nd_args <- c("grad_output", "self", "lambd")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softshrink_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softshrink_backward_out
torch_softshrink_backward_out <- function(grad_input, grad_output, self, lambd) {
  args <- mget(x = c("grad_input", "grad_output", "self", "lambd"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    lambd = "Scalar")
nd_args <- c("grad_input", "grad_output", "self", "lambd")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softshrink_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_softshrink_out
torch_softshrink_out <- function(out, self, lambd = 0.5) {
  args <- mget(x = c("out", "self", "lambd"))
expected_types <- list(out = "Tensor", self = "Tensor", lambd = "Scalar")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'softshrink_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_sort
.torch_sort <- function(self, dim = -1L, descending = FALSE, stable) {
  args <- mget(x = c("self", "dim", "descending", "stable"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), descending = "bool", 
    stable = "bool")
nd_args <- c("self", "dim", "stable")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'sort',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sort_out
torch_sort_out <- function(values, indices, self, stable, dim = -1L, descending = FALSE) {
  args <- mget(x = c("values", "indices", "self", "stable", "dim", "descending"))
expected_types <- list(values = "Tensor", indices = "Tensor", self = "Tensor", 
    stable = "bool", dim = c("int64_t", "Dimname"), descending = "bool")
nd_args <- c("values", "indices", "self", "stable", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'sort_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_bsc_tensor
torch_sparse_bsc_tensor <- function(ccol_indices, row_indices, values, size, options) {
  args <- mget(x = c("ccol_indices", "row_indices", "values", "size", "options"))
expected_types <- list(ccol_indices = "Tensor", row_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("ccol_indices", "row_indices", "values", "size", "options")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_bsc_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_bsr_tensor
torch_sparse_bsr_tensor <- function(crow_indices, col_indices, values, size, options) {
  args <- mget(x = c("crow_indices", "col_indices", "values", "size", "options"))
expected_types <- list(crow_indices = "Tensor", col_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("crow_indices", "col_indices", "values", "size", "options")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_bsr_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_compressed_tensor
torch_sparse_compressed_tensor <- function(compressed_indices, plain_indices, values, size, options) {
  args <- mget(x = c("compressed_indices", "plain_indices", "values", "size", "options"))
expected_types <- list(compressed_indices = "Tensor", plain_indices = "Tensor", 
    values = "Tensor", size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("compressed_indices", "plain_indices", "values", "size", "options"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_compressed_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_sparse_coo_tensor
.torch_sparse_coo_tensor <- function(indices, values, size, options = list()) {
  args <- mget(x = c("indices", "values", "size", "options"))
expected_types <- list(indices = "Tensor", values = "Tensor", size = "IntArrayRef", 
    options = "TensorOptions")
nd_args <- c("indices", "values", "size", "options")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_coo_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_coo_tensor_out
torch_sparse_coo_tensor_out <- function(out, size) {
  args <- mget(x = c("out", "size"))
expected_types <- list(out = "Tensor", size = "IntArrayRef")
nd_args <- c("out", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_coo_tensor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_csc_tensor
torch_sparse_csc_tensor <- function(ccol_indices, row_indices, values, size, options) {
  args <- mget(x = c("ccol_indices", "row_indices", "values", "size", "options"))
expected_types <- list(ccol_indices = "Tensor", row_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("ccol_indices", "row_indices", "values", "size", "options")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_csc_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_csr_tensor
torch_sparse_csr_tensor <- function(crow_indices, col_indices, values, size, options) {
  args <- mget(x = c("crow_indices", "col_indices", "values", "size", "options"))
expected_types <- list(crow_indices = "Tensor", col_indices = "Tensor", values = "Tensor", 
    size = "IntArrayRef", options = "TensorOptions")
nd_args <- c("crow_indices", "col_indices", "values", "size", "options")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_csr_tensor',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_mask_out
torch_sparse_mask_out <- function(out, self, mask) {
  args <- mget(x = c("out", "self", "mask"))
expected_types <- list(out = "Tensor", self = "Tensor", mask = "Tensor")
nd_args <- c("out", "self", "mask")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_mask_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_resize
torch_sparse_resize <- function(self, size, sparse_dim, dense_dim) {
  args <- mget(x = c("self", "size", "sparse_dim", "dense_dim"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", sparse_dim = "int64_t", 
    dense_dim = "int64_t")
nd_args <- c("self", "size", "sparse_dim", "dense_dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_resize',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_resize_and_clear
torch_sparse_resize_and_clear <- function(self, size, sparse_dim, dense_dim) {
  args <- mget(x = c("self", "size", "sparse_dim", "dense_dim"))
expected_types <- list(self = "Tensor", size = "IntArrayRef", sparse_dim = "int64_t", 
    dense_dim = "int64_t")
nd_args <- c("self", "size", "sparse_dim", "dense_dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_resize_and_clear',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_resize_and_clear_out
torch_sparse_resize_and_clear_out <- function(out, self, size, sparse_dim, dense_dim) {
  args <- mget(x = c("out", "self", "size", "sparse_dim", "dense_dim"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef", sparse_dim = "int64_t", 
    dense_dim = "int64_t")
nd_args <- c("out", "self", "size", "sparse_dim", "dense_dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_resize_and_clear_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_resize_out
torch_sparse_resize_out <- function(out, self, size, sparse_dim, dense_dim) {
  args <- mget(x = c("out", "self", "size", "sparse_dim", "dense_dim"))
expected_types <- list(out = "Tensor", self = "Tensor", size = "IntArrayRef", sparse_dim = "int64_t", 
    dense_dim = "int64_t")
nd_args <- c("out", "self", "size", "sparse_dim", "dense_dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_resize_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_sampled_addmm
torch_sparse_sampled_addmm <- function(self, mat1, mat2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("self", "mat1", "mat2", "beta", "alpha"))
expected_types <- list(self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", beta = "Scalar", 
    alpha = "Scalar")
nd_args <- c("self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_sampled_addmm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sparse_sampled_addmm_out
torch_sparse_sampled_addmm_out <- function(out, self, mat1, mat2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("out", "self", "mat1", "mat2", "beta", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", 
    beta = "Scalar", alpha = "Scalar")
nd_args <- c("out", "self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sparse_sampled_addmm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_airy_ai
torch_special_airy_ai <- function(x) {
  args <- mget(x = c("x"))
expected_types <- list(x = "Tensor")
nd_args <- "x"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_airy_ai',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_airy_ai_out
torch_special_airy_ai_out <- function(out, x) {
  args <- mget(x = c("out", "x"))
expected_types <- list(out = "Tensor", x = "Tensor")
nd_args <- c("out", "x")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_airy_ai_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_bessel_j0
torch_special_bessel_j0 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_bessel_j0',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_bessel_j0_out
torch_special_bessel_j0_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_bessel_j0_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_bessel_j1
torch_special_bessel_j1 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_bessel_j1',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_bessel_j1_out
torch_special_bessel_j1_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_bessel_j1_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_bessel_y0
torch_special_bessel_y0 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_bessel_y0',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_bessel_y0_out
torch_special_bessel_y0_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_bessel_y0_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_bessel_y1
torch_special_bessel_y1 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_bessel_y1',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_bessel_y1_out
torch_special_bessel_y1_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_bessel_y1_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_chebyshev_polynomial_t
torch_special_chebyshev_polynomial_t <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_chebyshev_polynomial_t',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_chebyshev_polynomial_t_out
torch_special_chebyshev_polynomial_t_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_chebyshev_polynomial_t_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_chebyshev_polynomial_u
torch_special_chebyshev_polynomial_u <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_chebyshev_polynomial_u',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_chebyshev_polynomial_u_out
torch_special_chebyshev_polynomial_u_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_chebyshev_polynomial_u_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_chebyshev_polynomial_v
torch_special_chebyshev_polynomial_v <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_chebyshev_polynomial_v',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_chebyshev_polynomial_v_out
torch_special_chebyshev_polynomial_v_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_chebyshev_polynomial_v_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_chebyshev_polynomial_w
torch_special_chebyshev_polynomial_w <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_chebyshev_polynomial_w',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_chebyshev_polynomial_w_out
torch_special_chebyshev_polynomial_w_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_chebyshev_polynomial_w_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_digamma
torch_special_digamma <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_digamma',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_digamma_out
torch_special_digamma_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_digamma_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_entr
torch_special_entr <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_entr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_entr_out
torch_special_entr_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_entr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_erf
torch_special_erf <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_erf',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_erf_out
torch_special_erf_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_erf_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_erfc
torch_special_erfc <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_erfc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_erfc_out
torch_special_erfc_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_erfc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_erfcx
torch_special_erfcx <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_erfcx',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_erfcx_out
torch_special_erfcx_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_erfcx_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_erfinv
torch_special_erfinv <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_erfinv',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_erfinv_out
torch_special_erfinv_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_erfinv_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_exp2
torch_special_exp2 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_exp2',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_exp2_out
torch_special_exp2_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_exp2_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_expit
torch_special_expit <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_expit',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_expit_out
torch_special_expit_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_expit_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_expm1
torch_special_expm1 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_expm1',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_expm1_out
torch_special_expm1_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_expm1_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_gammainc
torch_special_gammainc <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_gammainc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_gammainc_out
torch_special_gammainc_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_gammainc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_gammaincc
torch_special_gammaincc <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_gammaincc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_gammaincc_out
torch_special_gammaincc_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_gammaincc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_gammaln
torch_special_gammaln <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_gammaln',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_gammaln_out
torch_special_gammaln_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_gammaln_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_hermite_polynomial_h
torch_special_hermite_polynomial_h <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_hermite_polynomial_h',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_hermite_polynomial_h_out
torch_special_hermite_polynomial_h_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_hermite_polynomial_h_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_hermite_polynomial_he
torch_special_hermite_polynomial_he <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_hermite_polynomial_he',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_hermite_polynomial_he_out
torch_special_hermite_polynomial_he_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_hermite_polynomial_he_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_i0
torch_special_i0 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_i0',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_i0_out
torch_special_i0_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_i0_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_i0e
torch_special_i0e <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_i0e',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_i0e_out
torch_special_i0e_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_i0e_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_i1
torch_special_i1 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_i1',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_i1_out
torch_special_i1_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_i1_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_i1e
torch_special_i1e <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_i1e',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_i1e_out
torch_special_i1e_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_i1e_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_laguerre_polynomial_l
torch_special_laguerre_polynomial_l <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_laguerre_polynomial_l',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_laguerre_polynomial_l_out
torch_special_laguerre_polynomial_l_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_laguerre_polynomial_l_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_legendre_polynomial_p
torch_special_legendre_polynomial_p <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_legendre_polynomial_p',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_legendre_polynomial_p_out
torch_special_legendre_polynomial_p_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_legendre_polynomial_p_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_log_ndtr
torch_special_log_ndtr <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_log_ndtr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_log_ndtr_out
torch_special_log_ndtr_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_log_ndtr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_log_softmax
torch_special_log_softmax <- function(self, dim, dtype = NULL) {
  args <- mget(x = c("self", "dim", "dtype"))
expected_types <- list(self = "Tensor", dim = "int64_t", dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_log_softmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_log1p
torch_special_log1p <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_log1p',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_log1p_out
torch_special_log1p_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_log1p_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_logit
torch_special_logit <- function(self, eps = NULL) {
  args <- mget(x = c("self", "eps"))
expected_types <- list(self = "Tensor", eps = "double")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_logit',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_logit_out
torch_special_logit_out <- function(out, self, eps = NULL) {
  args <- mget(x = c("out", "self", "eps"))
expected_types <- list(out = "Tensor", self = "Tensor", eps = "double")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_logit_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_logsumexp
torch_special_logsumexp <- function(self, dim, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "keepdim"))
expected_types <- list(self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_logsumexp',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_logsumexp_out
torch_special_logsumexp_out <- function(out, self, dim, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "IntArrayRef", keepdim = "bool")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_logsumexp_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_modified_bessel_i0
torch_special_modified_bessel_i0 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_modified_bessel_i0',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_modified_bessel_i0_out
torch_special_modified_bessel_i0_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_modified_bessel_i0_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_modified_bessel_i1
torch_special_modified_bessel_i1 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_modified_bessel_i1',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_modified_bessel_i1_out
torch_special_modified_bessel_i1_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_modified_bessel_i1_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_modified_bessel_k0
torch_special_modified_bessel_k0 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_modified_bessel_k0',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_modified_bessel_k0_out
torch_special_modified_bessel_k0_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_modified_bessel_k0_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_modified_bessel_k1
torch_special_modified_bessel_k1 <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_modified_bessel_k1',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_modified_bessel_k1_out
torch_special_modified_bessel_k1_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_modified_bessel_k1_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_multigammaln
torch_special_multigammaln <- function(self, p) {
  args <- mget(x = c("self", "p"))
expected_types <- list(self = "Tensor", p = "int64_t")
nd_args <- c("self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_multigammaln',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_multigammaln_out
torch_special_multigammaln_out <- function(out, self, p) {
  args <- mget(x = c("out", "self", "p"))
expected_types <- list(out = "Tensor", self = "Tensor", p = "int64_t")
nd_args <- c("out", "self", "p")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_multigammaln_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_ndtr
torch_special_ndtr <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_ndtr',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_ndtr_out
torch_special_ndtr_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_ndtr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_ndtri
torch_special_ndtri <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_ndtri',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_ndtri_out
torch_special_ndtri_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_ndtri_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_polygamma_out
torch_special_polygamma_out <- function(out, n, self) {
  args <- mget(x = c("out", "n", "self"))
expected_types <- list(out = "Tensor", n = "int64_t", self = "Tensor")
nd_args <- c("out", "n", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_polygamma_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_psi
torch_special_psi <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_psi',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_psi_out
torch_special_psi_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_psi_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_round
torch_special_round <- function(self, decimals = 0L) {
  args <- mget(x = c("self", "decimals"))
expected_types <- list(self = "Tensor", decimals = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_round',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_round_out
torch_special_round_out <- function(out, self, decimals = 0L) {
  args <- mget(x = c("out", "self", "decimals"))
expected_types <- list(out = "Tensor", self = "Tensor", decimals = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_round_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_scaled_modified_bessel_k0
torch_special_scaled_modified_bessel_k0 <- function(x) {
  args <- mget(x = c("x"))
expected_types <- list(x = "Tensor")
nd_args <- "x"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_scaled_modified_bessel_k0',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_scaled_modified_bessel_k0_out
torch_special_scaled_modified_bessel_k0_out <- function(out, x) {
  args <- mget(x = c("out", "x"))
expected_types <- list(out = "Tensor", x = "Tensor")
nd_args <- c("out", "x")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_scaled_modified_bessel_k0_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_scaled_modified_bessel_k1
torch_special_scaled_modified_bessel_k1 <- function(x) {
  args <- mget(x = c("x"))
expected_types <- list(x = "Tensor")
nd_args <- "x"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_scaled_modified_bessel_k1',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_scaled_modified_bessel_k1_out
torch_special_scaled_modified_bessel_k1_out <- function(out, x) {
  args <- mget(x = c("out", "x"))
expected_types <- list(out = "Tensor", x = "Tensor")
nd_args <- c("out", "x")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_scaled_modified_bessel_k1_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_shifted_chebyshev_polynomial_t
torch_special_shifted_chebyshev_polynomial_t <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_shifted_chebyshev_polynomial_t',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_shifted_chebyshev_polynomial_t_out
torch_special_shifted_chebyshev_polynomial_t_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_shifted_chebyshev_polynomial_t_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_shifted_chebyshev_polynomial_u
torch_special_shifted_chebyshev_polynomial_u <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_shifted_chebyshev_polynomial_u',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_shifted_chebyshev_polynomial_u_out
torch_special_shifted_chebyshev_polynomial_u_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_shifted_chebyshev_polynomial_u_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_shifted_chebyshev_polynomial_v
torch_special_shifted_chebyshev_polynomial_v <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_shifted_chebyshev_polynomial_v',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_shifted_chebyshev_polynomial_v_out
torch_special_shifted_chebyshev_polynomial_v_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_shifted_chebyshev_polynomial_v_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_shifted_chebyshev_polynomial_w
torch_special_shifted_chebyshev_polynomial_w <- function(x, n) {
  args <- mget(x = c("x", "n"))
expected_types <- list(x = c("Tensor", "Scalar"), n = c("Tensor", "Scalar"))
nd_args <- c("x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_shifted_chebyshev_polynomial_w',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_shifted_chebyshev_polynomial_w_out
torch_special_shifted_chebyshev_polynomial_w_out <- function(out, x, n) {
  args <- mget(x = c("out", "x", "n"))
expected_types <- list(out = "Tensor", x = c("Tensor", "Scalar"), n = c("Tensor", 
"Scalar"))
nd_args <- c("out", "x", "n")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_shifted_chebyshev_polynomial_w_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_sinc
torch_special_sinc <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_sinc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_sinc_out
torch_special_sinc_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_sinc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_softmax
torch_special_softmax <- function(self, dim, dtype = NULL) {
  args <- mget(x = c("self", "dim", "dtype"))
expected_types <- list(self = "Tensor", dim = "int64_t", dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_softmax',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_spherical_bessel_j0
torch_special_spherical_bessel_j0 <- function(x) {
  args <- mget(x = c("x"))
expected_types <- list(x = "Tensor")
nd_args <- "x"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_spherical_bessel_j0',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_spherical_bessel_j0_out
torch_special_spherical_bessel_j0_out <- function(out, x) {
  args <- mget(x = c("out", "x"))
expected_types <- list(out = "Tensor", x = "Tensor")
nd_args <- c("out", "x")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_spherical_bessel_j0_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_xlog1py
torch_special_xlog1py <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Tensor", "Scalar"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_xlog1py',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_xlog1py_out
torch_special_xlog1py_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_xlog1py_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_xlogy
torch_special_xlogy <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Tensor", "Scalar"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_xlogy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_xlogy_out
torch_special_xlogy_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_xlogy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_zeta
torch_special_zeta <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Tensor", "Scalar"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_zeta',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_special_zeta_out
torch_special_zeta_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'special_zeta_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_split
.torch_split <- function(self, split_size, dim = 1L) {
  args <- mget(x = c("self", "split_size", "dim"))
expected_types <- list(self = "Tensor", split_size = c("int64_t", "IntArrayRef"
), dim = "int64_t")
nd_args <- c("self", "split_size")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'split',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_split_copy
torch_split_copy <- function(self, split_size, dim = 1L) {
  args <- mget(x = c("self", "split_size", "dim"))
expected_types <- list(self = "Tensor", split_size = "int64_t", dim = "int64_t")
nd_args <- c("self", "split_size")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'split_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_split_copy_out
torch_split_copy_out <- function(out, self, split_size, dim = 1L) {
  args <- mget(x = c("out", "self", "split_size", "dim"))
expected_types <- list(out = "TensorList", self = "Tensor", split_size = "int64_t", 
    dim = "int64_t")
nd_args <- c("out", "self", "split_size")
return_types <- list(list("void"))
call_c_function(
fun_name = 'split_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_split_with_sizes
torch_split_with_sizes <- function(self, split_sizes, dim = 1L) {
  args <- mget(x = c("self", "split_sizes", "dim"))
expected_types <- list(self = "Tensor", split_sizes = "IntArrayRef", dim = "int64_t")
nd_args <- c("self", "split_sizes")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'split_with_sizes',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_split_with_sizes_copy
torch_split_with_sizes_copy <- function(self, split_sizes, dim = 1L) {
  args <- mget(x = c("self", "split_sizes", "dim"))
expected_types <- list(self = "Tensor", split_sizes = "IntArrayRef", dim = "int64_t")
nd_args <- c("self", "split_sizes")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'split_with_sizes_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_split_with_sizes_copy_out
torch_split_with_sizes_copy_out <- function(out, self, split_sizes, dim = 1L) {
  args <- mget(x = c("out", "self", "split_sizes", "dim"))
expected_types <- list(out = "TensorList", self = "Tensor", split_sizes = "IntArrayRef", 
    dim = "int64_t")
nd_args <- c("out", "self", "split_sizes")
return_types <- list(list("void"))
call_c_function(
fun_name = 'split_with_sizes_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sqrt
torch_sqrt <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sqrt',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sqrt_
torch_sqrt_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sqrt_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sqrt_out
torch_sqrt_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sqrt_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_square
torch_square <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'square',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_square_
torch_square_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'square_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_square_out
torch_square_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'square_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_squeeze
torch_squeeze <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname", "IntArrayRef"
))
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'squeeze',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_squeeze_copy
torch_squeeze_copy <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "IntArrayRef"))
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'squeeze_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_squeeze_copy_out
torch_squeeze_copy_out <- function(out, self, dim) {
  args <- mget(x = c("out", "self", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("int64_t", "IntArrayRef"
))
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'squeeze_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sspaddmm
torch_sspaddmm <- function(self, mat1, mat2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("self", "mat1", "mat2", "beta", "alpha"))
expected_types <- list(self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", beta = "Scalar", 
    alpha = "Scalar")
nd_args <- c("self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sspaddmm',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sspaddmm_out
torch_sspaddmm_out <- function(out, self, mat1, mat2, beta = 1L, alpha = 1L) {
  args <- mget(x = c("out", "self", "mat1", "mat2", "beta", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", mat1 = "Tensor", mat2 = "Tensor", 
    beta = "Scalar", alpha = "Scalar")
nd_args <- c("out", "self", "mat1", "mat2")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sspaddmm_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_stack
torch_stack <- function(tensors, dim = 1L) {
  args <- mget(x = c("tensors", "dim"))
expected_types <- list(tensors = "TensorList", dim = "int64_t")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'stack',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_stack_out
torch_stack_out <- function(out, tensors, dim = 1L) {
  args <- mget(x = c("out", "tensors", "dim"))
expected_types <- list(out = "Tensor", tensors = "TensorList", dim = "int64_t")
nd_args <- c("out", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'stack_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_std
torch_std <- function(self, dim, unbiased = TRUE, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "unbiased", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("IntArrayRef", "DimnameList"), 
    unbiased = "bool", keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'std',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_std_mean
torch_std_mean <- function(self, dim, unbiased = TRUE, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "unbiased", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("IntArrayRef", "DimnameList"), 
    unbiased = "bool", keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'std_mean',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_std_out
torch_std_out <- function(out, self, dim, unbiased = TRUE, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "unbiased", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("IntArrayRef", 
"DimnameList"), unbiased = "bool", keepdim = "bool")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'std_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_stft
.torch_stft <- function(self, n_fft, hop_length = NULL, win_length = NULL, window = list(), center = TRUE, pad_mode = "reflect", normalized = FALSE, onesided = NULL, return_complex = NULL) {
  args <- mget(x = c("self", "n_fft", "hop_length", "win_length", "window", "center", "pad_mode", "normalized", "onesided", "return_complex"))
expected_types <- list(self = "Tensor", n_fft = "int64_t", hop_length = "int64_t", 
    win_length = "int64_t", window = "Tensor", center = "bool", 
    pad_mode = "c10::string_view", normalized = "bool", onesided = "bool", 
    return_complex = "bool")
nd_args <- c("self", "n_fft")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'stft',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_stride
torch_stride <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"))
nd_args <- c("self", "dim")
return_types <- list(list('int64_t'))
call_c_function(
fun_name = 'stride',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sub
torch_sub <- function(self, other, alpha = 1L) {
  args <- mget(x = c("self", "other", "alpha"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"), alpha = "Scalar")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sub',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sub_out
torch_sub_out <- function(out, self, other, alpha = 1L) {
  args <- mget(x = c("out", "self", "other", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", other = c("Tensor", "Scalar"
), alpha = "Scalar")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sub_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_subtract
torch_subtract <- function(self, other, alpha = 1L) {
  args <- mget(x = c("self", "other", "alpha"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"), alpha = "Scalar")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'subtract',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_subtract_out
torch_subtract_out <- function(out, self, other, alpha = 1L) {
  args <- mget(x = c("out", "self", "other", "alpha"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor", alpha = "Scalar")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'subtract_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sum
torch_sum <- function(self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("self", "dim", "keepdim", "dtype"))
expected_types <- list(self = "Tensor", dim = c("IntArrayRef", "DimnameList"), 
    keepdim = "bool", dtype = "ScalarType")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sum',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_sum_out
torch_sum_out <- function(out, self, dim, keepdim = FALSE, dtype = NULL) {
  args <- mget(x = c("out", "self", "dim", "keepdim", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("IntArrayRef", 
"DimnameList"), keepdim = "bool", dtype = "ScalarType")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'sum_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_svd
torch_svd <- function(self, some = TRUE, compute_uv = TRUE) {
  args <- mget(x = c("self", "some", "compute_uv"))
expected_types <- list(self = "Tensor", some = "bool", compute_uv = "bool")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'svd',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_svd_out
torch_svd_out <- function(U, S, V, self, some = TRUE, compute_uv = TRUE) {
  args <- mget(x = c("U", "S", "V", "self", "some", "compute_uv"))
expected_types <- list(U = "Tensor", S = "Tensor", V = "Tensor", self = "Tensor", 
    some = "bool", compute_uv = "bool")
nd_args <- c("U", "S", "V", "self")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'svd_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_swapaxes
torch_swapaxes <- function(self, axis0, axis1) {
  args <- mget(x = c("self", "axis0", "axis1"))
expected_types <- list(self = "Tensor", axis0 = "int64_t", axis1 = "int64_t")
nd_args <- c("self", "axis0", "axis1")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'swapaxes',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_swapdims
torch_swapdims <- function(self, dim0, dim1) {
  args <- mget(x = c("self", "dim0", "dim1"))
expected_types <- list(self = "Tensor", dim0 = "int64_t", dim1 = "int64_t")
nd_args <- c("self", "dim0", "dim1")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'swapdims',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_t
torch_t <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 't',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_t_copy
torch_t_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 't_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_t_copy_out
torch_t_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 't_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_take
torch_take <- function(self, index) {
  args <- mget(x = c("self", "index"))
expected_types <- list(self = "Tensor", index = "Tensor")
nd_args <- c("self", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'take',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_take_along_dim
torch_take_along_dim <- function(self, indices, dim = NULL) {
  args <- mget(x = c("self", "indices", "dim"))
expected_types <- list(self = "Tensor", indices = "Tensor", dim = "int64_t")
nd_args <- c("self", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'take_along_dim',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_take_along_dim_out
torch_take_along_dim_out <- function(out, self, indices, dim = NULL) {
  args <- mget(x = c("out", "self", "indices", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", indices = "Tensor", dim = "int64_t")
nd_args <- c("out", "self", "indices")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'take_along_dim_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_take_out
torch_take_out <- function(out, self, index) {
  args <- mget(x = c("out", "self", "index"))
expected_types <- list(out = "Tensor", self = "Tensor", index = "Tensor")
nd_args <- c("out", "self", "index")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'take_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tan
torch_tan <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tan',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tan_
torch_tan_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tan_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tan_out
torch_tan_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tan_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tanh
torch_tanh <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tanh',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tanh_
torch_tanh_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tanh_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tanh_backward
torch_tanh_backward <- function(grad_output, output) {
  args <- mget(x = c("grad_output", "output"))
expected_types <- list(grad_output = "Tensor", output = "Tensor")
nd_args <- c("grad_output", "output")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tanh_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tanh_backward_out
torch_tanh_backward_out <- function(grad_input, grad_output, output) {
  args <- mget(x = c("grad_input", "grad_output", "output"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output = "Tensor")
nd_args <- c("grad_input", "grad_output", "output")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tanh_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tanh_out
torch_tanh_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tanh_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tensor_split
torch_tensor_split <- function(self, indices, sections, tensor_indices_or_sections, dim = 1L) {
  args <- mget(x = c("self", "indices", "sections", "tensor_indices_or_sections", "dim"))
expected_types <- list(self = "Tensor", indices = "IntArrayRef", sections = "int64_t", 
    tensor_indices_or_sections = "Tensor", dim = "int64_t")
nd_args <- c("self", "indices", "sections", "tensor_indices_or_sections"
)
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'tensor_split',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_tensordot
.torch_tensordot <- function(self, other, dims_self, dims_other) {
  args <- mget(x = c("self", "other", "dims_self", "dims_other"))
expected_types <- list(self = "Tensor", other = "Tensor", dims_self = "IntArrayRef", 
    dims_other = "IntArrayRef")
nd_args <- c("self", "other", "dims_self", "dims_other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tensordot',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tensordot_out
torch_tensordot_out <- function(out, self, other, dims_self, dims_other) {
  args <- mget(x = c("out", "self", "other", "dims_self", "dims_other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor", dims_self = "IntArrayRef", 
    dims_other = "IntArrayRef")
nd_args <- c("out", "self", "other", "dims_self", "dims_other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tensordot_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_thnn_conv2d
torch_thnn_conv2d <- function(self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L) {
  args <- mget(x = c("self", "weight", "kernel_size", "bias", "stride", "padding"))
expected_types <- list(self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'thnn_conv2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_thnn_conv2d_out
torch_thnn_conv2d_out <- function(out, self, weight, kernel_size, bias = list(), stride = 1L, padding = 0L) {
  args <- mget(x = c("out", "self", "weight", "kernel_size", "bias", "stride", "padding"))
expected_types <- list(out = "Tensor", self = "Tensor", weight = "Tensor", kernel_size = "IntArrayRef", 
    bias = "Tensor", stride = "IntArrayRef", padding = "IntArrayRef")
nd_args <- c("out", "self", "weight", "kernel_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'thnn_conv2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_threshold
torch_threshold <- function(self, threshold, value) {
  args <- mget(x = c("self", "threshold", "value"))
expected_types <- list(self = "Tensor", threshold = "Scalar", value = "Scalar")
nd_args <- c("self", "threshold", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'threshold',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_threshold_
torch_threshold_ <- function(self, threshold, value) {
  args <- mget(x = c("self", "threshold", "value"))
expected_types <- list(self = "Tensor", threshold = "Scalar", value = "Scalar")
nd_args <- c("self", "threshold", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'threshold_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_threshold_backward
torch_threshold_backward <- function(grad_output, self, threshold) {
  args <- mget(x = c("grad_output", "self", "threshold"))
expected_types <- list(grad_output = "Tensor", self = "Tensor", threshold = "Scalar")
nd_args <- c("grad_output", "self", "threshold")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'threshold_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_threshold_backward_out
torch_threshold_backward_out <- function(grad_input, grad_output, self, threshold) {
  args <- mget(x = c("grad_input", "grad_output", "self", "threshold"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", self = "Tensor", 
    threshold = "Scalar")
nd_args <- c("grad_input", "grad_output", "self", "threshold")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'threshold_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_threshold_out
torch_threshold_out <- function(out, self, threshold, value) {
  args <- mget(x = c("out", "self", "threshold", "value"))
expected_types <- list(out = "Tensor", self = "Tensor", threshold = "Scalar", value = "Scalar")
nd_args <- c("out", "self", "threshold", "value")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'threshold_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tile
torch_tile <- function(self, dims) {
  args <- mget(x = c("self", "dims"))
expected_types <- list(self = "Tensor", dims = "IntArrayRef")
nd_args <- c("self", "dims")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tile',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_to_dense_backward
torch_to_dense_backward <- function(grad, input) {
  args <- mget(x = c("grad", "input"))
expected_types <- list(grad = "Tensor", input = "Tensor")
nd_args <- c("grad", "input")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'to_dense_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_to_mkldnn_backward
torch_to_mkldnn_backward <- function(grad, input) {
  args <- mget(x = c("grad", "input"))
expected_types <- list(grad = "Tensor", input = "Tensor")
nd_args <- c("grad", "input")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'to_mkldnn_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_to_mkldnn_out
torch_to_mkldnn_out <- function(out, self, dtype = NULL) {
  args <- mget(x = c("out", "self", "dtype"))
expected_types <- list(out = "Tensor", self = "Tensor", dtype = "ScalarType")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'to_mkldnn_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_to_padded_tensor_out
torch_to_padded_tensor_out <- function(out, self, padding, output_size = NULL) {
  args <- mget(x = c("out", "self", "padding", "output_size"))
expected_types <- list(out = "Tensor", self = "Tensor", padding = "double", output_size = "IntArrayRef")
nd_args <- c("out", "self", "padding")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'to_padded_tensor_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_to_sparse_bsc_out
torch_to_sparse_bsc_out <- function(out, self, blocksize, dense_dim = NULL) {
  args <- mget(x = c("out", "self", "blocksize", "dense_dim"))
expected_types <- list(out = "Tensor", self = "Tensor", blocksize = "IntArrayRef", 
    dense_dim = "int64_t")
nd_args <- c("out", "self", "blocksize")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'to_sparse_bsc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_to_sparse_bsr_out
torch_to_sparse_bsr_out <- function(out, self, blocksize, dense_dim = NULL) {
  args <- mget(x = c("out", "self", "blocksize", "dense_dim"))
expected_types <- list(out = "Tensor", self = "Tensor", blocksize = "IntArrayRef", 
    dense_dim = "int64_t")
nd_args <- c("out", "self", "blocksize")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'to_sparse_bsr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_to_sparse_csc_out
torch_to_sparse_csc_out <- function(out, self, dense_dim = NULL) {
  args <- mget(x = c("out", "self", "dense_dim"))
expected_types <- list(out = "Tensor", self = "Tensor", dense_dim = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'to_sparse_csc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_to_sparse_csr_out
torch_to_sparse_csr_out <- function(out, self, dense_dim = NULL) {
  args <- mget(x = c("out", "self", "dense_dim"))
expected_types <- list(out = "Tensor", self = "Tensor", dense_dim = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'to_sparse_csr_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_to_sparse_out
torch_to_sparse_out <- function(out, self, layout = NULL, sparse_dim, blocksize = NULL, dense_dim = NULL) {
  args <- mget(x = c("out", "self", "layout", "sparse_dim", "blocksize", "dense_dim"))
expected_types <- list(out = "Tensor", self = "Tensor", layout = "Layout", sparse_dim = "int64_t", 
    blocksize = "IntArrayRef", dense_dim = "int64_t")
nd_args <- c("out", "self", "sparse_dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'to_sparse_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_topk
.torch_topk <- function(self, k, dim = -1L, largest = TRUE, sorted = TRUE) {
  args <- mget(x = c("self", "k", "dim", "largest", "sorted"))
expected_types <- list(self = "Tensor", k = "int64_t", dim = "int64_t", largest = "bool", 
    sorted = "bool")
nd_args <- c("self", "k")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'topk',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_topk_out
torch_topk_out <- function(values, indices, self, k, dim = -1L, largest = TRUE, sorted = TRUE) {
  args <- mget(x = c("values", "indices", "self", "k", "dim", "largest", "sorted"))
expected_types <- list(values = "Tensor", indices = "Tensor", self = "Tensor", 
    k = "int64_t", dim = "int64_t", largest = "bool", sorted = "bool")
nd_args <- c("values", "indices", "self", "k")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'topk_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_trace
torch_trace <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'trace',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_trace_backward
torch_trace_backward <- function(grad, sizes) {
  args <- mget(x = c("grad", "sizes"))
expected_types <- list(grad = "Tensor", sizes = "IntArrayRef")
nd_args <- c("grad", "sizes")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'trace_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_trace_out
torch_trace_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'trace_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_transpose
torch_transpose <- function(self, dim0, dim1) {
  args <- mget(x = c("self", "dim0", "dim1"))
expected_types <- list(self = "Tensor", dim0 = c("int64_t", "Dimname"), dim1 = c("int64_t", 
"Dimname"))
nd_args <- c("self", "dim0", "dim1")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'transpose',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_transpose_copy
torch_transpose_copy <- function(self, dim0, dim1) {
  args <- mget(x = c("self", "dim0", "dim1"))
expected_types <- list(self = "Tensor", dim0 = "int64_t", dim1 = "int64_t")
nd_args <- c("self", "dim0", "dim1")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'transpose_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_transpose_copy_out
torch_transpose_copy_out <- function(out, self, dim0, dim1) {
  args <- mget(x = c("out", "self", "dim0", "dim1"))
expected_types <- list(out = "Tensor", self = "Tensor", dim0 = "int64_t", dim1 = "int64_t")
nd_args <- c("out", "self", "dim0", "dim1")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'transpose_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_trapezoid
torch_trapezoid <- function(y, dx = 1L, x, dim = -1L) {
  args <- mget(x = c("y", "dx", "x", "dim"))
expected_types <- list(y = "Tensor", dx = "Scalar", x = "Tensor", dim = "int64_t")
nd_args <- c("y", "x")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'trapezoid',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_trapz
torch_trapz <- function(y, dx = 1L, x, dim = -1L) {
  args <- mget(x = c("y", "dx", "x", "dim"))
expected_types <- list(y = "Tensor", dx = "double", x = "Tensor", dim = "int64_t")
nd_args <- c("y", "x")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'trapz',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_triangular_solve
torch_triangular_solve <- function(self, A, upper = TRUE, transpose = FALSE, unitriangular = FALSE) {
  args <- mget(x = c("self", "A", "upper", "transpose", "unitriangular"))
expected_types <- list(self = "Tensor", A = "Tensor", upper = "bool", transpose = "bool", 
    unitriangular = "bool")
nd_args <- c("self", "A")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'triangular_solve',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_triangular_solve_out
torch_triangular_solve_out <- function(X, M, self, A, upper = TRUE, transpose = FALSE, unitriangular = FALSE) {
  args <- mget(x = c("X", "M", "self", "A", "upper", "transpose", "unitriangular"))
expected_types <- list(X = "Tensor", M = "Tensor", self = "Tensor", A = "Tensor", 
    upper = "bool", transpose = "bool", unitriangular = "bool")
nd_args <- c("X", "M", "self", "A")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'triangular_solve_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tril
torch_tril <- function(self, diagonal = 0L) {
  args <- mget(x = c("self", "diagonal"))
expected_types <- list(self = "Tensor", diagonal = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tril',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_tril_indices
.torch_tril_indices <- function(row, col, offset = 0L, options = torch_long()) {
  args <- mget(x = c("row", "col", "offset", "options"))
expected_types <- list(row = "int64_t", col = "int64_t", offset = "int64_t", options = "TensorOptions")
nd_args <- c("row", "col")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tril_indices',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tril_indices_out
torch_tril_indices_out <- function(out, row, col, offset = 0L) {
  args <- mget(x = c("out", "row", "col", "offset"))
expected_types <- list(out = "Tensor", row = "int64_t", col = "int64_t", offset = "int64_t")
nd_args <- c("out", "row", "col")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tril_indices_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_tril_out
torch_tril_out <- function(out, self, diagonal = 0L) {
  args <- mget(x = c("out", "self", "diagonal"))
expected_types <- list(out = "Tensor", self = "Tensor", diagonal = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'tril_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_triplet_margin_loss
torch_triplet_margin_loss <- function(anchor, positive, negative, margin = 1L, p = 2L, eps = 1e-06, swap = FALSE, reduction = torch_reduction_mean()) {
  args <- mget(x = c("anchor", "positive", "negative", "margin", "p", "eps", "swap", "reduction"))
expected_types <- list(anchor = "Tensor", positive = "Tensor", negative = "Tensor", 
    margin = "double", p = "double", eps = "double", swap = "bool", 
    reduction = "int64_t")
nd_args <- c("anchor", "positive", "negative")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'triplet_margin_loss',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_triu
torch_triu <- function(self, diagonal = 0L) {
  args <- mget(x = c("self", "diagonal"))
expected_types <- list(self = "Tensor", diagonal = "int64_t")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'triu',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_triu_indices
.torch_triu_indices <- function(row, col, offset = 0L, options = torch_long()) {
  args <- mget(x = c("row", "col", "offset", "options"))
expected_types <- list(row = "int64_t", col = "int64_t", offset = "int64_t", options = "TensorOptions")
nd_args <- c("row", "col")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'triu_indices',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_triu_indices_out
torch_triu_indices_out <- function(out, row, col, offset = 0L) {
  args <- mget(x = c("out", "row", "col", "offset"))
expected_types <- list(out = "Tensor", row = "int64_t", col = "int64_t", offset = "int64_t")
nd_args <- c("out", "row", "col")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'triu_indices_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_triu_out
torch_triu_out <- function(out, self, diagonal = 0L) {
  args <- mget(x = c("out", "self", "diagonal"))
expected_types <- list(out = "Tensor", self = "Tensor", diagonal = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'triu_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_true_divide
torch_true_divide <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'true_divide',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_true_divide_out
torch_true_divide_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'true_divide_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_trunc
torch_trunc <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'trunc',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_trunc_
torch_trunc_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'trunc_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_trunc_out
torch_trunc_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'trunc_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unbind
torch_unbind <- function(self, dim = 1L) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"))
nd_args <- c("self", "dim")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'unbind',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unbind_copy
torch_unbind_copy <- function(self, dim = 1L) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = "int64_t")
nd_args <- "self"
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'unbind_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unbind_copy_out
torch_unbind_copy_out <- function(out, self, dim = 1L) {
  args <- mget(x = c("out", "self", "dim"))
expected_types <- list(out = "TensorList", self = "Tensor", dim = "int64_t")
nd_args <- c("out", "self")
return_types <- list(list("void"))
call_c_function(
fun_name = 'unbind_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unflatten
torch_unflatten <- function(self, dim, sizes, names) {
  args <- mget(x = c("self", "dim", "sizes", "names"))
expected_types <- list(self = "Tensor", dim = c("int64_t", "Dimname"), sizes = "IntArrayRef", 
    names = "DimnameList")
nd_args <- c("self", "dim", "sizes", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'unflatten',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unflatten_dense_tensors
torch_unflatten_dense_tensors <- function(flat, tensors) {
  args <- mget(x = c("flat", "tensors"))
expected_types <- list(flat = "Tensor", tensors = "TensorList")
nd_args <- c("flat", "tensors")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'unflatten_dense_tensors',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unfold_backward
torch_unfold_backward <- function(grad_in, input_sizes, dim, size, step) {
  args <- mget(x = c("grad_in", "input_sizes", "dim", "size", "step"))
expected_types <- list(grad_in = "Tensor", input_sizes = "IntArrayRef", dim = "int64_t", 
    size = "int64_t", step = "int64_t")
nd_args <- c("grad_in", "input_sizes", "dim", "size", "step")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'unfold_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unfold_backward_out
torch_unfold_backward_out <- function(out, grad_in, input_sizes, dim, size, step) {
  args <- mget(x = c("out", "grad_in", "input_sizes", "dim", "size", "step"))
expected_types <- list(out = "Tensor", grad_in = "Tensor", input_sizes = "IntArrayRef", 
    dim = "int64_t", size = "int64_t", step = "int64_t")
nd_args <- c("out", "grad_in", "input_sizes", "dim", "size", "step")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'unfold_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unfold_copy
torch_unfold_copy <- function(self, dimension, size, step) {
  args <- mget(x = c("self", "dimension", "size", "step"))
expected_types <- list(self = "Tensor", dimension = "int64_t", size = "int64_t", 
    step = "int64_t")
nd_args <- c("self", "dimension", "size", "step")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'unfold_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unfold_copy_out
torch_unfold_copy_out <- function(out, self, dimension, size, step) {
  args <- mget(x = c("out", "self", "dimension", "size", "step"))
expected_types <- list(out = "Tensor", self = "Tensor", dimension = "int64_t", 
    size = "int64_t", step = "int64_t")
nd_args <- c("out", "self", "dimension", "size", "step")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'unfold_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_uniform
torch_uniform <- function(self, from = 0L, to = 1L, generator = NULL) {
  args <- mget(x = c("self", "from", "to", "generator"))
expected_types <- list(self = "Tensor", from = "double", to = "double", generator = "Generator")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'uniform',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_uniform_out
torch_uniform_out <- function(out, self, from = 0L, to = 1L, generator = NULL) {
  args <- mget(x = c("out", "self", "from", "to", "generator"))
expected_types <- list(out = "Tensor", self = "Tensor", from = "double", to = "double", 
    generator = "Generator")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'uniform_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unique_consecutive
torch_unique_consecutive <- function(self, return_inverse = FALSE, return_counts = FALSE, dim = NULL) {
  args <- mget(x = c("self", "return_inverse", "return_counts", "dim"))
expected_types <- list(self = "Tensor", return_inverse = "bool", return_counts = "bool", 
    dim = "int64_t")
nd_args <- "self"
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'unique_consecutive',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unique_consecutive_out
torch_unique_consecutive_out <- function(out0, out1, out2, self, return_inverse = FALSE, return_counts = FALSE, dim = NULL) {
  args <- mget(x = c("out0", "out1", "out2", "self", "return_inverse", "return_counts", "dim"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", self = "Tensor", 
    return_inverse = "bool", return_counts = "bool", dim = "int64_t")
nd_args <- c("out0", "out1", "out2", "self")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'unique_consecutive_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unique_dim
torch_unique_dim <- function(self, dim, sorted = TRUE, return_inverse = FALSE, return_counts = FALSE) {
  args <- mget(x = c("self", "dim", "sorted", "return_inverse", "return_counts"))
expected_types <- list(self = "Tensor", dim = "int64_t", sorted = "bool", return_inverse = "bool", 
    return_counts = "bool")
nd_args <- c("self", "dim")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'unique_dim',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unique_dim_consecutive
torch_unique_dim_consecutive <- function(self, dim, return_inverse = FALSE, return_counts = FALSE) {
  args <- mget(x = c("self", "dim", "return_inverse", "return_counts"))
expected_types <- list(self = "Tensor", dim = "int64_t", return_inverse = "bool", 
    return_counts = "bool")
nd_args <- c("self", "dim")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'unique_dim_consecutive',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unique_dim_consecutive_out
torch_unique_dim_consecutive_out <- function(out0, out1, out2, self, dim, return_inverse = FALSE, return_counts = FALSE) {
  args <- mget(x = c("out0", "out1", "out2", "self", "dim", "return_inverse", "return_counts"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", self = "Tensor", 
    dim = "int64_t", return_inverse = "bool", return_counts = "bool")
nd_args <- c("out0", "out1", "out2", "self", "dim")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'unique_dim_consecutive_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unique_dim_out
torch_unique_dim_out <- function(out0, out1, out2, self, dim, sorted = TRUE, return_inverse = FALSE, return_counts = FALSE) {
  args <- mget(x = c("out0", "out1", "out2", "self", "dim", "sorted", "return_inverse", "return_counts"))
expected_types <- list(out0 = "Tensor", out1 = "Tensor", out2 = "Tensor", self = "Tensor", 
    dim = "int64_t", sorted = "bool", return_inverse = "bool", 
    return_counts = "bool")
nd_args <- c("out0", "out1", "out2", "self", "dim")
return_types <- list(list("Tensor", "Tensor", "Tensor"))
call_c_function(
fun_name = 'unique_dim_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unsafe_chunk
torch_unsafe_chunk <- function(self, chunks, dim = 1L) {
  args <- mget(x = c("self", "chunks", "dim"))
expected_types <- list(self = "Tensor", chunks = "int64_t", dim = "int64_t")
nd_args <- c("self", "chunks")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'unsafe_chunk',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unsafe_split
torch_unsafe_split <- function(self, split_size, dim = 1L) {
  args <- mget(x = c("self", "split_size", "dim"))
expected_types <- list(self = "Tensor", split_size = "int64_t", dim = "int64_t")
nd_args <- c("self", "split_size")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'unsafe_split',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unsafe_split_out
torch_unsafe_split_out <- function(out, self, split_size, dim = 1L) {
  args <- mget(x = c("out", "self", "split_size", "dim"))
expected_types <- list(out = "TensorList", self = "Tensor", split_size = "int64_t", 
    dim = "int64_t")
nd_args <- c("out", "self", "split_size")
return_types <- list(list("void"))
call_c_function(
fun_name = 'unsafe_split_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unsafe_split_with_sizes
torch_unsafe_split_with_sizes <- function(self, split_sizes, dim = 1L) {
  args <- mget(x = c("self", "split_sizes", "dim"))
expected_types <- list(self = "Tensor", split_sizes = "IntArrayRef", dim = "int64_t")
nd_args <- c("self", "split_sizes")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'unsafe_split_with_sizes',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unsafe_split_with_sizes_out
torch_unsafe_split_with_sizes_out <- function(out, self, split_sizes, dim = 1L) {
  args <- mget(x = c("out", "self", "split_sizes", "dim"))
expected_types <- list(out = "TensorList", self = "Tensor", split_sizes = "IntArrayRef", 
    dim = "int64_t")
nd_args <- c("out", "self", "split_sizes")
return_types <- list(list("void"))
call_c_function(
fun_name = 'unsafe_split_with_sizes_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unsqueeze
torch_unsqueeze <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = "int64_t")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'unsqueeze',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unsqueeze_copy
torch_unsqueeze_copy <- function(self, dim) {
  args <- mget(x = c("self", "dim"))
expected_types <- list(self = "Tensor", dim = "int64_t")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'unsqueeze_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_unsqueeze_copy_out
torch_unsqueeze_copy_out <- function(out, self, dim) {
  args <- mget(x = c("out", "self", "dim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = "int64_t")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'unsqueeze_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_bicubic2d
torch_upsample_bicubic2d <- function(input, self, output_size, align_corners, scale_factors, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("input", "self", "output_size", "align_corners", "scale_factors", "scales_h", "scales_w"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scale_factors = "ArrayRef<double>", 
    scales_h = "double", scales_w = "double")
nd_args <- c("input", "self", "output_size", "align_corners", "scale_factors"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_bicubic2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_bicubic2d_backward
torch_upsample_bicubic2d_backward <- function(grad_output, output_size, input_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    align_corners = "bool", scales_h = "double", scales_w = "double")
nd_args <- c("grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_bicubic2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_bicubic2d_backward_out
torch_upsample_bicubic2d_backward_out <- function(grad_input, grad_output, output_size, input_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", align_corners = "bool", scales_h = "double", 
    scales_w = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_bicubic2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_bicubic2d_out
torch_upsample_bicubic2d_out <- function(out, self, output_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("out", "self", "output_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scales_h = "double", scales_w = "double")
nd_args <- c("out", "self", "output_size", "align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_bicubic2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_bilinear2d
torch_upsample_bilinear2d <- function(input, self, output_size, align_corners, scale_factors, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("input", "self", "output_size", "align_corners", "scale_factors", "scales_h", "scales_w"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scale_factors = "ArrayRef<double>", 
    scales_h = "double", scales_w = "double")
nd_args <- c("input", "self", "output_size", "align_corners", "scale_factors"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_bilinear2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_bilinear2d_backward
torch_upsample_bilinear2d_backward <- function(grad_output, output_size, input_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    align_corners = "bool", scales_h = "double", scales_w = "double")
nd_args <- c("grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_bilinear2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_bilinear2d_backward_out
torch_upsample_bilinear2d_backward_out <- function(grad_input, grad_output, output_size, input_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", align_corners = "bool", scales_h = "double", 
    scales_w = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_bilinear2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_bilinear2d_out
torch_upsample_bilinear2d_out <- function(out, self, output_size, align_corners, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("out", "self", "output_size", "align_corners", "scales_h", "scales_w"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scales_h = "double", scales_w = "double")
nd_args <- c("out", "self", "output_size", "align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_bilinear2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_linear1d
torch_upsample_linear1d <- function(input, self, output_size, align_corners, scale_factors, scales = NULL) {
  args <- mget(x = c("input", "self", "output_size", "align_corners", "scale_factors", "scales"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scale_factors = "ArrayRef<double>", 
    scales = "double")
nd_args <- c("input", "self", "output_size", "align_corners", "scale_factors"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_linear1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_linear1d_backward
torch_upsample_linear1d_backward <- function(grad_output, output_size, input_size, align_corners, scales = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "align_corners", "scales"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    align_corners = "bool", scales = "double")
nd_args <- c("grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_linear1d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_linear1d_backward_out
torch_upsample_linear1d_backward_out <- function(grad_input, grad_output, output_size, input_size, align_corners, scales = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "align_corners", "scales"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", align_corners = "bool", scales = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_linear1d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_linear1d_out
torch_upsample_linear1d_out <- function(out, self, output_size, align_corners, scales = NULL) {
  args <- mget(x = c("out", "self", "output_size", "align_corners", "scales"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scales = "double")
nd_args <- c("out", "self", "output_size", "align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_linear1d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_upsample_nearest1d
.torch_upsample_nearest1d <- function(input, self, output_size, scale_factors, scales = NULL) {
  args <- mget(x = c("input", "self", "output_size", "scale_factors", "scales"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scale_factors = "ArrayRef<double>", scales = "double")
nd_args <- c("input", "self", "output_size", "scale_factors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest1d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_nearest1d_backward
torch_upsample_nearest1d_backward <- function(grad_output, output_size, input_size, scales = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "scales"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    scales = "double")
nd_args <- c("grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest1d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_nearest1d_backward_out
torch_upsample_nearest1d_backward_out <- function(grad_input, grad_output, output_size, input_size, scales = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "scales"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", scales = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest1d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_nearest1d_out
torch_upsample_nearest1d_out <- function(out, self, output_size, scales = NULL) {
  args <- mget(x = c("out", "self", "output_size", "scales"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scales = "double")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest1d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_upsample_nearest2d
.torch_upsample_nearest2d <- function(input, self, output_size, scale_factors, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("input", "self", "output_size", "scale_factors", "scales_h", "scales_w"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scale_factors = "ArrayRef<double>", scales_h = "double", 
    scales_w = "double")
nd_args <- c("input", "self", "output_size", "scale_factors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest2d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_nearest2d_backward
torch_upsample_nearest2d_backward <- function(grad_output, output_size, input_size, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "scales_h", "scales_w"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    scales_h = "double", scales_w = "double")
nd_args <- c("grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest2d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_nearest2d_backward_out
torch_upsample_nearest2d_backward_out <- function(grad_input, grad_output, output_size, input_size, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "scales_h", "scales_w"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", scales_h = "double", scales_w = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest2d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_nearest2d_out
torch_upsample_nearest2d_out <- function(out, self, output_size, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("out", "self", "output_size", "scales_h", "scales_w"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scales_h = "double", scales_w = "double")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest2d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_upsample_nearest3d
.torch_upsample_nearest3d <- function(input, self, output_size, scale_factors, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("input", "self", "output_size", "scale_factors", "scales_d", "scales_h", "scales_w"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scale_factors = "ArrayRef<double>", scales_d = "double", 
    scales_h = "double", scales_w = "double")
nd_args <- c("input", "self", "output_size", "scale_factors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_nearest3d_backward
torch_upsample_nearest3d_backward <- function(grad_output, output_size, input_size, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "scales_d", "scales_h", "scales_w"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    scales_d = "double", scales_h = "double", scales_w = "double")
nd_args <- c("grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_nearest3d_backward_out
torch_upsample_nearest3d_backward_out <- function(grad_input, grad_output, output_size, input_size, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "scales_d", "scales_h", "scales_w"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", scales_d = "double", scales_h = "double", 
    scales_w = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_nearest3d_out
torch_upsample_nearest3d_out <- function(out, self, output_size, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("out", "self", "output_size", "scales_d", "scales_h", "scales_w"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    scales_d = "double", scales_h = "double", scales_w = "double")
nd_args <- c("out", "self", "output_size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_nearest3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_upsample_trilinear3d
.torch_upsample_trilinear3d <- function(input, self, output_size, align_corners, scale_factors, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("input", "self", "output_size", "align_corners", "scale_factors", "scales_d", "scales_h", "scales_w"))
expected_types <- list(input = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scale_factors = "ArrayRef<double>", 
    scales_d = "double", scales_h = "double", scales_w = "double")
nd_args <- c("input", "self", "output_size", "align_corners", "scale_factors"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_trilinear3d',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_trilinear3d_backward
torch_upsample_trilinear3d_backward <- function(grad_output, output_size, input_size, align_corners, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_output", "output_size", "input_size", "align_corners", "scales_d", "scales_h", "scales_w"))
expected_types <- list(grad_output = "Tensor", output_size = "IntArrayRef", input_size = "IntArrayRef", 
    align_corners = "bool", scales_d = "double", scales_h = "double", 
    scales_w = "double")
nd_args <- c("grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_trilinear3d_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_trilinear3d_backward_out
torch_upsample_trilinear3d_backward_out <- function(grad_input, grad_output, output_size, input_size, align_corners, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("grad_input", "grad_output", "output_size", "input_size", "align_corners", "scales_d", "scales_h", "scales_w"))
expected_types <- list(grad_input = "Tensor", grad_output = "Tensor", output_size = "IntArrayRef", 
    input_size = "IntArrayRef", align_corners = "bool", scales_d = "double", 
    scales_h = "double", scales_w = "double")
nd_args <- c("grad_input", "grad_output", "output_size", "input_size", "align_corners"
)
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_trilinear3d_backward_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_upsample_trilinear3d_out
torch_upsample_trilinear3d_out <- function(out, self, output_size, align_corners, scales_d = NULL, scales_h = NULL, scales_w = NULL) {
  args <- mget(x = c("out", "self", "output_size", "align_corners", "scales_d", "scales_h", "scales_w"))
expected_types <- list(out = "Tensor", self = "Tensor", output_size = "IntArrayRef", 
    align_corners = "bool", scales_d = "double", scales_h = "double", 
    scales_w = "double")
nd_args <- c("out", "self", "output_size", "align_corners")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'upsample_trilinear3d_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_value_selecting_reduction_backward
torch_value_selecting_reduction_backward <- function(grad, dim, indices, sizes, keepdim) {
  args <- mget(x = c("grad", "dim", "indices", "sizes", "keepdim"))
expected_types <- list(grad = "Tensor", dim = "int64_t", indices = "Tensor", sizes = "IntArrayRef", 
    keepdim = "bool")
nd_args <- c("grad", "dim", "indices", "sizes", "keepdim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'value_selecting_reduction_backward',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_values_copy
torch_values_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'values_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_values_copy_out
torch_values_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'values_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_vander
.torch_vander <- function(x, False = NULL, increasing = FALSE) {
  args <- mget(x = c("x", "False", "increasing"))
expected_types <- list(x = "Tensor", False = "int64_t", increasing = "bool")
nd_args <- "x"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'vander',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_var
torch_var <- function(self, dim, unbiased = TRUE, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "unbiased", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("IntArrayRef", "DimnameList"), 
    unbiased = "bool", keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'var',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_var_mean
torch_var_mean <- function(self, dim, unbiased = TRUE, keepdim = FALSE) {
  args <- mget(x = c("self", "dim", "unbiased", "keepdim"))
expected_types <- list(self = "Tensor", dim = c("IntArrayRef", "DimnameList"), 
    unbiased = "bool", keepdim = "bool")
nd_args <- c("self", "dim")
return_types <- list(list("Tensor", "Tensor"))
call_c_function(
fun_name = 'var_mean',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_var_out
torch_var_out <- function(out, self, dim, unbiased = TRUE, keepdim = FALSE) {
  args <- mget(x = c("out", "self", "dim", "unbiased", "keepdim"))
expected_types <- list(out = "Tensor", self = "Tensor", dim = c("IntArrayRef", 
"DimnameList"), unbiased = "bool", keepdim = "bool")
nd_args <- c("out", "self", "dim")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'var_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_vdot
torch_vdot <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = "Tensor")
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'vdot',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_vdot_out
torch_vdot_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'vdot_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_view_as_complex
torch_view_as_complex <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'view_as_complex',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_view_as_complex_copy
torch_view_as_complex_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'view_as_complex_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_view_as_complex_copy_out
torch_view_as_complex_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'view_as_complex_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_view_as_real
torch_view_as_real <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'view_as_real',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_view_as_real_copy
torch_view_as_real_copy <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'view_as_real_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_view_as_real_copy_out
torch_view_as_real_copy_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'view_as_real_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_view_copy
torch_view_copy <- function(self, dtype, size) {
  args <- mget(x = c("self", "dtype", "size"))
expected_types <- list(self = "Tensor", dtype = "ScalarType", size = "IntArrayRef")
nd_args <- c("self", "dtype", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'view_copy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_view_copy_out
torch_view_copy_out <- function(out, self, dtype, size) {
  args <- mget(x = c("out", "self", "dtype", "size"))
expected_types <- list(out = "Tensor", self = "Tensor", dtype = "ScalarType", size = "IntArrayRef")
nd_args <- c("out", "self", "dtype", "size")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'view_copy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_vsplit
torch_vsplit <- function(self, indices, sections) {
  args <- mget(x = c("self", "indices", "sections"))
expected_types <- list(self = "Tensor", indices = "IntArrayRef", sections = "int64_t")
nd_args <- c("self", "indices", "sections")
return_types <- list(list('TensorList'))
call_c_function(
fun_name = 'vsplit',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_vstack
torch_vstack <- function(tensors) {
  args <- mget(x = c("tensors"))
expected_types <- list(tensors = "TensorList")
nd_args <- "tensors"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'vstack',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_vstack_out
torch_vstack_out <- function(out, tensors) {
  args <- mget(x = c("out", "tensors"))
expected_types <- list(out = "Tensor", tensors = "TensorList")
nd_args <- c("out", "tensors")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'vstack_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_where
.torch_where <- function(condition, self, other) {
  args <- mget(x = c("condition", "self", "other"))
expected_types <- list(condition = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("condition", "self", "other")
return_types <- list(list('Tensor'), list('TensorList'))
call_c_function(
fun_name = 'where',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_where_out
torch_where_out <- function(out, condition, self, other) {
  args <- mget(x = c("out", "condition", "self", "other"))
expected_types <- list(out = "Tensor", condition = "Tensor", self = "Tensor", other = "Tensor")
nd_args <- c("out", "condition", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'where_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_xlogy
torch_xlogy <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = c("Tensor", "Scalar"), other = c("Tensor", "Scalar"
))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'xlogy',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_xlogy_
torch_xlogy_ <- function(self, other) {
  args <- mget(x = c("self", "other"))
expected_types <- list(self = "Tensor", other = c("Tensor", "Scalar"))
nd_args <- c("self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'xlogy_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_xlogy_out
torch_xlogy_out <- function(out, self, other) {
  args <- mget(x = c("out", "self", "other"))
expected_types <- list(out = "Tensor", self = c("Tensor", "Scalar"), other = c("Tensor", 
"Scalar"))
nd_args <- c("out", "self", "other")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'xlogy_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_zero
torch_zero <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'zero',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_zero_
torch_zero_ <- function(self) {
  args <- mget(x = c("self"))
expected_types <- list(self = "Tensor")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'zero_',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_zero_out
torch_zero_out <- function(out, self) {
  args <- mget(x = c("out", "self"))
expected_types <- list(out = "Tensor", self = "Tensor")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'zero_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_zeros
.torch_zeros <- function(size, names, options = list()) {
  args <- mget(x = c("size", "names", "options"))
expected_types <- list(size = "IntArrayRef", names = "DimnameList", options = "TensorOptions")
nd_args <- c("size", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'zeros',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname .torch_zeros_like
.torch_zeros_like <- function(self, options = list(), memory_format = NULL) {
  args <- mget(x = c("self", "options", "memory_format"))
expected_types <- list(self = "Tensor", options = "TensorOptions", memory_format = "MemoryFormat")
nd_args <- "self"
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'zeros_like',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_zeros_like_out
torch_zeros_like_out <- function(out, self, memory_format = NULL) {
  args <- mget(x = c("out", "self", "memory_format"))
expected_types <- list(out = "Tensor", self = "Tensor", memory_format = "MemoryFormat")
nd_args <- c("out", "self")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'zeros_like_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}


#' @rdname torch_zeros_out
torch_zeros_out <- function(out, size, names) {
  args <- mget(x = c("out", "size", "names"))
expected_types <- list(out = "Tensor", size = "IntArrayRef", names = "DimnameList")
nd_args <- c("out", "size", "names")
return_types <- list(list('Tensor'))
call_c_function(
fun_name = 'zeros_out',
args = args,
expected_types = expected_types,
nd_args = nd_args,
return_types = return_types,
fun_type = 'namespace'
)
}