/usr/local/lib64/python3.6/site-packages/torch/include/ATen
Edit: /usr/local/lib64/python3.6/site-packages/torch/include/ATen/Functions.h (846326B)
#pragma once
// @generated by tools/codegen/gen.py from Functions.h
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace at {
// These functions are defined in ATen/Utils.cpp.
#define TENSOR(T, S) \
TORCH_API Tensor tensor(ArrayRef values, const TensorOptions& options); \
inline Tensor tensor( \
std::initializer_list values, const TensorOptions& options) { \
return at::tensor(ArrayRef(values), options); \
} \
inline Tensor tensor(T value, const TensorOptions& options) { \
return at::tensor(ArrayRef(value), options); \
} \
inline Tensor tensor(ArrayRef values) { \
return at::tensor(std::move(values), at::dtype(k##S)); \
} \
inline Tensor tensor(std::initializer_list values) { \
return at::tensor(ArrayRef(values)); \
} \
inline Tensor tensor(T value) { \
return at::tensor(ArrayRef(value)); \
}
AT_FORALL_SCALAR_TYPES_AND3(Bool, Half, BFloat16, TENSOR)
AT_FORALL_COMPLEX_TYPES(TENSOR)
#undef TENSOR
// aten::_cast_Byte(Tensor self, bool non_blocking=False) -> Tensor
TORCH_API inline at::Tensor _cast_Byte(const at::Tensor & self, bool non_blocking=false) {
return at::_ops::_cast_Byte::call(self, non_blocking);
}
// aten::_cast_Char(Tensor self, bool non_blocking=False) -> Tensor
TORCH_API inline at::Tensor _cast_Char(const at::Tensor & self, bool non_blocking=false) {
return at::_ops::_cast_Char::call(self, non_blocking);
}
// aten::_cast_Double(Tensor self, bool non_blocking=False) -> Tensor
TORCH_API inline at::Tensor _cast_Double(const at::Tensor & self, bool non_blocking=false) {
return at::_ops::_cast_Double::call(self, non_blocking);
}
// aten::_cast_Float(Tensor self, bool non_blocking=False) -> Tensor
TORCH_API inline at::Tensor _cast_Float(const at::Tensor & self, bool non_blocking=false) {
return at::_ops::_cast_Float::call(self, non_blocking);
}
// aten::_cast_Int(Tensor self, bool non_blocking=False) -> Tensor
TORCH_API inline at::Tensor _cast_Int(const at::Tensor & self, bool non_blocking=false) {
return at::_ops::_cast_Int::call(self, non_blocking);
}
// aten::_cast_Long(Tensor self, bool non_blocking=False) -> Tensor
TORCH_API inline at::Tensor _cast_Long(const at::Tensor & self, bool non_blocking=false) {
return at::_ops::_cast_Long::call(self, non_blocking);
}
// aten::_cast_Short(Tensor self, bool non_blocking=False) -> Tensor
TORCH_API inline at::Tensor _cast_Short(const at::Tensor & self, bool non_blocking=false) {
return at::_ops::_cast_Short::call(self, non_blocking);
}
// aten::_cast_Half(Tensor self, bool non_blocking=False) -> Tensor
TORCH_API inline at::Tensor _cast_Half(const at::Tensor & self, bool non_blocking=false) {
return at::_ops::_cast_Half::call(self, non_blocking);
}
// aten::_make_dual(Tensor(a) primal, Tensor tangent, int level) -> Tensor(a)
TORCH_API inline at::Tensor _make_dual(const at::Tensor & primal, const at::Tensor & tangent, int64_t level) {
return at::_ops::_make_dual::call(primal, tangent, level);
}
// aten::_unpack_dual(Tensor(a) dual, int level) -> (Tensor(a) primal, Tensor tangent)
TORCH_API inline ::std::tuple _unpack_dual(const at::Tensor & dual, int64_t level) {
return at::_ops::_unpack_dual::call(dual, level);
}
// aten::align_tensors(Tensor[] tensors) -> Tensor[]
TORCH_API inline ::std::vector align_tensors(at::TensorList tensors) {
return at::_ops::align_tensors::call(tensors);
}
// aten::_assert_async(Tensor self) -> ()
TORCH_API inline void _assert_async(const at::Tensor & self) {
return at::_ops::_assert_async::call(self);
}
// aten::_use_cudnn_ctc_loss(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank) -> bool
TORCH_API inline bool _use_cudnn_ctc_loss(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank) {
return at::_ops::_use_cudnn_ctc_loss::call(log_probs, targets, input_lengths, target_lengths, blank);
}
// aten::_cudnn_ctc_loss(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank, bool deterministic, bool zero_infinity) -> (Tensor, Tensor)
TORCH_API inline ::std::tuple _cudnn_ctc_loss(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool deterministic, bool zero_infinity) {
return at::_ops::_cudnn_ctc_loss::call(log_probs, targets, input_lengths, target_lengths, blank, deterministic, zero_infinity);
}
// aten::_use_cudnn_rnn_flatten_weight() -> bool
TORCH_API inline bool _use_cudnn_rnn_flatten_weight() {
return at::_ops::_use_cudnn_rnn_flatten_weight::call();
}
// aten::_cudnn_rnn_flatten_weight(Tensor[] weight_arr, int weight_stride0, int input_size, int mode, int hidden_size, int proj_size, int num_layers, bool batch_first, bool bidirectional) -> Tensor
TORCH_API inline at::Tensor _cudnn_rnn_flatten_weight(at::TensorList weight_arr, int64_t weight_stride0, int64_t input_size, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, bool bidirectional) {
return at::_ops::_cudnn_rnn_flatten_weight::call(weight_arr, weight_stride0, input_size, mode, hidden_size, proj_size, num_layers, batch_first, bidirectional);
}
// aten::_cudnn_rnn(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, int hidden_size, int proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
TORCH_API inline ::std::tuple _cudnn_rnn(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state) {
return at::_ops::_cudnn_rnn::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state);
}
// aten::_cudnn_rnn_backward(Tensor input, Tensor[] weight, int weight_stride0, Tensor weight_buf, Tensor hx, Tensor? cx, Tensor output, Tensor? grad_output, Tensor? grad_hy, Tensor? grad_cy, int mode, int hidden_size, int proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state, Tensor reserve, bool[4] output_mask) -> (Tensor, Tensor, Tensor, Tensor[])
TORCH_API inline ::std::tuple> _cudnn_rnn_backward(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & weight_buf, const at::Tensor & hx, const c10::optional & cx, const at::Tensor & output, const c10::optional & grad_output, const c10::optional & grad_hy, const c10::optional & grad_cy, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state, const at::Tensor & reserve, ::std::array output_mask) {
return at::_ops::_cudnn_rnn_backward::call(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);
}
// aten::_cudnn_init_dropout_state(float dropout, bool train, int dropout_seed, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor
TORCH_API inline at::Tensor _cudnn_init_dropout_state(double dropout, bool train, int64_t dropout_seed, at::TensorOptions options) {
return at::_ops::_cudnn_init_dropout_state::call(dropout, train, dropout_seed, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
// aten::_cudnn_init_dropout_state(float dropout, bool train, int dropout_seed, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor
TORCH_API inline at::Tensor _cudnn_init_dropout_state(double dropout, bool train, int64_t dropout_seed, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) {
return at::_ops::_cudnn_init_dropout_state::call(dropout, train, dropout_seed, dtype, layout, device, pin_memory);
}
// aten::_debug_has_internal_overlap(Tensor self) -> int
TORCH_API inline int64_t _debug_has_internal_overlap(const at::Tensor & self) {
return at::_ops::_debug_has_internal_overlap::call(self);
}
// aten::_fused_dropout(Tensor self, float p, Generator? generator=None) -> (Tensor, Tensor)
TORCH_API inline ::std::tuple _fused_dropout(const at::Tensor & self, double p, c10::optional generator=c10::nullopt) {
return at::_ops::_fused_dropout::call(self, p, generator);
}
// aten::_masked_scale(Tensor self, Tensor mask, float scale) -> Tensor
TORCH_API inline at::Tensor _masked_scale(const at::Tensor & self, const at::Tensor & mask, double scale) {
return at::_ops::_masked_scale::call(self, mask, scale);
}
// aten::_sobol_engine_draw(Tensor quasi, int n, Tensor sobolstate, int dimension, int num_generated, ScalarType? dtype) -> (Tensor, Tensor)
TORCH_API inline ::std::tuple _sobol_engine_draw(const at::Tensor & quasi, int64_t n, const at::Tensor & sobolstate, int64_t dimension, int64_t num_generated, c10::optional dtype) {
return at::_ops::_sobol_engine_draw::call(quasi, n, sobolstate, dimension, num_generated, dtype);
}
// aten::_sobol_engine_ff_(Tensor(a!) self, int n, Tensor sobolstate, int dimension, int num_generated) -> Tensor(a!)
TORCH_API inline at::Tensor & _sobol_engine_ff_(at::Tensor & self, int64_t n, const at::Tensor & sobolstate, int64_t dimension, int64_t num_generated) {
return at::_ops::_sobol_engine_ff_::call(self, n, sobolstate, dimension, num_generated);
}
// aten::_sobol_engine_scramble_(Tensor(a!) self, Tensor ltm, int dimension) -> Tensor(a!)
TORCH_API inline at::Tensor & _sobol_engine_scramble_(at::Tensor & self, const at::Tensor & ltm, int64_t dimension) {
return at::_ops::_sobol_engine_scramble_::call(self, ltm, dimension);
}
// aten::_sobol_engine_initialize_state_(Tensor(a!) self, int dimension) -> Tensor(a!)
TORCH_API inline at::Tensor & _sobol_engine_initialize_state_(at::Tensor & self, int64_t dimension) {
return at::_ops::_sobol_engine_initialize_state_::call(self, dimension);
}
// aten::_reshape_from_tensor(Tensor self, Tensor shape) -> Tensor
TORCH_API inline at::Tensor _reshape_from_tensor(const at::Tensor & self, const at::Tensor & shape) {
return at::_ops::_reshape_from_tensor::call(self, shape);
}
// aten::_shape_as_tensor(Tensor self) -> Tensor
TORCH_API inline at::Tensor _shape_as_tensor(const at::Tensor & self) {
return at::_ops::_shape_as_tensor::call(self);
}
// aten::dropout(Tensor input, float p, bool train) -> Tensor
TORCH_API inline at::Tensor dropout(const at::Tensor & input, double p, bool train) {
return at::_ops::dropout::call(input, p, train);
}
// aten::dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!)
TORCH_API inline at::Tensor & dropout_(at::Tensor & self, double p, bool train) {
return at::_ops::dropout_::call(self, p, train);
}
// aten::feature_dropout(Tensor input, float p, bool train) -> Tensor
TORCH_API inline at::Tensor feature_dropout(const at::Tensor & input, double p, bool train) {
return at::_ops::feature_dropout::call(input, p, train);
}
// aten::feature_dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!)
TORCH_API inline at::Tensor & feature_dropout_(at::Tensor & self, double p, bool train) {
return at::_ops::feature_dropout_::call(self, p, train);
}
// aten::alpha_dropout(Tensor input, float p, bool train) -> Tensor
TORCH_API inline at::Tensor alpha_dropout(const at::Tensor & input, double p, bool train) {
return at::_ops::alpha_dropout::call(input, p, train);
}
// aten::alpha_dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!)
TORCH_API inline at::Tensor & alpha_dropout_(at::Tensor & self, double p, bool train) {
return at::_ops::alpha_dropout_::call(self, p, train);
}
// aten::feature_alpha_dropout(Tensor input, float p, bool train) -> Tensor
TORCH_API inline at::Tensor feature_alpha_dropout(const at::Tensor & input, double p, bool train) {
return at::_ops::feature_alpha_dropout::call(input, p, train);
}
// aten::feature_alpha_dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!)
TORCH_API inline at::Tensor & feature_alpha_dropout_(at::Tensor & self, double p, bool train) {
return at::_ops::feature_alpha_dropout_::call(self, p, train);
}
// aten::abs(Tensor self) -> Tensor
TORCH_API inline at::Tensor abs(const at::Tensor & self) {
return at::_ops::abs::call(self);
}
// aten::abs_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & abs_(at::Tensor & self) {
return at::_ops::abs_::call(self);
}
// aten::abs.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & abs_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::abs_out::call(self, out);
}
// aten::abs.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & abs_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::abs_out::call(self, out);
}
// aten::absolute(Tensor self) -> Tensor
TORCH_API inline at::Tensor absolute(const at::Tensor & self) {
return at::_ops::absolute::call(self);
}
// aten::absolute.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & absolute_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::absolute_out::call(self, out);
}
// aten::absolute.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & absolute_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::absolute_out::call(self, out);
}
// aten::angle(Tensor self) -> Tensor
TORCH_API inline at::Tensor angle(const at::Tensor & self) {
return at::_ops::angle::call(self);
}
// aten::angle.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & angle_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::angle_out::call(self, out);
}
// aten::angle.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & angle_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::angle_out::call(self, out);
}
// aten::view_as_real(Tensor(a) self) -> Tensor(a)
TORCH_API inline at::Tensor view_as_real(const at::Tensor & self) {
return at::_ops::view_as_real::call(self);
}
// aten::view_as_complex(Tensor(a) self) -> Tensor(a)
TORCH_API inline at::Tensor view_as_complex(const at::Tensor & self) {
return at::_ops::view_as_complex::call(self);
}
// aten::sgn(Tensor self) -> Tensor
TORCH_API inline at::Tensor sgn(const at::Tensor & self) {
return at::_ops::sgn::call(self);
}
// aten::sgn.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & sgn_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::sgn_out::call(self, out);
}
// aten::sgn.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & sgn_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::sgn_out::call(self, out);
}
// aten::real(Tensor(a) self) -> Tensor(a)
TORCH_API inline at::Tensor real(const at::Tensor & self) {
return at::_ops::real::call(self);
}
// aten::imag(Tensor(a) self) -> Tensor(a)
TORCH_API inline at::Tensor imag(const at::Tensor & self) {
return at::_ops::imag::call(self);
}
// aten::_conj(Tensor(a) self) -> Tensor(a)
TORCH_API inline at::Tensor _conj(const at::Tensor & self) {
return at::_ops::_conj::call(self);
}
// aten::conj(Tensor(a) self) -> Tensor(a)
TORCH_API inline at::Tensor __dispatch_conj(const at::Tensor & self) {
return at::_ops::conj::call(self);
}
// aten::_conj_physical(Tensor self) -> Tensor
TORCH_API inline at::Tensor _conj_physical(const at::Tensor & self) {
return at::_ops::_conj_physical::call(self);
}
// aten::conj_physical(Tensor self) -> Tensor
TORCH_API inline at::Tensor conj_physical(const at::Tensor & self) {
return at::_ops::conj_physical::call(self);
}
// aten::conj_physical.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & conj_physical_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::conj_physical_out::call(self, out);
}
// aten::conj_physical.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & conj_physical_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::conj_physical_out::call(self, out);
}
// aten::conj_physical_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & conj_physical_(at::Tensor & self) {
return at::_ops::conj_physical_::call(self);
}
// aten::resolve_conj(Tensor(a) self) -> Tensor(a)
TORCH_API inline at::Tensor resolve_conj(const at::Tensor & self) {
return at::_ops::resolve_conj::call(self);
}
// aten::resolve_neg(Tensor(a) self) -> Tensor(a)
TORCH_API inline at::Tensor resolve_neg(const at::Tensor & self) {
return at::_ops::resolve_neg::call(self);
}
// aten::_neg_view(Tensor(a) self) -> Tensor(a)
TORCH_API inline at::Tensor _neg_view(const at::Tensor & self) {
return at::_ops::_neg_view::call(self);
}
// aten::acos(Tensor self) -> Tensor
TORCH_API inline at::Tensor acos(const at::Tensor & self) {
return at::_ops::acos::call(self);
}
// aten::acos_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & acos_(at::Tensor & self) {
return at::_ops::acos_::call(self);
}
// aten::acos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & acos_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::acos_out::call(self, out);
}
// aten::acos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & acos_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::acos_out::call(self, out);
}
// aten::arccos(Tensor self) -> Tensor
TORCH_API inline at::Tensor arccos(const at::Tensor & self) {
return at::_ops::arccos::call(self);
}
// aten::arccos_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & arccos_(at::Tensor & self) {
return at::_ops::arccos_::call(self);
}
// aten::arccos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arccos_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::arccos_out::call(self, out);
}
// aten::arccos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arccos_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::arccos_out::call(self, out);
}
// aten::avg_pool1d(Tensor self, int[1] kernel_size, int[1] stride=[], int[1] padding=0, bool ceil_mode=False, bool count_include_pad=True) -> Tensor
TORCH_API inline at::Tensor avg_pool1d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride={}, at::IntArrayRef padding=0, bool ceil_mode=false, bool count_include_pad=true) {
return at::_ops::avg_pool1d::call(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
// aten::adaptive_avg_pool1d(Tensor self, int[1] output_size) -> Tensor
TORCH_API inline at::Tensor adaptive_avg_pool1d(const at::Tensor & self, at::IntArrayRef output_size) {
return at::_ops::adaptive_avg_pool1d::call(self, output_size);
}
// aten::adaptive_max_pool1d(Tensor self, int[1] output_size) -> (Tensor, Tensor)
TORCH_API inline ::std::tuple adaptive_max_pool1d(const at::Tensor & self, at::IntArrayRef output_size) {
return at::_ops::adaptive_max_pool1d::call(self, output_size);
}
// aten::add.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor
TORCH_API inline at::Tensor add(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha=1) {
return at::_ops::add_Tensor::call(self, other, alpha);
}
// aten::add.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & add_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha=1) {
return at::_ops::add_out::call(self, other, alpha, out);
}
// aten::add.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & add_outf(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha, at::Tensor & out) {
return at::_ops::add_out::call(self, other, alpha, out);
}
// aten::_add_relu.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor
TORCH_API inline at::Tensor _add_relu(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha=1) {
return at::_ops::_add_relu_Tensor::call(self, other, alpha);
}
// aten::_add_relu_.Tensor(Tensor(a!) self, Tensor other, *, Scalar alpha=1) -> Tensor(a!)
TORCH_API inline at::Tensor & _add_relu_(at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha=1) {
return at::_ops::_add_relu__Tensor::call(self, other, alpha);
}
// aten::_add_relu.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & _add_relu_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha=1) {
return at::_ops::_add_relu_out::call(self, other, alpha, out);
}
// aten::_add_relu.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & _add_relu_outf(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha, at::Tensor & out) {
return at::_ops::_add_relu_out::call(self, other, alpha, out);
}
// aten::_add_relu.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor
TORCH_API inline at::Tensor _add_relu(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha=1) {
return at::_ops::_add_relu_Scalar::call(self, other, alpha);
}
// aten::_add_relu_.Scalar(Tensor(a!) self, Scalar other, Scalar alpha=1) -> Tensor(a!)
TORCH_API inline at::Tensor & _add_relu_(at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha=1) {
return at::_ops::_add_relu__Scalar::call(self, other, alpha);
}
// aten::add.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor
TORCH_API inline at::Tensor add(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha=1) {
return at::_ops::add_Scalar::call(self, other, alpha);
}
// aten::addmv(Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1) -> Tensor
TORCH_API inline at::Tensor addmv(const at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta=1, const at::Scalar & alpha=1) {
return at::_ops::addmv::call(self, mat, vec, beta, alpha);
}
// aten::addmv_(Tensor(a!) self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!)
TORCH_API inline at::Tensor & addmv_(at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta=1, const at::Scalar & alpha=1) {
return at::_ops::addmv_::call(self, mat, vec, beta, alpha);
}
// aten::addmv.out(Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & addmv_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta=1, const at::Scalar & alpha=1) {
return at::_ops::addmv_out::call(self, mat, vec, beta, alpha, out);
}
// aten::addmv.out(Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & addmv_outf(const at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) {
return at::_ops::addmv_out::call(self, mat, vec, beta, alpha, out);
}
// aten::addr(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
TORCH_API inline at::Tensor addr(const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta=1, const at::Scalar & alpha=1) {
return at::_ops::addr::call(self, vec1, vec2, beta, alpha);
}
// aten::addr.out(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & addr_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta=1, const at::Scalar & alpha=1) {
return at::_ops::addr_out::call(self, vec1, vec2, beta, alpha, out);
}
// aten::addr.out(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & addr_outf(const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) {
return at::_ops::addr_out::call(self, vec1, vec2, beta, alpha, out);
}
// aten::affine_grid_generator(Tensor theta, int[] size, bool align_corners) -> Tensor
TORCH_API inline at::Tensor affine_grid_generator(const at::Tensor & theta, at::IntArrayRef size, bool align_corners) {
return at::_ops::affine_grid_generator::call(theta, size, align_corners);
}
// aten::affine_grid_generator_backward(Tensor grad, int[] size, bool align_corners) -> Tensor
TORCH_API inline at::Tensor affine_grid_generator_backward(const at::Tensor & grad, at::IntArrayRef size, bool align_corners) {
return at::_ops::affine_grid_generator_backward::call(grad, size, align_corners);
}
// aten::all.dim(Tensor self, int dim, bool keepdim=False) -> Tensor
TORCH_API inline at::Tensor all(const at::Tensor & self, int64_t dim, bool keepdim=false) {
return at::_ops::all_dim::call(self, dim, keepdim);
}
// aten::all.out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & all_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool keepdim=false) {
return at::_ops::all_out::call(self, dim, keepdim, out);
}
// aten::all.out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & all_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & out) {
return at::_ops::all_out::call(self, dim, keepdim, out);
}
// aten::all.dimname(Tensor self, Dimname dim, bool keepdim=False) -> Tensor
TORCH_API inline at::Tensor all(const at::Tensor & self, at::Dimname dim, bool keepdim=false) {
return at::_ops::all_dimname::call(self, dim, keepdim);
}
// aten::all.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & all_out(at::Tensor & out, const at::Tensor & self, at::Dimname dim, bool keepdim=false) {
return at::_ops::all_dimname_out::call(self, dim, keepdim, out);
}
// aten::all.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & all_outf(const at::Tensor & self, at::Dimname dim, bool keepdim, at::Tensor & out) {
return at::_ops::all_dimname_out::call(self, dim, keepdim, out);
}
// aten::allclose(Tensor self, Tensor other, float rtol=1e-05, float atol=1e-08, bool equal_nan=False) -> bool
TORCH_API inline bool allclose(const at::Tensor & self, const at::Tensor & other, double rtol=1e-05, double atol=1e-08, bool equal_nan=false) {
return at::_ops::allclose::call(self, other, rtol, atol, equal_nan);
}
// aten::any.dim(Tensor self, int dim, bool keepdim=False) -> Tensor
TORCH_API inline at::Tensor any(const at::Tensor & self, int64_t dim, bool keepdim=false) {
return at::_ops::any_dim::call(self, dim, keepdim);
}
// aten::any.out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & any_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool keepdim=false) {
return at::_ops::any_out::call(self, dim, keepdim, out);
}
// aten::any.out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & any_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & out) {
return at::_ops::any_out::call(self, dim, keepdim, out);
}
// aten::any.dimname(Tensor self, Dimname dim, bool keepdim=False) -> Tensor
TORCH_API inline at::Tensor any(const at::Tensor & self, at::Dimname dim, bool keepdim=false) {
return at::_ops::any_dimname::call(self, dim, keepdim);
}
// aten::any.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & any_out(at::Tensor & out, const at::Tensor & self, at::Dimname dim, bool keepdim=false) {
return at::_ops::any_dimname_out::call(self, dim, keepdim, out);
}
// aten::any.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & any_outf(const at::Tensor & self, at::Dimname dim, bool keepdim, at::Tensor & out) {
return at::_ops::any_dimname_out::call(self, dim, keepdim, out);
}
// aten::arange(Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor arange(const at::Scalar & end, at::TensorOptions options={}) {
return at::_ops::arange::call(end, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
// aten::arange(Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor arange(const at::Scalar & end, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) {
return at::_ops::arange::call(end, dtype, layout, device, pin_memory);
}
// aten::arange.start(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor arange(const at::Scalar & start, const at::Scalar & end, at::TensorOptions options={}) {
return at::_ops::arange_start::call(start, end, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
// aten::arange.start(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor arange(const at::Scalar & start, const at::Scalar & end, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) {
return at::_ops::arange_start::call(start, end, dtype, layout, device, pin_memory);
}
// aten::arange.start_step(Scalar start, Scalar end, Scalar step, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor arange(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::TensorOptions options={}) {
return at::_ops::arange_start_step::call(start, end, step, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
// aten::arange.start_step(Scalar start, Scalar end, Scalar step, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor arange(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) {
return at::_ops::arange_start_step::call(start, end, step, dtype, layout, device, pin_memory);
}
// aten::arange.out(Scalar end, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arange_out(at::Tensor & out, const at::Scalar & end) {
return at::_ops::arange_out::call(end, out);
}
// aten::arange.out(Scalar end, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arange_outf(const at::Scalar & end, at::Tensor & out) {
return at::_ops::arange_out::call(end, out);
}
// aten::arange.start_out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arange_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end, const at::Scalar & step=1) {
return at::_ops::arange_start_out::call(start, end, step, out);
}
// aten::arange.start_out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arange_outf(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::Tensor & out) {
return at::_ops::arange_start_out::call(start, end, step, out);
}
// aten::_dim_arange(Tensor like, int dim) -> Tensor
TORCH_API inline at::Tensor _dim_arange(const at::Tensor & like, int64_t dim) {
return at::_ops::_dim_arange::call(like, dim);
}
// aten::argmax(Tensor self, int? dim=None, bool keepdim=False) -> Tensor
TORCH_API inline at::Tensor argmax(const at::Tensor & self, c10::optional dim=c10::nullopt, bool keepdim=false) {
return at::_ops::argmax::call(self, dim, keepdim);
}
// aten::argmax.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & argmax_out(at::Tensor & out, const at::Tensor & self, c10::optional dim=c10::nullopt, bool keepdim=false) {
return at::_ops::argmax_out::call(self, dim, keepdim, out);
}
// aten::argmax.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & argmax_outf(const at::Tensor & self, c10::optional dim, bool keepdim, at::Tensor & out) {
return at::_ops::argmax_out::call(self, dim, keepdim, out);
}
// aten::argmin(Tensor self, int? dim=None, bool keepdim=False) -> Tensor
TORCH_API inline at::Tensor argmin(const at::Tensor & self, c10::optional dim=c10::nullopt, bool keepdim=false) {
return at::_ops::argmin::call(self, dim, keepdim);
}
// aten::argmin.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & argmin_out(at::Tensor & out, const at::Tensor & self, c10::optional dim=c10::nullopt, bool keepdim=false) {
return at::_ops::argmin_out::call(self, dim, keepdim, out);
}
// aten::argmin.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & argmin_outf(const at::Tensor & self, c10::optional dim, bool keepdim, at::Tensor & out) {
return at::_ops::argmin_out::call(self, dim, keepdim, out);
}
// aten::acosh(Tensor self) -> Tensor
TORCH_API inline at::Tensor acosh(const at::Tensor & self) {
return at::_ops::acosh::call(self);
}
// aten::acosh_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & acosh_(at::Tensor & self) {
return at::_ops::acosh_::call(self);
}
// aten::acosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & acosh_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::acosh_out::call(self, out);
}
// aten::acosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & acosh_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::acosh_out::call(self, out);
}
// aten::arccosh(Tensor self) -> Tensor
TORCH_API inline at::Tensor arccosh(const at::Tensor & self) {
return at::_ops::arccosh::call(self);
}
// aten::arccosh_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & arccosh_(at::Tensor & self) {
return at::_ops::arccosh_::call(self);
}
// aten::arccosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arccosh_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::arccosh_out::call(self, out);
}
// aten::arccosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arccosh_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::arccosh_out::call(self, out);
}
// aten::asinh(Tensor self) -> Tensor
TORCH_API inline at::Tensor asinh(const at::Tensor & self) {
return at::_ops::asinh::call(self);
}
// aten::asinh_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & asinh_(at::Tensor & self) {
return at::_ops::asinh_::call(self);
}
// aten::asinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & asinh_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::asinh_out::call(self, out);
}
// aten::asinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & asinh_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::asinh_out::call(self, out);
}
// aten::arcsinh(Tensor self) -> Tensor
TORCH_API inline at::Tensor arcsinh(const at::Tensor & self) {
return at::_ops::arcsinh::call(self);
}
// aten::arcsinh_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & arcsinh_(at::Tensor & self) {
return at::_ops::arcsinh_::call(self);
}
// aten::arcsinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arcsinh_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::arcsinh_out::call(self, out);
}
// aten::arcsinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arcsinh_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::arcsinh_out::call(self, out);
}
// aten::atanh(Tensor self) -> Tensor
TORCH_API inline at::Tensor atanh(const at::Tensor & self) {
return at::_ops::atanh::call(self);
}
// aten::atanh_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & atanh_(at::Tensor & self) {
return at::_ops::atanh_::call(self);
}
// aten::atanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & atanh_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::atanh_out::call(self, out);
}
// aten::atanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & atanh_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::atanh_out::call(self, out);
}
// aten::arctanh(Tensor self) -> Tensor
TORCH_API inline at::Tensor arctanh(const at::Tensor & self) {
return at::_ops::arctanh::call(self);
}
// aten::arctanh_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & arctanh_(at::Tensor & self) {
return at::_ops::arctanh_::call(self);
}
// aten::arctanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arctanh_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::arctanh_out::call(self, out);
}
// aten::arctanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arctanh_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::arctanh_out::call(self, out);
}
// aten::as_strided(Tensor(a) self, int[] size, int[] stride, int? storage_offset=None) -> Tensor(a)
TORCH_API inline at::Tensor as_strided(const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride, c10::optional storage_offset=c10::nullopt) {
return at::_ops::as_strided::call(self, size, stride, storage_offset);
}
// aten::as_strided_(Tensor(a!) self, int[] size, int[] stride, int? storage_offset=None) -> Tensor(a!)
TORCH_API inline const at::Tensor & as_strided_(const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride, c10::optional storage_offset=c10::nullopt) {
return at::_ops::as_strided_::call(self, size, stride, storage_offset);
}
// aten::asin(Tensor self) -> Tensor
TORCH_API inline at::Tensor asin(const at::Tensor & self) {
return at::_ops::asin::call(self);
}
// aten::asin_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & asin_(at::Tensor & self) {
return at::_ops::asin_::call(self);
}
// aten::asin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & asin_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::asin_out::call(self, out);
}
// aten::asin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & asin_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::asin_out::call(self, out);
}
// aten::arcsin(Tensor self) -> Tensor
TORCH_API inline at::Tensor arcsin(const at::Tensor & self) {
return at::_ops::arcsin::call(self);
}
// aten::arcsin_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & arcsin_(at::Tensor & self) {
return at::_ops::arcsin_::call(self);
}
// aten::arcsin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arcsin_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::arcsin_out::call(self, out);
}
// aten::arcsin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arcsin_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::arcsin_out::call(self, out);
}
// aten::atan(Tensor self) -> Tensor
TORCH_API inline at::Tensor atan(const at::Tensor & self) {
return at::_ops::atan::call(self);
}
// aten::atan_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & atan_(at::Tensor & self) {
return at::_ops::atan_::call(self);
}
// aten::atan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & atan_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::atan_out::call(self, out);
}
// aten::atan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & atan_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::atan_out::call(self, out);
}
// aten::arctan(Tensor self) -> Tensor
TORCH_API inline at::Tensor arctan(const at::Tensor & self) {
return at::_ops::arctan::call(self);
}
// aten::arctan_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & arctan_(at::Tensor & self) {
return at::_ops::arctan_::call(self);
}
// aten::arctan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arctan_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::arctan_out::call(self, out);
}
// aten::arctan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & arctan_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::arctan_out::call(self, out);
}
// aten::atleast_1d(Tensor self) -> Tensor
TORCH_API inline at::Tensor atleast_1d(const at::Tensor & self) {
return at::_ops::atleast_1d::call(self);
}
// aten::atleast_1d.Sequence(Tensor[] tensors) -> Tensor[]
TORCH_API inline ::std::vector atleast_1d(at::TensorList tensors) {
return at::_ops::atleast_1d_Sequence::call(tensors);
}
// aten::atleast_2d(Tensor self) -> Tensor
TORCH_API inline at::Tensor atleast_2d(const at::Tensor & self) {
return at::_ops::atleast_2d::call(self);
}
// aten::atleast_2d.Sequence(Tensor[] tensors) -> Tensor[]
TORCH_API inline ::std::vector atleast_2d(at::TensorList tensors) {
return at::_ops::atleast_2d_Sequence::call(tensors);
}
// aten::atleast_3d(Tensor self) -> Tensor
TORCH_API inline at::Tensor atleast_3d(const at::Tensor & self) {
return at::_ops::atleast_3d::call(self);
}
// aten::atleast_3d.Sequence(Tensor[] tensors) -> Tensor[]
TORCH_API inline ::std::vector atleast_3d(at::TensorList tensors) {
return at::_ops::atleast_3d_Sequence::call(tensors);
}
// aten::baddbmm(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
TORCH_API inline at::Tensor baddbmm(const at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta=1, const at::Scalar & alpha=1) {
return at::_ops::baddbmm::call(self, batch1, batch2, beta, alpha);
}
// aten::_baddbmm_mkl_(Tensor(a!) self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!)
TORCH_API inline at::Tensor & _baddbmm_mkl_(at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta=1, const at::Scalar & alpha=1) {
return at::_ops::_baddbmm_mkl_::call(self, batch1, batch2, beta, alpha);
}
// aten::baddbmm.out(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & baddbmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta=1, const at::Scalar & alpha=1) {
return at::_ops::baddbmm_out::call(self, batch1, batch2, beta, alpha, out);
}
// aten::baddbmm.out(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & baddbmm_outf(const at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) {
return at::_ops::baddbmm_out::call(self, batch1, batch2, beta, alpha, out);
}
// aten::bartlett_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor bartlett_window(int64_t window_length, at::TensorOptions options={}) {
return at::_ops::bartlett_window::call(window_length, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
// aten::bartlett_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor bartlett_window(int64_t window_length, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) {
return at::_ops::bartlett_window::call(window_length, dtype, layout, device, pin_memory);
}
// aten::bartlett_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor bartlett_window(int64_t window_length, bool periodic, at::TensorOptions options={}) {
return at::_ops::bartlett_window_periodic::call(window_length, periodic, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
// aten::bartlett_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor bartlett_window(int64_t window_length, bool periodic, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) {
return at::_ops::bartlett_window_periodic::call(window_length, periodic, dtype, layout, device, pin_memory);
}
// aten::batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps, bool cudnn_enabled) -> Tensor
TORCH_API inline at::Tensor batch_norm(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, const c10::optional & running_mean, const c10::optional & running_var, bool training, double momentum, double eps, bool cudnn_enabled) {
return at::_ops::batch_norm::call(input, weight, bias, running_mean, running_var, training, momentum, eps, cudnn_enabled);
}
// aten::quantized_batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor mean, Tensor var, float eps, float output_scale, int output_zero_point) -> Tensor
TORCH_API inline at::Tensor quantized_batch_norm(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, const at::Tensor & mean, const at::Tensor & var, double eps, double output_scale, int64_t output_zero_point) {
return at::_ops::quantized_batch_norm::call(input, weight, bias, mean, var, eps, output_scale, output_zero_point);
}
// aten::_batch_norm_impl_index(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps, bool cudnn_enabled) -> (Tensor, Tensor, Tensor, Tensor, int)
TORCH_API inline ::std::tuple _batch_norm_impl_index(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, const c10::optional & running_mean, const c10::optional & running_var, bool training, double momentum, double eps, bool cudnn_enabled) {
return at::_ops::_batch_norm_impl_index::call(input, weight, bias, running_mean, running_var, training, momentum, eps, cudnn_enabled);
}
// aten::_batch_norm_impl_index_backward(int impl_index, Tensor input, Tensor grad_output, Tensor? weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var_transform, bool train, float eps, bool[3] output_mask, Tensor reservedSpace) -> (Tensor, Tensor, Tensor)
TORCH_API inline ::std::tuple _batch_norm_impl_index_backward(int64_t impl_index, const at::Tensor & input, const at::Tensor & grad_output, const c10::optional & weight, const c10::optional & running_mean, const c10::optional & running_var, const c10::optional & save_mean, const c10::optional & save_var_transform, bool train, double eps, ::std::array output_mask, const at::Tensor & reservedSpace) {
return at::_ops::_batch_norm_impl_index_backward::call(impl_index, input, grad_output, weight, running_mean, running_var, save_mean, save_var_transform, train, eps, output_mask, reservedSpace);
}
// aten::bernoulli(Tensor self, *, Generator? generator=None) -> Tensor
TORCH_API inline at::Tensor bernoulli(const at::Tensor & self, c10::optional generator=c10::nullopt) {
return at::_ops::bernoulli::call(self, generator);
}
// aten::bernoulli.out(Tensor self, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, c10::optional generator=c10::nullopt) {
return at::_ops::bernoulli_out::call(self, generator, out);
}
// aten::bernoulli.out(Tensor self, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & bernoulli_outf(const at::Tensor & self, c10::optional generator, at::Tensor & out) {
return at::_ops::bernoulli_out::call(self, generator, out);
}
// aten::bernoulli.p(Tensor self, float p, *, Generator? generator=None) -> Tensor
TORCH_API inline at::Tensor bernoulli(const at::Tensor & self, double p, c10::optional generator=c10::nullopt) {
return at::_ops::bernoulli_p::call(self, p, generator);
}
// aten::bilinear(Tensor input1, Tensor input2, Tensor weight, Tensor? bias) -> Tensor
TORCH_API inline at::Tensor bilinear(const at::Tensor & input1, const at::Tensor & input2, const at::Tensor & weight, const c10::optional & bias) {
return at::_ops::bilinear::call(input1, input2, weight, bias);
}
// aten::binary_cross_entropy(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor
TORCH_API inline at::Tensor binary_cross_entropy(const at::Tensor & self, const at::Tensor & target, const c10::optional & weight={}, int64_t reduction=at::Reduction::Mean) {
return at::_ops::binary_cross_entropy::call(self, target, weight, reduction);
}
// aten::binary_cross_entropy.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & binary_cross_entropy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, const c10::optional & weight={}, int64_t reduction=at::Reduction::Mean) {
return at::_ops::binary_cross_entropy_out::call(self, target, weight, reduction, out);
}
// aten::binary_cross_entropy.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & binary_cross_entropy_outf(const at::Tensor & self, const at::Tensor & target, const c10::optional & weight, int64_t reduction, at::Tensor & out) {
return at::_ops::binary_cross_entropy_out::call(self, target, weight, reduction, out);
}
// aten::binary_cross_entropy_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor
TORCH_API inline at::Tensor binary_cross_entropy_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const c10::optional & weight={}, int64_t reduction=at::Reduction::Mean) {
return at::_ops::binary_cross_entropy_backward::call(grad_output, self, target, weight, reduction);
}
// aten::binary_cross_entropy_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) grad_input) -> Tensor(a!)
TORCH_API inline at::Tensor & binary_cross_entropy_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const c10::optional & weight={}, int64_t reduction=at::Reduction::Mean) {
return at::_ops::binary_cross_entropy_backward_grad_input::call(grad_output, self, target, weight, reduction, grad_input);
}
// aten::binary_cross_entropy_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) grad_input) -> Tensor(a!)
TORCH_API inline at::Tensor & binary_cross_entropy_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const c10::optional & weight, int64_t reduction, at::Tensor & grad_input) {
return at::_ops::binary_cross_entropy_backward_grad_input::call(grad_output, self, target, weight, reduction, grad_input);
}
// aten::binary_cross_entropy_with_logits(Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean) -> Tensor
TORCH_API inline at::Tensor binary_cross_entropy_with_logits(const at::Tensor & self, const at::Tensor & target, const c10::optional & weight={}, const c10::optional & pos_weight={}, int64_t reduction=at::Reduction::Mean) {
return at::_ops::binary_cross_entropy_with_logits::call(self, target, weight, pos_weight, reduction);
}
// aten::binary_cross_entropy_with_logits_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean) -> Tensor
TORCH_API inline at::Tensor binary_cross_entropy_with_logits_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const c10::optional & weight={}, const c10::optional & pos_weight={}, int64_t reduction=at::Reduction::Mean) {
return at::_ops::binary_cross_entropy_with_logits_backward::call(grad_output, self, target, weight, pos_weight, reduction);
}
// aten::bincount(Tensor self, Tensor? weights=None, int minlength=0) -> Tensor
TORCH_API inline at::Tensor bincount(const at::Tensor & self, const c10::optional & weights={}, int64_t minlength=0) {
return at::_ops::bincount::call(self, weights, minlength);
}
// aten::bitwise_not(Tensor self) -> Tensor
TORCH_API inline at::Tensor bitwise_not(const at::Tensor & self) {
return at::_ops::bitwise_not::call(self);
}
// aten::bitwise_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & bitwise_not_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::bitwise_not_out::call(self, out);
}
// aten::bitwise_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & bitwise_not_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::bitwise_not_out::call(self, out);
}
// aten::copysign.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & copysign_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return at::_ops::copysign_out::call(self, other, out);
}
// aten::copysign.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & copysign_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return at::_ops::copysign_out::call(self, other, out);
}
// aten::copysign.Tensor(Tensor self, Tensor other) -> Tensor
TORCH_API inline at::Tensor copysign(const at::Tensor & self, const at::Tensor & other) {
return at::_ops::copysign_Tensor::call(self, other);
}
// aten::copysign.Scalar(Tensor self, Scalar other) -> Tensor
TORCH_API inline at::Tensor copysign(const at::Tensor & self, const at::Scalar & other) {
return at::_ops::copysign_Scalar::call(self, other);
}
// aten::copysign.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & copysign_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return at::_ops::copysign_Scalar_out::call(self, other, out);
}
// aten::copysign.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & copysign_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return at::_ops::copysign_Scalar_out::call(self, other, out);
}
// aten::logical_not(Tensor self) -> Tensor
TORCH_API inline at::Tensor logical_not(const at::Tensor & self) {
return at::_ops::logical_not::call(self);
}
// aten::logical_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & logical_not_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::logical_not_out::call(self, out);
}
// aten::logical_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & logical_not_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::logical_not_out::call(self, out);
}
// aten::logical_xor(Tensor self, Tensor other) -> Tensor
TORCH_API inline at::Tensor logical_xor(const at::Tensor & self, const at::Tensor & other) {
return at::_ops::logical_xor::call(self, other);
}
// aten::logical_xor.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & logical_xor_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return at::_ops::logical_xor_out::call(self, other, out);
}
// aten::logical_xor.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & logical_xor_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return at::_ops::logical_xor_out::call(self, other, out);
}
// aten::logical_and(Tensor self, Tensor other) -> Tensor
TORCH_API inline at::Tensor logical_and(const at::Tensor & self, const at::Tensor & other) {
return at::_ops::logical_and::call(self, other);
}
// aten::logical_and.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & logical_and_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return at::_ops::logical_and_out::call(self, other, out);
}
// aten::logical_and.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & logical_and_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return at::_ops::logical_and_out::call(self, other, out);
}
// aten::logical_or(Tensor self, Tensor other) -> Tensor
TORCH_API inline at::Tensor logical_or(const at::Tensor & self, const at::Tensor & other) {
return at::_ops::logical_or::call(self, other);
}
// aten::logical_or.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & logical_or_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return at::_ops::logical_or_out::call(self, other, out);
}
// aten::logical_or.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & logical_or_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return at::_ops::logical_or_out::call(self, other, out);
}
// aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor blackman_window(int64_t window_length, at::TensorOptions options={}) {
return at::_ops::blackman_window::call(window_length, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
// aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor blackman_window(int64_t window_length, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) {
return at::_ops::blackman_window::call(window_length, dtype, layout, device, pin_memory);
}
// aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor blackman_window(int64_t window_length, bool periodic, at::TensorOptions options={}) {
return at::_ops::blackman_window_periodic::call(window_length, periodic, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
// aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
TORCH_API inline at::Tensor blackman_window(int64_t window_length, bool periodic, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) {
return at::_ops::blackman_window_periodic::call(window_length, periodic, dtype, layout, device, pin_memory);
}
// aten::bmm(Tensor self, Tensor mat2) -> Tensor
TORCH_API inline at::Tensor bmm(const at::Tensor & self, const at::Tensor & mat2) {
return at::_ops::bmm::call(self, mat2);
}
// aten::bmm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & bmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat2) {
return at::_ops::bmm_out::call(self, mat2, out);
}
// aten::bmm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & bmm_outf(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out) {
return at::_ops::bmm_out::call(self, mat2, out);
}
// aten::broadcast_tensors(Tensor[] tensors) -> Tensor[]
TORCH_API inline ::std::vector broadcast_tensors(at::TensorList tensors) {
return at::_ops::broadcast_tensors::call(tensors);
}
// aten::broadcast_to(Tensor(a) self, int[] size) -> Tensor(a)
TORCH_API inline at::Tensor broadcast_to(const at::Tensor & self, at::IntArrayRef size) {
return at::_ops::broadcast_to::call(self, size);
}
// aten::cat(Tensor[] tensors, int dim=0) -> Tensor
TORCH_API inline at::Tensor cat(at::TensorList tensors, int64_t dim=0) {
return at::_ops::cat::call(tensors, dim);
}
// aten::cat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cat_out(at::Tensor & out, at::TensorList tensors, int64_t dim=0) {
return at::_ops::cat_out::call(tensors, dim, out);
}
// aten::cat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cat_outf(at::TensorList tensors, int64_t dim, at::Tensor & out) {
return at::_ops::cat_out::call(tensors, dim, out);
}
// aten::cat.names(Tensor[] tensors, Dimname dim) -> Tensor
TORCH_API inline at::Tensor cat(at::TensorList tensors, at::Dimname dim) {
return at::_ops::cat_names::call(tensors, dim);
}
// aten::cat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cat_out(at::Tensor & out, at::TensorList tensors, at::Dimname dim) {
return at::_ops::cat_names_out::call(tensors, dim, out);
}
// aten::cat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cat_outf(at::TensorList tensors, at::Dimname dim, at::Tensor & out) {
return at::_ops::cat_names_out::call(tensors, dim, out);
}
// aten::concat(Tensor[] tensors, int dim=0) -> Tensor
TORCH_API inline at::Tensor concat(at::TensorList tensors, int64_t dim=0) {
return at::_ops::concat::call(tensors, dim);
}
// aten::concat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & concat_out(at::Tensor & out, at::TensorList tensors, int64_t dim=0) {
return at::_ops::concat_out::call(tensors, dim, out);
}
// aten::concat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & concat_outf(at::TensorList tensors, int64_t dim, at::Tensor & out) {
return at::_ops::concat_out::call(tensors, dim, out);
}
// aten::concat.names(Tensor[] tensors, Dimname dim) -> Tensor
TORCH_API inline at::Tensor concat(at::TensorList tensors, at::Dimname dim) {
return at::_ops::concat_names::call(tensors, dim);
}
// aten::concat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & concat_out(at::Tensor & out, at::TensorList tensors, at::Dimname dim) {
return at::_ops::concat_names_out::call(tensors, dim, out);
}
// aten::concat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & concat_outf(at::TensorList tensors, at::Dimname dim, at::Tensor & out) {
return at::_ops::concat_names_out::call(tensors, dim, out);
}
// aten::block_diag(Tensor[] tensors) -> Tensor
TORCH_API inline at::Tensor block_diag(at::TensorList tensors) {
return at::_ops::block_diag::call(tensors);
}
// aten::ceil(Tensor self) -> Tensor
TORCH_API inline at::Tensor ceil(const at::Tensor & self) {
return at::_ops::ceil::call(self);
}
// aten::ceil_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & ceil_(at::Tensor & self) {
return at::_ops::ceil_::call(self);
}
// aten::ceil.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & ceil_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::ceil_out::call(self, out);
}
// aten::ceil.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & ceil_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::ceil_out::call(self, out);
}
// aten::chain_matmul(Tensor[] matrices) -> Tensor
TORCH_API inline at::Tensor chain_matmul(at::TensorList matrices) {
return at::_ops::chain_matmul::call(matrices);
}
// aten::chain_matmul.out(Tensor[] matrices, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & chain_matmul_out(at::Tensor & out, at::TensorList matrices) {
return at::_ops::chain_matmul_out::call(matrices, out);
}
// aten::chain_matmul.out(Tensor[] matrices, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & chain_matmul_outf(at::TensorList matrices, at::Tensor & out) {
return at::_ops::chain_matmul_out::call(matrices, out);
}
// aten::unsafe_chunk(Tensor self, int chunks, int dim=0) -> Tensor[]
TORCH_API inline ::std::vector unsafe_chunk(const at::Tensor & self, int64_t chunks, int64_t dim=0) {
return at::_ops::unsafe_chunk::call(self, chunks, dim);
}
// aten::chunk(Tensor(a) self, int chunks, int dim=0) -> Tensor(a)[]
TORCH_API inline ::std::vector chunk(const at::Tensor & self, int64_t chunks, int64_t dim=0) {
return at::_ops::chunk::call(self, chunks, dim);
}
// aten::tensor_split.sections(Tensor(a) self, int sections, int dim=0) -> Tensor(a)[]
TORCH_API inline ::std::vector tensor_split(const at::Tensor & self, int64_t sections, int64_t dim=0) {
return at::_ops::tensor_split_sections::call(self, sections, dim);
}
// aten::tensor_split.indices(Tensor(a) self, int[] indices, int dim=0) -> Tensor(a)[]
TORCH_API inline ::std::vector tensor_split(const at::Tensor & self, at::IntArrayRef indices, int64_t dim=0) {
return at::_ops::tensor_split_indices::call(self, indices, dim);
}
// aten::tensor_split.tensor_indices_or_sections(Tensor(a) self, Tensor tensor_indices_or_sections, int dim=0) -> Tensor(a)[]
TORCH_API inline ::std::vector tensor_split(const at::Tensor & self, const at::Tensor & tensor_indices_or_sections, int64_t dim=0) {
return at::_ops::tensor_split_tensor_indices_or_sections::call(self, tensor_indices_or_sections, dim);
}
// aten::clamp(Tensor self, Scalar? min=None, Scalar? max=None) -> Tensor
TORCH_API inline at::Tensor clamp(const at::Tensor & self, const c10::optional & min, const c10::optional & max=c10::nullopt) {
return at::_ops::clamp::call(self, min, max);
}
// aten::clamp.Tensor(Tensor self, Tensor? min=None, Tensor? max=None) -> Tensor
TORCH_API inline at::Tensor clamp(const at::Tensor & self, const c10::optional & min={}, const c10::optional & max={}) {
return at::_ops::clamp_Tensor::call(self, min, max);
}
// aten::clamp_(Tensor(a!) self, Scalar? min=None, Scalar? max=None) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_(at::Tensor & self, const c10::optional & min, const c10::optional & max=c10::nullopt) {
return at::_ops::clamp_::call(self, min, max);
}
// aten::clamp_.Tensor(Tensor(a!) self, Tensor? min=None, Tensor? max=None) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_(at::Tensor & self, const c10::optional & min={}, const c10::optional & max={}) {
return at::_ops::clamp__Tensor::call(self, min, max);
}
// aten::clamp.out(Tensor self, Scalar? min=None, Scalar? max=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_out(at::Tensor & out, const at::Tensor & self, const c10::optional & min, const c10::optional & max=c10::nullopt) {
return at::_ops::clamp_out::call(self, min, max, out);
}
// aten::clamp.out(Tensor self, Scalar? min=None, Scalar? max=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_outf(const at::Tensor & self, const c10::optional & min, const c10::optional & max, at::Tensor & out) {
return at::_ops::clamp_out::call(self, min, max, out);
}
// aten::clamp.Tensor_out(Tensor self, Tensor? min=None, Tensor? max=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_out(at::Tensor & out, const at::Tensor & self, const c10::optional & min={}, const c10::optional & max={}) {
return at::_ops::clamp_Tensor_out::call(self, min, max, out);
}
// aten::clamp.Tensor_out(Tensor self, Tensor? min=None, Tensor? max=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_outf(const at::Tensor & self, const c10::optional & min, const c10::optional & max, at::Tensor & out) {
return at::_ops::clamp_Tensor_out::call(self, min, max, out);
}
// aten::clamp_max(Tensor self, Scalar max) -> Tensor
TORCH_API inline at::Tensor clamp_max(const at::Tensor & self, const at::Scalar & max) {
return at::_ops::clamp_max::call(self, max);
}
// aten::clamp_max.Tensor(Tensor self, Tensor max) -> Tensor
TORCH_API inline at::Tensor clamp_max(const at::Tensor & self, const at::Tensor & max) {
return at::_ops::clamp_max_Tensor::call(self, max);
}
// aten::clamp_max_(Tensor(a!) self, Scalar max) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_max_(at::Tensor & self, const at::Scalar & max) {
return at::_ops::clamp_max_::call(self, max);
}
// aten::clamp_max_.Tensor(Tensor(a!) self, Tensor max) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_max_(at::Tensor & self, const at::Tensor & max) {
return at::_ops::clamp_max__Tensor::call(self, max);
}
// aten::clamp_max.out(Tensor self, Scalar max, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_max_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & max) {
return at::_ops::clamp_max_out::call(self, max, out);
}
// aten::clamp_max.out(Tensor self, Scalar max, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_max_outf(const at::Tensor & self, const at::Scalar & max, at::Tensor & out) {
return at::_ops::clamp_max_out::call(self, max, out);
}
// aten::clamp_max.Tensor_out(Tensor self, Tensor max, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_max_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & max) {
return at::_ops::clamp_max_Tensor_out::call(self, max, out);
}
// aten::clamp_max.Tensor_out(Tensor self, Tensor max, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_max_outf(const at::Tensor & self, const at::Tensor & max, at::Tensor & out) {
return at::_ops::clamp_max_Tensor_out::call(self, max, out);
}
// aten::clamp_min(Tensor self, Scalar min) -> Tensor
TORCH_API inline at::Tensor clamp_min(const at::Tensor & self, const at::Scalar & min) {
return at::_ops::clamp_min::call(self, min);
}
// aten::clamp_min.Tensor(Tensor self, Tensor min) -> Tensor
TORCH_API inline at::Tensor clamp_min(const at::Tensor & self, const at::Tensor & min) {
return at::_ops::clamp_min_Tensor::call(self, min);
}
// aten::clamp_min_(Tensor(a!) self, Scalar min) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_min_(at::Tensor & self, const at::Scalar & min) {
return at::_ops::clamp_min_::call(self, min);
}
// aten::clamp_min_.Tensor(Tensor(a!) self, Tensor min) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_min_(at::Tensor & self, const at::Tensor & min) {
return at::_ops::clamp_min__Tensor::call(self, min);
}
// aten::clamp_min.out(Tensor self, Scalar min, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_min_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & min) {
return at::_ops::clamp_min_out::call(self, min, out);
}
// aten::clamp_min.out(Tensor self, Scalar min, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_min_outf(const at::Tensor & self, const at::Scalar & min, at::Tensor & out) {
return at::_ops::clamp_min_out::call(self, min, out);
}
// aten::clamp_min.Tensor_out(Tensor self, Tensor min, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_min_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & min) {
return at::_ops::clamp_min_Tensor_out::call(self, min, out);
}
// aten::clamp_min.Tensor_out(Tensor self, Tensor min, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clamp_min_outf(const at::Tensor & self, const at::Tensor & min, at::Tensor & out) {
return at::_ops::clamp_min_Tensor_out::call(self, min, out);
}
// aten::clip(Tensor self, Scalar? min=None, Scalar? max=None) -> Tensor
TORCH_API inline at::Tensor clip(const at::Tensor & self, const c10::optional & min, const c10::optional & max=c10::nullopt) {
return at::_ops::clip::call(self, min, max);
}
// aten::clip.Tensor(Tensor self, Tensor? min=None, Tensor? max=None) -> Tensor
TORCH_API inline at::Tensor clip(const at::Tensor & self, const c10::optional & min={}, const c10::optional & max={}) {
return at::_ops::clip_Tensor::call(self, min, max);
}
// aten::clip_(Tensor(a!) self, Scalar? min=None, Scalar? max=None) -> Tensor(a!)
TORCH_API inline at::Tensor & clip_(at::Tensor & self, const c10::optional & min, const c10::optional & max=c10::nullopt) {
return at::_ops::clip_::call(self, min, max);
}
// aten::clip_.Tensor(Tensor(a!) self, Tensor? min=None, Tensor? max=None) -> Tensor(a!)
TORCH_API inline at::Tensor & clip_(at::Tensor & self, const c10::optional & min={}, const c10::optional & max={}) {
return at::_ops::clip__Tensor::call(self, min, max);
}
// aten::clip.out(Tensor self, Scalar? min=None, Scalar? max=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clip_out(at::Tensor & out, const at::Tensor & self, const c10::optional & min, const c10::optional & max=c10::nullopt) {
return at::_ops::clip_out::call(self, min, max, out);
}
// aten::clip.out(Tensor self, Scalar? min=None, Scalar? max=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clip_outf(const at::Tensor & self, const c10::optional & min, const c10::optional & max, at::Tensor & out) {
return at::_ops::clip_out::call(self, min, max, out);
}
// aten::clip.Tensor_out(Tensor self, Tensor? min=None, Tensor? max=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clip_out(at::Tensor & out, const at::Tensor & self, const c10::optional & min={}, const c10::optional & max={}) {
return at::_ops::clip_Tensor_out::call(self, min, max, out);
}
// aten::clip.Tensor_out(Tensor self, Tensor? min=None, Tensor? max=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & clip_outf(const at::Tensor & self, const c10::optional & min, const c10::optional & max, at::Tensor & out) {
return at::_ops::clip_Tensor_out::call(self, min, max, out);
}
// aten::cudnn_is_acceptable(Tensor self) -> bool
TORCH_API inline bool cudnn_is_acceptable(const at::Tensor & self) {
return at::_ops::cudnn_is_acceptable::call(self);
}
// aten::complex(Tensor real, Tensor imag) -> Tensor
TORCH_API inline at::Tensor complex(const at::Tensor & real, const at::Tensor & imag) {
return at::_ops::complex::call(real, imag);
}
// aten::complex.out(Tensor real, Tensor imag, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & complex_out(at::Tensor & out, const at::Tensor & real, const at::Tensor & imag) {
return at::_ops::complex_out::call(real, imag, out);
}
// aten::complex.out(Tensor real, Tensor imag, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & complex_outf(const at::Tensor & real, const at::Tensor & imag, at::Tensor & out) {
return at::_ops::complex_out::call(real, imag, out);
}
// aten::polar(Tensor abs, Tensor angle) -> Tensor
TORCH_API inline at::Tensor polar(const at::Tensor & abs, const at::Tensor & angle) {
return at::_ops::polar::call(abs, angle);
}
// aten::polar.out(Tensor abs, Tensor angle, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & polar_out(at::Tensor & out, const at::Tensor & abs, const at::Tensor & angle) {
return at::_ops::polar_out::call(abs, angle, out);
}
// aten::polar.out(Tensor abs, Tensor angle, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & polar_outf(const at::Tensor & abs, const at::Tensor & angle, at::Tensor & out) {
return at::_ops::polar_out::call(abs, angle, out);
}
// aten::constant_pad_nd(Tensor self, int[] pad, Scalar value=0) -> Tensor
TORCH_API inline at::Tensor constant_pad_nd(const at::Tensor & self, at::IntArrayRef pad, const at::Scalar & value=0) {
return at::_ops::constant_pad_nd::call(self, pad, value);
}
// aten::convolution(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups) -> Tensor
TORCH_API inline at::Tensor convolution(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups) {
return at::_ops::convolution::call(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups);
}
// aten::convolution_overrideable(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups) -> Tensor
TORCH_API inline at::Tensor convolution_overrideable(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups) {
return at::_ops::convolution_overrideable::call(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups);
}
// aten::convolution_backward_overrideable(Tensor grad_output, Tensor input, Tensor weight, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias)
TORCH_API inline ::std::tuple convolution_backward_overrideable(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, ::std::array output_mask) {
return at::_ops::convolution_backward_overrideable::call(grad_output, input, weight, stride, padding, dilation, transposed, output_padding, groups, output_mask);
}
// aten::_convolution(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32) -> Tensor
TORCH_API inline at::Tensor _convolution(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32) {
return at::_ops::_convolution::call(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, allow_tf32);
}
// aten::_convolution.deprecated(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool benchmark, bool deterministic, bool cudnn_enabled) -> Tensor
TORCH_API inline at::Tensor _convolution(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled) {
return at::_ops::_convolution_deprecated::call(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled);
}
// aten::_convolution_mode(Tensor input, Tensor weight, Tensor? bias, int[] stride, str padding, int[] dilation, int groups) -> Tensor
TORCH_API inline at::Tensor _convolution_mode(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, c10::string_view padding, at::IntArrayRef dilation, int64_t groups) {
return at::_ops::_convolution_mode::call(input, weight, bias, stride, padding, dilation, groups);
}
// aten::_convolution_nogroup(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding) -> Tensor
TORCH_API inline at::Tensor _convolution_nogroup(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding) {
return at::_ops::_convolution_nogroup::call(input, weight, bias, stride, padding, dilation, transposed, output_padding);
}
// aten::_convolution_double_backward(Tensor? ggI, Tensor? ggW, Tensor? ggb, Tensor gO, Tensor weight, Tensor self, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
TORCH_API inline ::std::tuple _convolution_double_backward(const c10::optional & ggI, const c10::optional & ggW, const c10::optional & ggb, const at::Tensor & gO, const at::Tensor & weight, const at::Tensor & self, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32, ::std::array output_mask) {
return at::_ops::_convolution_double_backward::call(ggI, ggW, ggb, gO, weight, self, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, allow_tf32, output_mask);
}
// aten::conv1d(Tensor input, Tensor weight, Tensor? bias=None, int[1] stride=1, int[1] padding=0, int[1] dilation=1, int groups=1) -> Tensor
TORCH_API inline at::Tensor conv1d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef dilation=1, int64_t groups=1) {
return at::_ops::conv1d::call(input, weight, bias, stride, padding, dilation, groups);
}
// aten::conv2d(Tensor input, Tensor weight, Tensor? bias=None, int[2] stride=1, int[2] padding=0, int[2] dilation=1, int groups=1) -> Tensor
TORCH_API inline at::Tensor conv2d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef dilation=1, int64_t groups=1) {
return at::_ops::conv2d::call(input, weight, bias, stride, padding, dilation, groups);
}
// aten::conv3d(Tensor input, Tensor weight, Tensor? bias=None, int[3] stride=1, int[3] padding=0, int[3] dilation=1, int groups=1) -> Tensor
TORCH_API inline at::Tensor conv3d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef dilation=1, int64_t groups=1) {
return at::_ops::conv3d::call(input, weight, bias, stride, padding, dilation, groups);
}
// aten::conv1d.padding(Tensor input, Tensor weight, Tensor? bias=None, int[1] stride=1, str padding="valid", int[1] dilation=1, int groups=1) -> Tensor
TORCH_API inline at::Tensor conv1d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, c10::string_view padding, at::IntArrayRef dilation=1, int64_t groups=1) {
return at::_ops::conv1d_padding::call(input, weight, bias, stride, padding, dilation, groups);
}
// aten::conv2d.padding(Tensor input, Tensor weight, Tensor? bias=None, int[2] stride=1, str padding="valid", int[2] dilation=1, int groups=1) -> Tensor
TORCH_API inline at::Tensor conv2d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, c10::string_view padding, at::IntArrayRef dilation=1, int64_t groups=1) {
return at::_ops::conv2d_padding::call(input, weight, bias, stride, padding, dilation, groups);
}
// aten::conv3d.padding(Tensor input, Tensor weight, Tensor? bias=None, int[3] stride=1, str padding="valid", int[3] dilation=1, int groups=1) -> Tensor
TORCH_API inline at::Tensor conv3d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, c10::string_view padding, at::IntArrayRef dilation=1, int64_t groups=1) {
return at::_ops::conv3d_padding::call(input, weight, bias, stride, padding, dilation, groups);
}
// aten::conv_tbc(Tensor self, Tensor weight, Tensor bias, int pad=0) -> Tensor
TORCH_API inline at::Tensor conv_tbc(const at::Tensor & self, const at::Tensor & weight, const at::Tensor & bias, int64_t pad=0) {
return at::_ops::conv_tbc::call(self, weight, bias, pad);
}
// aten::conv_tbc_backward(Tensor self, Tensor input, Tensor weight, Tensor bias, int pad) -> (Tensor, Tensor, Tensor)
TORCH_API inline ::std::tuple conv_tbc_backward(const at::Tensor & self, const at::Tensor & input, const at::Tensor & weight, const at::Tensor & bias, int64_t pad) {
return at::_ops::conv_tbc_backward::call(self, input, weight, bias, pad);
}
// aten::conv_transpose1d(Tensor input, Tensor weight, Tensor? bias=None, int[1] stride=1, int[1] padding=0, int[1] output_padding=0, int groups=1, int[1] dilation=1) -> Tensor
TORCH_API inline at::Tensor conv_transpose1d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, int64_t groups=1, at::IntArrayRef dilation=1) {
return at::_ops::conv_transpose1d::call(input, weight, bias, stride, padding, output_padding, groups, dilation);
}
// aten::conv_transpose2d.input(Tensor input, Tensor weight, Tensor? bias=None, int[2] stride=1, int[2] padding=0, int[2] output_padding=0, int groups=1, int[2] dilation=1) -> Tensor
TORCH_API inline at::Tensor conv_transpose2d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, int64_t groups=1, at::IntArrayRef dilation=1) {
return at::_ops::conv_transpose2d_input::call(input, weight, bias, stride, padding, output_padding, groups, dilation);
}
// aten::conv_transpose3d.input(Tensor input, Tensor weight, Tensor? bias=None, int[3] stride=1, int[3] padding=0, int[3] output_padding=0, int groups=1, int[3] dilation=1) -> Tensor
TORCH_API inline at::Tensor conv_transpose3d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, int64_t groups=1, at::IntArrayRef dilation=1) {
return at::_ops::conv_transpose3d_input::call(input, weight, bias, stride, padding, output_padding, groups, dilation);
}
// aten::_copy_from(Tensor self, Tensor dst, bool non_blocking=False) -> Tensor
TORCH_API inline at::Tensor _copy_from(const at::Tensor & self, const at::Tensor & dst, bool non_blocking=false) {
return at::_ops::_copy_from::call(self, dst, non_blocking);
}
// aten::_copy_from_and_resize(Tensor self, Tensor dst) -> Tensor
TORCH_API inline at::Tensor _copy_from_and_resize(const at::Tensor & self, const at::Tensor & dst) {
return at::_ops::_copy_from_and_resize::call(self, dst);
}
// aten::cos(Tensor self) -> Tensor
TORCH_API inline at::Tensor cos(const at::Tensor & self) {
return at::_ops::cos::call(self);
}
// aten::cos_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & cos_(at::Tensor & self) {
return at::_ops::cos_::call(self);
}
// aten::cos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cos_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::cos_out::call(self, out);
}
// aten::cos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cos_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::cos_out::call(self, out);
}
// aten::cosh(Tensor self) -> Tensor
TORCH_API inline at::Tensor cosh(const at::Tensor & self) {
return at::_ops::cosh::call(self);
}
// aten::cosh_(Tensor(a!) self) -> Tensor(a!)
TORCH_API inline at::Tensor & cosh_(at::Tensor & self) {
return at::_ops::cosh_::call(self);
}
// aten::cosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cosh_out(at::Tensor & out, const at::Tensor & self) {
return at::_ops::cosh_out::call(self, out);
}
// aten::cosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cosh_outf(const at::Tensor & self, at::Tensor & out) {
return at::_ops::cosh_out::call(self, out);
}
// aten::cosine_embedding_loss(Tensor input1, Tensor input2, Tensor target, float margin=0.0, int reduction=Mean) -> Tensor
TORCH_API inline at::Tensor cosine_embedding_loss(const at::Tensor & input1, const at::Tensor & input2, const at::Tensor & target, double margin=0.0, int64_t reduction=at::Reduction::Mean) {
return at::_ops::cosine_embedding_loss::call(input1, input2, target, margin, reduction);
}
// aten::count_nonzero.dim_IntList(Tensor self, int[] dim) -> Tensor
TORCH_API inline at::Tensor count_nonzero(const at::Tensor & self, at::IntArrayRef dim) {
return at::_ops::count_nonzero_dim_IntList::call(self, dim);
}
// aten::count_nonzero(Tensor self, int? dim=None) -> Tensor
TORCH_API inline at::Tensor count_nonzero(const at::Tensor & self, c10::optional dim=c10::nullopt) {
return at::_ops::count_nonzero::call(self, dim);
}
// aten::cov(Tensor self, *, int correction=1, Tensor? fweights=None, Tensor? aweights=None) -> Tensor
TORCH_API inline at::Tensor cov(const at::Tensor & self, int64_t correction=1, const c10::optional & fweights={}, const c10::optional & aweights={}) {
return at::_ops::cov::call(self, correction, fweights, aweights);
}
// aten::corrcoef(Tensor self) -> Tensor
TORCH_API inline at::Tensor corrcoef(const at::Tensor & self) {
return at::_ops::corrcoef::call(self);
}
// aten::cudnn_affine_grid_generator(Tensor theta, int N, int C, int H, int W) -> Tensor grid
TORCH_API inline at::Tensor cudnn_affine_grid_generator(const at::Tensor & theta, int64_t N, int64_t C, int64_t H, int64_t W) {
return at::_ops::cudnn_affine_grid_generator::call(theta, N, C, H, W);
}
// aten::cudnn_affine_grid_generator_backward(Tensor grad, int N, int C, int H, int W) -> Tensor grad_theta
TORCH_API inline at::Tensor cudnn_affine_grid_generator_backward(const at::Tensor & grad, int64_t N, int64_t C, int64_t H, int64_t W) {
return at::_ops::cudnn_affine_grid_generator_backward::call(grad, N, C, H, W);
}
// aten::cudnn_batch_norm(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float exponential_average_factor, float epsilon) -> (Tensor, Tensor, Tensor, Tensor)
TORCH_API inline ::std::tuple cudnn_batch_norm(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, const c10::optional & running_mean, const c10::optional & running_var, bool training, double exponential_average_factor, double epsilon) {
return at::_ops::cudnn_batch_norm::call(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon);
}
// aten::cudnn_batch_norm_backward(Tensor input, Tensor grad_output, Tensor weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var, float epsilon, Tensor reserveSpace) -> (Tensor, Tensor, Tensor)
TORCH_API inline ::std::tuple cudnn_batch_norm_backward(const at::Tensor & input, const at::Tensor & grad_output, const at::Tensor & weight, const c10::optional & running_mean, const c10::optional & running_var, const c10::optional & save_mean, const c10::optional & save_var, double epsilon, const at::Tensor & reserveSpace) {
return at::_ops::cudnn_batch_norm_backward::call(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, reserveSpace);
}
// aten::cudnn_convolution.deprecated(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution(const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
return at::_ops::cudnn_convolution_deprecated::call(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic);
}
// aten::cudnn_convolution.deprecated2(Tensor self, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
return at::_ops::cudnn_convolution_deprecated2::call(self, weight, padding, stride, dilation, groups, benchmark, deterministic);
}
// aten::cudnn_convolution(Tensor self, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
return at::_ops::cudnn_convolution::call(self, weight, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32);
}
// aten::cudnn_convolution_backward_input(int[] self_size, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution_backward_input(at::IntArrayRef self_size, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
return at::_ops::cudnn_convolution_backward_input::call(self_size, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32);
}
// aten::cudnn_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32, bool[2] output_mask) -> (Tensor, Tensor)
TORCH_API inline ::std::tuple cudnn_convolution_backward(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32, ::std::array output_mask) {
return at::_ops::cudnn_convolution_backward::call(self, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, output_mask);
}
// aten::cudnn_convolution_backward_weight(int[] weight_size, Tensor grad_output, Tensor self, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution_backward_weight(at::IntArrayRef weight_size, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
return at::_ops::cudnn_convolution_backward_weight::call(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32);
}
// aten::cudnn_convolution_transpose.deprecated(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution_transpose(const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
return at::_ops::cudnn_convolution_transpose_deprecated::call(self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic);
}
// aten::cudnn_convolution_transpose.deprecated2(Tensor self, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution_transpose(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
return at::_ops::cudnn_convolution_transpose_deprecated2::call(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic);
}
// aten::cudnn_convolution_transpose(Tensor self, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution_transpose(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
return at::_ops::cudnn_convolution_transpose::call(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32);
}
// aten::cudnn_convolution_transpose_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32, bool[2] output_mask) -> (Tensor, Tensor)
TORCH_API inline ::std::tuple cudnn_convolution_transpose_backward(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32, ::std::array output_mask) {
return at::_ops::cudnn_convolution_transpose_backward::call(self, grad_output, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, output_mask);
}
// aten::cudnn_convolution_transpose_backward_input(Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution_transpose_backward_input(const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
return at::_ops::cudnn_convolution_transpose_backward_input::call(grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32);
}
// aten::cudnn_convolution_transpose_backward_weight(int[] weight_size, Tensor grad_output, Tensor self, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution_transpose_backward_weight(at::IntArrayRef weight_size, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
return at::_ops::cudnn_convolution_transpose_backward_weight::call(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32);
}
// aten::cudnn_convolution_relu(Tensor self, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, int groups) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution_relu(const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, int64_t groups) {
return at::_ops::cudnn_convolution_relu::call(self, weight, bias, stride, padding, dilation, groups);
}
// aten::cudnn_convolution_add_relu(Tensor self, Tensor weight, Tensor z, Scalar? alpha, Tensor? bias, int[] stride, int[] padding, int[] dilation, int groups) -> Tensor
TORCH_API inline at::Tensor cudnn_convolution_add_relu(const at::Tensor & self, const at::Tensor & weight, const at::Tensor & z, const c10::optional & alpha, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, int64_t groups) {
return at::_ops::cudnn_convolution_add_relu::call(self, weight, z, alpha, bias, stride, padding, dilation, groups);
}
// aten::cudnn_grid_sampler(Tensor self, Tensor grid) -> Tensor output
TORCH_API inline at::Tensor cudnn_grid_sampler(const at::Tensor & self, const at::Tensor & grid) {
return at::_ops::cudnn_grid_sampler::call(self, grid);
}
// aten::cudnn_grid_sampler_backward(Tensor self, Tensor grid, Tensor grad_output) -> (Tensor grad_self, Tensor grad_grid)
TORCH_API inline ::std::tuple cudnn_grid_sampler_backward(const at::Tensor & self, const at::Tensor & grid, const at::Tensor & grad_output) {
return at::_ops::cudnn_grid_sampler_backward::call(self, grid, grad_output);
}
// aten::cummax(Tensor self, int dim) -> (Tensor values, Tensor indices)
TORCH_API inline ::std::tuple cummax(const at::Tensor & self, int64_t dim) {
return at::_ops::cummax::call(self, dim);
}
// aten::cummax.out(Tensor self, int dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
TORCH_API inline ::std::tuple cummax_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t dim) {
return at::_ops::cummax_out::call(self, dim, values, indices);
}
// aten::cummax.out(Tensor self, int dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
TORCH_API inline ::std::tuple cummax_outf(const at::Tensor & self, int64_t dim, at::Tensor & values, at::Tensor & indices) {
return at::_ops::cummax_out::call(self, dim, values, indices);
}
// aten::cummax.dimname(Tensor self, Dimname dim) -> (Tensor values, Tensor indices)
TORCH_API inline ::std::tuple cummax(const at::Tensor & self, at::Dimname dim) {
return at::_ops::cummax_dimname::call(self, dim);
}
// aten::cummax.dimname_out(Tensor self, Dimname dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
TORCH_API inline ::std::tuple cummax_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, at::Dimname dim) {
return at::_ops::cummax_dimname_out::call(self, dim, values, indices);
}
// aten::cummax.dimname_out(Tensor self, Dimname dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
TORCH_API inline ::std::tuple cummax_outf(const at::Tensor & self, at::Dimname dim, at::Tensor & values, at::Tensor & indices) {
return at::_ops::cummax_dimname_out::call(self, dim, values, indices);
}
// aten::_cummax_helper(Tensor self, Tensor(a!) values, Tensor(b!) indices, int dim) -> ()
TORCH_API inline void _cummax_helper(const at::Tensor & self, at::Tensor & values, at::Tensor & indices, int64_t dim) {
return at::_ops::_cummax_helper::call(self, values, indices, dim);
}
// aten::cummin(Tensor self, int dim) -> (Tensor values, Tensor indices)
TORCH_API inline ::std::tuple cummin(const at::Tensor & self, int64_t dim) {
return at::_ops::cummin::call(self, dim);
}
// aten::cummin.out(Tensor self, int dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
TORCH_API inline ::std::tuple cummin_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t dim) {
return at::_ops::cummin_out::call(self, dim, values, indices);
}
// aten::cummin.out(Tensor self, int dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
TORCH_API inline ::std::tuple cummin_outf(const at::Tensor & self, int64_t dim, at::Tensor & values, at::Tensor & indices) {
return at::_ops::cummin_out::call(self, dim, values, indices);
}
// aten::cummin.dimname(Tensor self, Dimname dim) -> (Tensor values, Tensor indices)
TORCH_API inline ::std::tuple cummin(const at::Tensor & self, at::Dimname dim) {
return at::_ops::cummin_dimname::call(self, dim);
}
// aten::cummin.dimname_out(Tensor self, Dimname dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
TORCH_API inline ::std::tuple cummin_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, at::Dimname dim) {
return at::_ops::cummin_dimname_out::call(self, dim, values, indices);
}
// aten::cummin.dimname_out(Tensor self, Dimname dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
TORCH_API inline ::std::tuple cummin_outf(const at::Tensor & self, at::Dimname dim, at::Tensor & values, at::Tensor & indices) {
return at::_ops::cummin_dimname_out::call(self, dim, values, indices);
}
// aten::_cummin_helper(Tensor self, Tensor(a!) values, Tensor(b!) indices, int dim) -> ()
TORCH_API inline void _cummin_helper(const at::Tensor & self, at::Tensor & values, at::Tensor & indices, int64_t dim) {
return at::_ops::_cummin_helper::call(self, values, indices, dim);
}
// aten::cummaxmin_backward(Tensor grad, Tensor input, Tensor indices, int dim) -> Tensor
TORCH_API inline at::Tensor cummaxmin_backward(const at::Tensor & grad, const at::Tensor & input, const at::Tensor & indices, int64_t dim) {
return at::_ops::cummaxmin_backward::call(grad, input, indices, dim);
}
// aten::cumprod(Tensor self, int dim, *, ScalarType? dtype=None) -> Tensor
TORCH_API inline at::Tensor cumprod(const at::Tensor & self, int64_t dim, c10::optional dtype=c10::nullopt) {
return at::_ops::cumprod::call(self, dim, dtype);
}
// aten::cumprod.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cumprod_out(at::Tensor & out, const at::Tensor & self, int64_t dim, c10::optional dtype=c10::nullopt) {
return at::_ops::cumprod_out::call(self, dim, dtype, out);
}
// aten::cumprod.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cumprod_outf(const at::Tensor & self, int64_t dim, c10::optional dtype, at::Tensor & out) {
return at::_ops::cumprod_out::call(self, dim, dtype, out);
}
// aten::cumprod.dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor
TORCH_API inline at::Tensor cumprod(const at::Tensor & self, at::Dimname dim, c10::optional dtype=c10::nullopt) {
return at::_ops::cumprod_dimname::call(self, dim, dtype);
}
// aten::cumprod.dimname_out(Tensor self, Dimname dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cumprod_out(at::Tensor & out, const at::Tensor & self, at::Dimname dim, c10::optional dtype=c10::nullopt) {
return at::_ops::cumprod_dimname_out::call(self, dim, dtype, out);
}
// aten::cumprod.dimname_out(Tensor self, Dimname dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cumprod_outf(const at::Tensor & self, at::Dimname dim, c10::optional dtype, at::Tensor & out) {
return at::_ops::cumprod_dimname_out::call(self, dim, dtype, out);
}
// aten::cumprod_backward(Tensor grad, Tensor input, int dim, Tensor output) -> Tensor
TORCH_API inline at::Tensor cumprod_backward(const at::Tensor & grad, const at::Tensor & input, int64_t dim, const at::Tensor & output) {
return at::_ops::cumprod_backward::call(grad, input, dim, output);
}
// aten::cumsum(Tensor self, int dim, *, ScalarType? dtype=None) -> Tensor
TORCH_API inline at::Tensor cumsum(const at::Tensor & self, int64_t dim, c10::optional dtype=c10::nullopt) {
return at::_ops::cumsum::call(self, dim, dtype);
}
// aten::cumsum.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cumsum_out(at::Tensor & out, const at::Tensor & self, int64_t dim, c10::optional dtype=c10::nullopt) {
return at::_ops::cumsum_out::call(self, dim, dtype, out);
}
// aten::cumsum.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cumsum_outf(const at::Tensor & self, int64_t dim, c10::optional dtype, at::Tensor & out) {
return at::_ops::cumsum_out::call(self, dim, dtype, out);
}
// aten::cumsum.dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor
TORCH_API inline at::Tensor cumsum(const at::Tensor & self, at::Dimname dim, c10::optional dtype=c10::nullopt) {
return at::_ops::cumsum_dimname::call(self, dim, dtype);
}
// aten::cumsum.dimname_out(Tensor self, Dimname dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cumsum_out(at::Tensor & out, const at::Tensor & self, at::Dimname dim, c10::optional dtype=c10::nullopt) {
return at::_ops::cumsum_dimname_out::call(self, dim, dtype, out);
}
// aten::cumsum.dimname_out(Tensor self, Dimname dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & cumsum_outf(const at::Tensor & self, at::Dimname dim, c10::optional dtype, at::Tensor & out) {
return at::_ops::cumsum_dimname_out::call(self, dim, dtype, out);
}
// aten::cumulative_trapezoid.x(Tensor y, Tensor x, *, int dim=-1) -> Tensor
TORCH_API inline at::Tensor cumulative_trapezoid(const at::Tensor & y, const at::Tensor & x, int64_t dim=-1) {
return at::_ops::cumulative_trapezoid_x::call(y, x, dim);
}
// aten::cumulative_trapezoid.dx(Tensor y, *, Scalar dx=1, int dim=-1) -> Tensor
TORCH_API inline at::Tensor cumulative_trapezoid(const at::Tensor & y, const at::Scalar & dx=1, int64_t dim=-1) {
return at::_ops::cumulative_trapezoid_dx::call(y, dx, dim);
}
// aten::ctc_loss.IntList(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank=0, int reduction=Mean, bool zero_infinity=False) -> Tensor
TORCH_API inline at::Tensor ctc_loss(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank=0, int64_t reduction=at::Reduction::Mean, bool zero_infinity=false) {
return at::_ops::ctc_loss_IntList::call(log_probs, targets, input_lengths, target_lengths, blank, reduction, zero_infinity);
}
// aten::ctc_loss.Tensor(Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, int blank=0, int reduction=Mean, bool zero_infinity=False) -> Tensor
TORCH_API inline at::Tensor ctc_loss(const at::Tensor & log_probs, const at::Tensor & targets, const at::Tensor & input_lengths, const at::Tensor & target_lengths, int64_t blank=0, int64_t reduction=at::Reduction::Mean, bool zero_infinity=false) {
return at::_ops::ctc_loss_Tensor::call(log_probs, targets, input_lengths, target_lengths, blank, reduction, zero_infinity);
}
// aten::_ctc_loss(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank=0, bool zero_infinity=False) -> (Tensor, Tensor)
TORCH_API inline ::std::tuple _ctc_loss(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank=0, bool zero_infinity=false) {
return at::_ops::_ctc_loss::call(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity);
}
// aten::_ctc_loss_backward(Tensor grad, Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, Tensor neg_log_likelihood, Tensor log_alpha, int blank, bool zero_infinity=False) -> Tensor
TORCH_API inline at::Tensor _ctc_loss_backward(const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity=false) {
return at::_ops::_ctc_loss_backward::call(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, blank, zero_infinity);
}
// aten::diag_embed(Tensor self, int offset=0, int dim1=-2, int dim2=-1) -> Tensor
TORCH_API inline at::Tensor diag_embed(const at::Tensor & self, int64_t offset=0, int64_t dim1=-2, int64_t dim2=-1) {
return at::_ops::diag_embed::call(self, offset, dim1, dim2);
}
// aten::diagflat(Tensor self, int offset=0) -> Tensor
TORCH_API inline at::Tensor diagflat(const at::Tensor & self, int64_t offset=0) {
return at::_ops::diagflat::call(self, offset);
}
// aten::diagonal(Tensor(a) self, int offset=0, int dim1=0, int dim2=1) -> Tensor(a)
TORCH_API inline at::Tensor diagonal(const at::Tensor & self, int64_t offset=0, int64_t dim1=0, int64_t dim2=1) {
return at::_ops::diagonal::call(self, offset, dim1, dim2);
}
// aten::diagonal.Dimname(Tensor(a) self, *, Dimname outdim, Dimname dim1, Dimname dim2, int offset=0) -> Tensor(a)
TORCH_API inline at::Tensor diagonal(const at::Tensor & self, at::Dimname outdim, at::Dimname dim1, at::Dimname dim2, int64_t offset=0) {
return at::_ops::diagonal_Dimname::call(self, outdim, dim1, dim2, offset);
}
// aten::diagonal_backward(Tensor grad_output, int[] input_sizes, int offset, int dim1, int dim2) -> Tensor
TORCH_API inline at::Tensor diagonal_backward(const at::Tensor & grad_output, at::IntArrayRef input_sizes, int64_t offset, int64_t dim1, int64_t dim2) {
return at::_ops::diagonal_backward::call(grad_output, input_sizes, offset, dim1, dim2);
}
// aten::diff(Tensor self, int n=1, int dim=-1, Tensor? prepend=None, Tensor? append=None) -> Tensor
TORCH_API inline at::Tensor diff(const at::Tensor & self, int64_t n=1, int64_t dim=-1, const c10::optional & prepend={}, const c10::optional & append={}) {
return at::_ops::diff::call(self, n, dim, prepend, append);
}
// aten::diff.out(Tensor self, int n=1, int dim=-1, Tensor? prepend=None, Tensor? append=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & diff_out(at::Tensor & out, const at::Tensor & self, int64_t n=1, int64_t dim=-1, const c10::optional & prepend={}, const c10::optional & append={}) {
return at::_ops::diff_out::call(self, n, dim, prepend, append, out);
}
// aten::diff.out(Tensor self, int n=1, int dim=-1, Tensor? prepend=None, Tensor? append=None, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & diff_outf(const at::Tensor & self, int64_t n, int64_t dim, const c10::optional & prepend, const c10::optional & append, at::Tensor & out) {
return at::_ops::diff_out::call(self, n, dim, prepend, append, out);
}
// aten::gradient.scalarint(Tensor self, *, Scalar? spacing=None, int? dim=None, int edge_order=1) -> Tensor[]
TORCH_API inline ::std::vector gradient(const at::Tensor & self, const c10::optional & spacing=c10::nullopt, c10::optional dim=c10::nullopt, int64_t edge_order=1) {
return at::_ops::gradient_scalarint::call(self, spacing, dim, edge_order);
}
// aten::gradient.scalararray(Tensor self, *, Scalar spacing, int[] dim, int edge_order=1) -> Tensor[]
TORCH_API inline ::std::vector gradient(const at::Tensor & self, const at::Scalar & spacing, at::IntArrayRef dim, int64_t edge_order=1) {
return at::_ops::gradient_scalararray::call(self, spacing, dim, edge_order);
}
// aten::gradient.array(Tensor self, *, int[] dim, int edge_order=1) -> Tensor[]
TORCH_API inline ::std::vector gradient(const at::Tensor & self, at::IntArrayRef dim, int64_t edge_order=1) {
return at::_ops::gradient_array::call(self, dim, edge_order);
}
// aten::gradient.scalarrayint(Tensor self, *, Scalar[] spacing, int? dim=None, int edge_order=1) -> Tensor[]
TORCH_API inline ::std::vector gradient(const at::Tensor & self, at::ArrayRef spacing, c10::optional dim=c10::nullopt, int64_t edge_order=1) {
return at::_ops::gradient_scalarrayint::call(self, spacing, dim, edge_order);
}
// aten::gradient.scalarrayarray(Tensor self, *, Scalar[] spacing, int[] dim, int edge_order=1) -> Tensor[]
TORCH_API inline ::std::vector gradient(const at::Tensor & self, at::ArrayRef spacing, at::IntArrayRef dim, int64_t edge_order=1) {
return at::_ops::gradient_scalarrayarray::call(self, spacing, dim, edge_order);
}
// aten::gradient.tensorarrayint(Tensor self, *, Tensor[] spacing, int? dim=None, int edge_order=1) -> Tensor[]
TORCH_API inline ::std::vector gradient(const at::Tensor & self, at::TensorList spacing, c10::optional dim=c10::nullopt, int64_t edge_order=1) {
return at::_ops::gradient_tensorarrayint::call(self, spacing, dim, edge_order);
}
// aten::gradient.tensorarray(Tensor self, *, Tensor[] spacing, int[] dim, int edge_order=1) -> Tensor[]
TORCH_API inline ::std::vector gradient(const at::Tensor & self, at::TensorList spacing, at::IntArrayRef dim, int64_t edge_order=1) {
return at::_ops::gradient_tensorarray::call(self, spacing, dim, edge_order);
}
// aten::div.Tensor(Tensor self, Tensor other) -> Tensor
TORCH_API inline at::Tensor div(const at::Tensor & self, const at::Tensor & other) {
return at::_ops::div_Tensor::call(self, other);
}
// aten::div.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & div_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return at::_ops::div_out::call(self, other, out);
}
// aten::div.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & div_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return at::_ops::div_out::call(self, other, out);
}
// aten::div.Tensor_mode(Tensor self, Tensor other, *, str? rounding_mode) -> Tensor
TORCH_API inline at::Tensor div(const at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode) {
return at::_ops::div_Tensor_mode::call(self, other, rounding_mode);
}
// aten::div.out_mode(Tensor self, Tensor other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & div_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode) {
return at::_ops::div_out_mode::call(self, other, rounding_mode, out);
}
// aten::div.out_mode(Tensor self, Tensor other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & div_outf(const at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode, at::Tensor & out) {
return at::_ops::div_out_mode::call(self, other, rounding_mode, out);
}
// aten::div.Scalar(Tensor self, Scalar other) -> Tensor
TORCH_API inline at::Tensor div(const at::Tensor & self, const at::Scalar & other) {
return at::_ops::div_Scalar::call(self, other);
}
// aten::div.Scalar_mode(Tensor self, Scalar other, *, str? rounding_mode) -> Tensor
TORCH_API inline at::Tensor div(const at::Tensor & self, const at::Scalar & other, c10::optional rounding_mode) {
return at::_ops::div_Scalar_mode::call(self, other, rounding_mode);
}
// aten::divide.Tensor(Tensor self, Tensor other) -> Tensor
TORCH_API inline at::Tensor divide(const at::Tensor & self, const at::Tensor & other) {
return at::_ops::divide_Tensor::call(self, other);
}
// aten::divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & divide_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return at::_ops::divide_out::call(self, other, out);
}
// aten::divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & divide_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return at::_ops::divide_out::call(self, other, out);
}
// aten::divide.Scalar(Tensor self, Scalar other) -> Tensor
TORCH_API inline at::Tensor divide(const at::Tensor & self, const at::Scalar & other) {
return at::_ops::divide_Scalar::call(self, other);
}
// aten::divide.Tensor_mode(Tensor self, Tensor other, *, str? rounding_mode) -> Tensor
TORCH_API inline at::Tensor divide(const at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode) {
return at::_ops::divide_Tensor_mode::call(self, other, rounding_mode);
}
// aten::divide.out_mode(Tensor self, Tensor other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & divide_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode) {
return at::_ops::divide_out_mode::call(self, other, rounding_mode, out);
}
// aten::divide.out_mode(Tensor self, Tensor other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & divide_outf(const at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode, at::Tensor & out) {
return at::_ops::divide_out_mode::call(self, other, rounding_mode, out);
}
// aten::divide.Scalar_mode(Tensor self, Scalar other, *, str? rounding_mode) -> Tensor
TORCH_API inline at::Tensor divide(const at::Tensor & self, const at::Scalar & other, c10::optional rounding_mode) {
return at::_ops::divide_Scalar_mode::call(self, other, rounding_mode);
}
// aten::true_divide.Tensor(Tensor self, Tensor other) -> Tensor
TORCH_API inline at::Tensor true_divide(const at::Tensor & self, const at::Tensor & other) {
return at::_ops::true_divide_Tensor::call(self, other);
}
// aten::true_divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & true_divide_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return at::_ops::true_divide_out::call(self, other, out);
}
// aten::true_divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & true_divide_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return at::_ops::true_divide_out::call(self, other, out);
}
// aten::true_divide.Scalar(Tensor self, Scalar other) -> Tensor
TORCH_API inline at::Tensor true_divide(const at::Tensor & self, const at::Scalar & other) {
return at::_ops::true_divide_Scalar::call(self, other);
}
// aten::dot(Tensor self, Tensor tensor) -> Tensor
TORCH_API inline at::Tensor dot(const at::Tensor & self, const at::Tensor & tensor) {
return at::_ops::dot::call(self, tensor);
}
// aten::dot.out(Tensor self, Tensor tensor, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & dot_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & tensor) {
return at::_ops::dot_out::call(self, tensor, out);
}
// aten::dot.out(Tensor self, Tensor tensor, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & dot_outf(const at::Tensor & self, const at::Tensor & tensor, at::Tensor & out) {
return at::_ops::dot_out::call(self, tensor, out);
}
// aten::vdot(Tensor self, Tensor other) -> Tensor
TORCH_API inline at::Tensor vdot(const at::Tensor & self, const at::Tensor & other) {
return at::_ops::vdot::call(self, other);
}
// aten::vdot.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & vdot_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return at::_ops::vdot_out::call(self, other, out);
}
// aten::vdot.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
TORCH_API inline at::Tensor & vdot_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return at::_ops::vdot_out::call(self, other, out);
}
// aten::einsum(str equation, Tensor[] tensors) -> Tensor
TORCH_API inline at::Tensor einsum(c10::string_view equation, at::TensorList tensors) {
return at::_ops::einsum::call(equation, tensors);
}
// aten::embedding(Tensor weight, Tensor indices, int padding_idx=-1, bool scale_grad_by_freq=False, bool sparse=False) -> Tensor
TORCH_API inline at::Tensor embedding(const at::Tensor & weight, const at::Tensor & indices, int64_t padding_idx=-1, bool scale_grad_by_freq=false, bool sparse=false) {
return at::_ops::embedding::call(weight, indices, padding_idx, scale_grad_by_freq, sparse);
}
// aten::embedding_backward(Tensor grad, Tensor indices, int num_weights, int padding_idx, bool scale_grad_by_freq, bool sparse) -> Tensor
TORCH_API inline at::Tensor embedding_backward(const at::Tensor & grad, const at::Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq, bool sparse) {
return at::_ops::embedding_backward::call(grad, indices, num_weights, padding_idx, scale_grad_by_freq, sparse);
}
// aten::embedding_dense_backward(Tensor grad_output, Tensor indices, int num_weights, int padding_idx, bool scale_grad_by_freq) -> Tensor
TORCH_API inline at::Tensor embedding_dense_backward(const at::Tensor & grad_output, const at::Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq) {
return at::_ops::embedding_dense_backward::call(grad_output, indices, num_weights, padding_idx, scale_grad_by_freq);
}
// aten::embedding_renorm_(Tensor(a!) self, Tensor indices, float max_norm, float norm_type) -> Tensor(a!)
TORCH_API inline at::Tensor & embedding_renorm_(at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type) {
return at::_ops::embedding_renorm_::call(self, indices, max_norm, norm_type);
}
// aten::embedding_sparse_backward(Tensor grad, Tensor indices, int num_weights, int padding_idx, bool scale_grad_by_freq) -> Tensor
TORCH_API inline at::Tensor embedding_sparse_backward(const at::Tensor & grad, const at::Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq) {
return at::_ops::embedding_sparse_backward::call(grad, indices, num_weights, padding_idx, scale_grad_by_freq);
}
// aten::_embedding_bag_forward_only(Tensor weight, Tensor indices, Tensor offsets, bool scale_grad_by_freq=False, int mode=0, bool sparse=False, Tensor? per_sample_weights=None, bool include_last_offset=False, int padding_idx=-1) -> (Tensor, Tensor, Tensor, Tensor)
TORCH_API inline ::std::tuple