aten/src/ATen/native/native_functions.yaml

# See README.md in this directory for more guidance


# Temporary type cast operators. These are needed to trace type-casts now since
# Type's are not supported in the IR. Instead, we call down to these
# specialized operators for each datatype.
# TODO: remove when we have Type support in the IR
- func: _cast_uint8_t(Tensor self, bool non_blocking=false) -> Tensor
  variants: function, method

- func: _cast_int8_t(Tensor self, bool non_blocking=false) -> Tensor
  variants: function, method

- func: _cast_double(Tensor self, bool non_blocking=false) -> Tensor
  variants: function, method

- func: _cast_float(Tensor self, bool non_blocking=false) -> Tensor
  variants: function, method

- func: _cast_int(Tensor self, bool non_blocking=false) -> Tensor
  variants: function, method

- func: _cast_int64_t(Tensor self, bool non_blocking=false) -> Tensor
  variants: function, method

- func: _cast_int16_t(Tensor self, bool non_blocking=false) -> Tensor
  variants: function, method

- func: _cast_Half(Tensor self, bool non_blocking=false) -> Tensor
  variants: function, method

- func: _cudnn_rnn_flatten_weight(TensorList weight_arr, int64_t weight_stride0, int64_t input_size, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, bool bidirectional) -> Tensor
  variants: function

- func: _cudnn_rnn(Tensor input, TensorList weight, int64_t weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, IntList batch_sizes, BoolTensor? dropout_state) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
  variants: function

- func: _cudnn_rnn_backward(Tensor input, TensorList weight, int64_t weight_stride0, Tensor weight_buf, Tensor hx, Tensor? cx, Tensor output, Tensor grad_output, Tensor grad_hy, Tensor? grad_cy, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, IntList batch_sizes, BoolTensor? dropout_state, Tensor reserve, std::array<bool,4> output_mask) -> (Tensor, Tensor, Tensor, TensorList)
  variants: function

- func: _cudnn_init_dropout_state(Type ty, double dropout, bool train, int64_t dropout_seed) -> Tensor
  variants: function

- func: adaptive_avg_pool1d(Tensor self, IntList[1] output_size) -> Tensor
  variants: function

- func: adaptive_max_pool1d(Tensor self, IntList[1] output_size) -> (Tensor, Tensor)
  variants: function

- func: allclose(Tensor self, Tensor other, double rtol=1e-5, double atol=1e-8) -> bool

- func: addmv(Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1) -> Tensor

- func: addmv_(Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1) -> Tensor

- func: addmv_out(Tensor result, Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1) -> Tensor
  variants: function

- func: addr(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor

- func: addr_(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
  variants: method

- func: addr_out(Tensor result, Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
  variants: function

- func: arange(Type dtype, Scalar start, Scalar end, Scalar step=1) -> Tensor
  variants: function

- func: arange_out(Tensor result, Scalar start, Scalar end, Scalar step=1) -> Tensor
  variants: function

- func: arange(Type dtype, Scalar end) -> Tensor
  variants: function

- func: arange_out(Tensor result, Scalar end) -> Tensor
  variants: function

- func: batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, double momentum, double eps, bool cudnn_enabled) -> Tensor
  variants: function

- func: bernoulli_(Tensor self, Tensor p, Generator* generator=nullptr) -> Tensor

- func: bernoulli_(Tensor self, double p=0.5, Generator* generator=nullptr) -> Tensor

- func: bilinear(Tensor input1, Tensor input2, Tensor weight, Tensor? bias) -> Tensor
  variants: function

- func: cat(TensorList tensors, int64_t dim=0) -> Tensor
  variants: function

- func: cat_out(Tensor result, TensorList tensors, int64_t dim=0) -> Tensor
  variants: function

- func: ceil(Tensor self) -> Tensor

- func: ceil_(Tensor self) -> Tensor

- func: ceil_out(Tensor result, Tensor self) -> Tensor
  variants: function
  dispatch:
    CPU: _ceil_out_cpu
    CUDA: _ceil_out_cuda

- func: chunk(Tensor self, int64_t chunks, int64_t dim=0) -> TensorList

- func: cudnn_is_acceptable(Tensor self) -> bool
  variants: function

- func: convolution(Tensor input, Tensor weight, Tensor? bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups) -> Tensor
  variants: function

- func: _convolution(Tensor input, Tensor weight, Tensor? bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled) -> Tensor
  variants: function

- func: _convolution_nogroup(Tensor input, Tensor weight, Tensor? bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding) -> Tensor
  variants: function

# NB: We MUST call the input self, otherwise codegen will attempt to
# dispatch on ggI... which might be undefined.
- func: _convolution_double_backward(Tensor? ggI, Tensor? ggW, Tensor? ggb, Tensor gO, Tensor weight, Tensor self, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled, std::array<bool,3> output_mask) -> (Tensor, Tensor, Tensor)
  variants: function

- func: conv1d(Tensor input, Tensor weight, Tensor bias={}, IntList[1] stride=1, IntList[1] padding=0, IntList[1] dilation=1, int64_t groups=1) -> Tensor
  variants: function

- func: conv2d(Tensor input, Tensor weight, Tensor bias={}, IntList[2] stride=1, IntList[2] padding=0, IntList[2] dilation=1, int64_t groups=1) -> Tensor
  variants: function

- func: conv3d(Tensor input, Tensor weight, Tensor bias={}, IntList[3] stride=1, IntList[3] padding=0, IntList[3] dilation=1, int64_t groups=1) -> Tensor
  variants: function

- func: conv_tbc(Tensor self, Tensor weight, Tensor bias, int64_t pad) -> Tensor

- func: conv_tbc_backward(Tensor self, Tensor input, Tensor weight, Tensor bias, int64_t pad) -> (Tensor, Tensor, Tensor)

# NB: we inherit the goofy argument order from PyTorch torch.nn.functional
- func: conv_transpose1d(Tensor input, Tensor weight, Tensor bias={}, IntList[1] stride=1, IntList[1] padding=0, IntList[1] output_padding=0, int64_t groups=1, IntList[1] dilation=1) -> Tensor
  variants: function

- func: conv_transpose2d(Tensor input, Tensor weight, Tensor bias={}, IntList[2] stride=1, IntList[2] padding=0, IntList[2] output_padding=0, int64_t groups=1, IntList[2] dilation=1) -> Tensor
  variants: function

- func: conv_transpose3d(Tensor input, Tensor weight, Tensor bias={}, IntList[3] stride=1, IntList[3] padding=0, IntList[3] output_padding=0, int64_t groups=1, IntList[3] dilation=1) -> Tensor
  variants: function

- func: cosine_embedding_loss(Tensor input1, Tensor input2, Tensor target, double margin, bool size_average, bool reduce) -> Tensor
  variants: function

- func: cudnn_affine_grid_generator(Tensor theta, int64_t N, int64_t C, int64_t H, int64_t W) -> Tensor
  return:
    - type: Tensor
      name: grid
  variants: function
  dispatch: cudnn_affine_grid_generator_forward

# TODO: Why do I have to call this grad?!
- func: cudnn_affine_grid_generator_backward(Tensor grad, int64_t N, int64_t C, int64_t H, int64_t W)
  return:
    - type: Tensor
      name: grad_theta
  variants: function

- func: cudnn_batch_norm(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, double exponential_average_factor, double epsilon) -> (Tensor, Tensor, Tensor)
  variants: function

# NB: You can only use this if you used cudnn_batch_norm training=True
- func: cudnn_batch_norm_backward(Tensor input, Tensor grad_output, Tensor weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var, double epsilon) -> (Tensor, Tensor, Tensor)
  variants: function

- func: cudnn_convolution(Tensor self, Tensor weight, Tensor? bias, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) -> Tensor
  variants: function

- func: cudnn_convolution_backward_input(IntList self_size, Tensor grad_output, Tensor weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) -> Tensor
  variants: function

- func: cudnn_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask) -> (Tensor, Tensor, Tensor)
  variants: function

- func: cudnn_convolution_backward_bias(Tensor grad_output) -> Tensor
  variants: function

- func: cudnn_convolution_backward_weight(IntList weight_size, Tensor grad_output, Tensor self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) -> Tensor
  variants: function

- func: cudnn_convolution_transpose(Tensor self, Tensor weight, Tensor? bias, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) -> Tensor
  variants: function

# NB: output_padding not strictly needed here, but it's helpful for the double
# backwards
- func: cudnn_convolution_transpose_backward(Tensor self, Tensor grad_output, Tensor weight, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask) -> (Tensor, Tensor, Tensor)
  variants: function

- func: cudnn_convolution_transpose_backward_bias(Tensor grad_output) -> Tensor
  variants: function
  dispatch: cudnn_convolution_backward_bias

- func: cudnn_convolution_transpose_backward_input(Tensor grad_output, Tensor weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) -> Tensor
  variants: function

- func: cudnn_convolution_transpose_backward_weight(IntList weight_size, Tensor grad_output, Tensor self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) -> Tensor
  variants: function

# NB: input is special cased in a way I don't quite understand
- func: cudnn_grid_sampler(Tensor self, Tensor grid)
  return:
    - type: Tensor
      name: output
  variants: function
  dispatch: cudnn_grid_sampler_forward

- func: cudnn_grid_sampler_backward(Tensor self, Tensor grid, Tensor grad_output)
  return:
    - type: Tensor
      name: grad_self
    - type: Tensor
      name: grad_grid
  variants: function

- func: det(Tensor self) -> Tensor

- func: diagflat(Tensor self, int64_t offset=0) -> Tensor
  variants: function

- func: diagonal(Tensor self, int64_t offset=0) -> Tensor
  variants: function

- func: dot(Tensor self, Tensor tensor) -> Tensor

- func: embedding(Tensor weight, IndexTensor indices, int64_t padding_idx=-1, bool scale_grad_by_freq=false, bool sparse=false) -> Tensor
  variants: function

- func: embedding_backward(Tensor grad, IndexTensor indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq, bool sparse) -> Tensor
  variants: function

- func: embedding_dense_backward(Tensor grad, IndexTensor indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq) -> Tensor
  variants: function
  dispatch:
    CPU: embedding_backward_cpu
    CUDA: embedding_backward_cuda

- func: embedding_renorm_(Tensor self, IndexTensor indices, double max_norm, double norm_type) -> Tensor
  variants: function
  dispatch:
    CPU: embedding_renorm_cpu_
    CUDA: embedding_renorm_cuda_

- func: embedding_sparse_backward(Tensor grad, IndexTensor indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq) -> Tensor
  variants: function

- func: embedding_bag(Tensor weight, IndexTensor indices, IndexTensor offsets, bool scale_grad_by_freq=false, int64_t mode=0, bool sparse=false) -> (Tensor, Tensor, Tensor)
  variants: function
  dispatch:
    CPU: embedding_bag_cpu
    CUDA: embedding_bag_cuda

- func: embedding_bag_backward(Tensor grad, IndexTensor indices, IndexTensor offsets, IndexTensor offset2bag, IndexTensor bag_size, int64_t num_weights, bool scale_grad_by_freq, int64_t mode, bool sparse) -> Tensor
  variants: function

- func: embedding_bag_sparse_backward(Tensor grad, IndexTensor indices, IndexTensor offsets, IndexTensor offset2bag, IndexTensor bag_size, int64_t num_weights, bool scale_grad_by_freq, int64_t mode) -> Tensor
  variants: function

- func: embedding_bag_dense_backward(Tensor grad, IndexTensor indices, IndexTensor offsets, IndexTensor offset2bag, IndexTensor bag_size, int64_t num_weights, bool scale_grad_by_freq, int64_t mode) -> Tensor
  variants: function
  dispatch:
    CPU: embedding_bag_backward_cpu
    CUDA: embedding_bag_backward_cuda

- func: empty(Type dtype, IntList size) -> Tensor
  variants: function

- func: empty_out(Tensor result, IntList size) -> Tensor
  variants: function

- func: empty_like(Tensor self) -> Tensor
  variants: function

- func: empty_like(Tensor self, *, Type dtype) -> Tensor
  variants: function

- func: expand(Tensor self, IntList size) -> Tensor
  variants: method  # This is method-only to match the previous tensor API. In the future we could make this a function too.

- func: expand_as(Tensor self, Tensor other) -> Tensor
  variants: method  # This is method-only to match the previous tensor API. In the future we could make this a function too.

- func: eye(Type dtype, int64_t n, int64_t m=-1) -> Tensor
  variants: function

- func: eye_out(Tensor result, int64_t n, int64_t m=-1) -> Tensor
  variants: function
  dispatch:
    CPU: eye_out_cpu
    CUDA: eye_out_cuda

- func: floor(Tensor self) -> Tensor

- func: floor_(Tensor self) -> Tensor

- func: floor_out(Tensor result, Tensor self) -> Tensor
  variants: function
  dispatch:
    CPU: _floor_out_cpu
    CUDA: _floor_out_cuda

- func: full(Type dtype, IntList size, Scalar fill_value) -> Tensor
  variants: function

- func: full_out(Tensor result, IntList size, Scalar fill_value) -> Tensor
  variants: function

- func: full_like(Tensor self, Scalar fill_value) -> Tensor
  variants: function

- func: full_like(Tensor self, Scalar fill_value, *, Type dtype) -> Tensor
  variants: function

- func: hinge_embedding_loss(Tensor self, Tensor target, double margin, bool size_average, bool reduce) -> Tensor
  variants: function

- func: ger(Tensor self, Tensor vec2) -> Tensor

- func: ger_out(Tensor result, Tensor self, Tensor vec2) -> Tensor
  variants: function

- func: group_norm(Tensor input, int64_t num_groups, Tensor? weight={}, Tensor? bias={}, double eps=1e-5) -> Tensor
  variants: function

- func: index(Tensor self, TensorList indices) -> Tensor
  # NB: This function is special-cased in tools/autograd/gen_variable_type.py

- func: index_copy_(Tensor self, int64_t dim, IndexTensor index, Tensor source) -> Tensor
  variants: method

- func: index_put_(Tensor self, TensorList indices, Tensor values) -> Tensor

- func: is_cuda(Tensor self) -> bool

- func: is_distributed(Tensor self) -> bool

- func: is_floating_point(Tensor self) -> bool

- func: is_nonzero(Tensor self) -> bool

- func: is_same_size(Tensor self, Tensor other) -> bool

- func: is_signed(Tensor self) -> bool

- func: is_sparse(Tensor self) -> bool

- func: linspace(Type dtype, Scalar start, Scalar end, int64_t steps=100) -> Tensor
  variants: function

- func: linspace_out(Tensor result, Scalar start, Scalar end, int64_t steps=100) -> Tensor
  variants: function

- func: logdet(Tensor self) -> Tensor

- func: logspace(Type dtype, Scalar start, Scalar end, int64_t steps=100) -> Tensor
  variants: function

- func: logspace_out(Tensor result, Scalar start, Scalar end, int64_t steps=100) -> Tensor
  variants: function

- func: margin_ranking_loss(Tensor input1, Tensor input2, Tensor target, double margin, bool size_average, bool reduce) -> Tensor
  variants: function

- func: matmul(Tensor self, Tensor other) -> Tensor

- func: max_pool1d(Tensor self, IntList[1] kernel_size, IntList[1] stride={}, IntList[1] padding=0, IntList[1] dilation=1, bool ceil_mode=false) -> (Tensor, Tensor)
  variants: function

- func: mm(Tensor self, Tensor mat2) -> Tensor

- func: mm_out(Tensor result, Tensor self, Tensor mat2) -> Tensor
  variants: function

- func: mv(Tensor self, Tensor vec) -> Tensor

- func: mv_out(Tensor result, Tensor self, Tensor vec) -> Tensor
  variants: function

- func: narrow(Tensor self, int64_t dim, int64_t start, int64_t length) -> Tensor

# TODO: Why does kW come before kH?  Hella confusing, because it
# doesn't match the input layout.
- func: nnpack_spatial_convolution(Tensor input, Tensor weight, Tensor? bias, int64_t kW, int64_t kH, int64_t padW, int64_t padH) -> Tensor
  variants: function

- func: nnpack_spatial_convolution_backward(Tensor input, Tensor grad_output, Tensor weight, int64_t kW, int64_t kH, int64_t padW, int64_t padH, std::array<bool,3> output_mask) -> (Tensor, Tensor, Tensor)
  variants: function

- func: nnpack_spatial_convolution_backward_input(Tensor input, Tensor grad_output, Tensor weight, int64_t kW, int64_t kH, int64_t padW, int64_t padH) -> Tensor
  variants: function

- func: nnpack_spatial_convolution_backward_weight(Tensor input, IntList weight_size, Tensor grad_output, int64_t kW, int64_t kH, int64_t padW, int64_t padH) -> Tensor
  variants: function

- func: ones(Type dtype, IntList size) -> Tensor
  variants: function

- func: ones_out(Tensor result, IntList size) -> Tensor
  variants: function

- func: ones_like(Tensor self) -> Tensor
  variants: function

- func: ones_like(Tensor self, *, Type dtype) -> Tensor
  variants: function

- func: pairwise_distance(Tensor x1, Tensor x2, double p=2, double eps=1e-6, bool keepdim=false) -> Tensor
  variants: function

- func: permute(Tensor self, IntList dims) -> Tensor
  variants: method  # This is method-only to match the previous tensor API. In the future we could make this a function too.

- func: pin_memory(Tensor self) -> Tensor

- func: rand(Type dtype, IntList size, *, Generator* generator=nullptr) -> Tensor
  variants: function

- func: rand_out(Tensor result, IntList size, *, Generator* generator=nullptr) -> Tensor
  variants: function

- func: rand_like(Tensor self) -> Tensor
  variants: function

- func: rand_like(Tensor self, *, Type dtype) -> Tensor
  variants: function

- func: randn(Type dtype, IntList size, *, Generator* generator=nullptr) -> Tensor
  variants: function

- func: randn_out(Tensor result, IntList size, *, Generator* generator=nullptr) -> Tensor
  variants: function

- func: randn_like(Tensor self) -> Tensor
  variants: function

- func: randn_like(Tensor self, *, Type dtype) -> Tensor
  variants: function

- func: randperm(Type dtype, int64_t n, *, Generator* generator=nullptr) -> Tensor
  variants: function

- func: randperm_out(Tensor result, int64_t n, *, Generator* generator=nullptr) -> Tensor
  variants: function

- func: range(Type dtype, Scalar start, Scalar end, Scalar step=1) -> Tensor
  variants: function

- func: range_out(Tensor result, Scalar start, Scalar end, Scalar step=1) -> Tensor
  variants: function

- func: repeat(Tensor self, IntList repeats) -> Tensor
  variants: method  # This is method-only to match the previous tensor API. In the future we could make this a function too.

- func: reshape(Tensor self, IntList shape) -> Tensor

- func: RoiPooling2d_forward(Tensor input, Tensor rois, int64_t pooledHeight, int64_t pooledWidth, double spatialScale) -> (Tensor, Tensor)
  variants: function
  dispatch:
    CPU: RoiPooling2d_forward_cpu
    CUDA: RoiPooling2d_forward_cuda

- func: RoiPooling2d_backward(Tensor input, Tensor rois, int64_t pooledHeight, int64_t pooledWidth, double spatialScale, Tensor gradOutput, Tensor argmaxes) -> Tensor
  variants: function
  dispatch:
    CPU: RoiPooling2d_backward_cpu
    CUDA: RoiPooling2d_backward_cuda

- func: round(Tensor self) -> Tensor

- func: round_(Tensor self) -> Tensor

- func: round_out(Tensor result, Tensor self) -> Tensor
  variants: function
  dispatch:
    CPU: _round_out_cpu
    CUDA: _round_out_cuda

- func: rrelu(Tensor self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator* generator=nullptr) -> Tensor
  variants: function

- func: rrelu_(Tensor self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator* generator=nullptr) -> Tensor
  variants: function

- func: relu(Tensor self) -> Tensor

- func: relu_(Tensor self) -> Tensor

- func: select(Tensor self, int64_t dim, int64_t index) -> Tensor

- func: selu(Tensor self) -> Tensor
  variants: function

- func: selu_(Tensor self) -> Tensor
  variants: function

- func: size(Tensor self, int64_t dim) -> int64_t

- func: slice(Tensor self, int64_t dim=0, int64_t start=0, int64_t end=9223372036854775807, int64_t step=1) -> Tensor

- func: slogdet(Tensor self) -> (Tensor, Tensor)

- func: smm(Tensor self, Tensor mat2) -> Tensor

- func: split(Tensor self, int64_t split_size, int64_t dim=0) -> TensorList

- func: split_with_sizes(Tensor self, IntList split_sizes, int64_t dim=0) -> TensorList

- func: squeeze(Tensor self) -> Tensor

- func: squeeze(Tensor self, int64_t dim) -> Tensor

- func: squeeze_(Tensor self) -> Tensor
  variants: method

- func: squeeze_(Tensor self, int64_t dim) -> Tensor
  variants: method

- func: sspaddmm(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor

- func: sspaddmm_out(Tensor result, Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
  variants: function
  dispatch:
    CPU: _sspaddmm_out_only_sparse
    CUDA: _sspaddmm_out_only_sparse
    SparseCPU: _sspaddmm_out_cpu
    SparseCUDA: _sspaddmm_out_cuda

- func: stack(TensorList tensors, int64_t dim=0) -> Tensor
  variants: function

- func: stack_out(Tensor result, TensorList tensors, int64_t dim=0) -> Tensor
  variants: function

- func: stft(Tensor self, int64_t frame_length, int64_t hop, int64_t fft_size, bool return_onesided=true, Tensor window={}, int64_t pad_end=0) -> Tensor
  python_default_init:
    fft_size: frame_length

- func: stride(Tensor self, int64_t dim) -> int64_t

- func: sum(Tensor self) -> Tensor
  dispatch:
    CPU: _sum_cpu
    CUDA: _sum_cuda

- func: sum(Tensor self, int64_t dim, bool keepdim=False) -> Tensor

- func: sum_out(Tensor result, Tensor self, int64_t dim, bool keepdim=False) -> Tensor
  variants: function
  dispatch:
    CPU: _sum_out_cpu
    CUDA: _sum_out_cuda

- func: sqrt(Tensor self) -> Tensor

- func: sqrt_(Tensor self) -> Tensor

- func: sqrt_out(Tensor result, Tensor self) -> Tensor
  variants: function
  dispatch:
    CPU: _sqrt_out_cpu
    CUDA: _sqrt_out_cuda

- func: prod(Tensor self) -> Tensor
  dispatch:
    CPU: _prod_cpu
    CUDA: _prod_cuda

- func: prod(Tensor self, int64_t dim, bool keepdim=False) -> Tensor

- func: prod_out(Tensor result, Tensor self, int64_t dim, bool keepdim=False) -> Tensor
  variants: function
  dispatch:
    CPU: _prod_out_cpu
    CUDA: _prod_out_cuda

- func: t_(Tensor self) -> Tensor
  variants: method

- func: transpose_(Tensor self, int64_t dim0, int64_t dim1) -> Tensor
  variants: method

- func: triplet_margin_loss(Tensor anchor, Tensor positive, Tensor negative, double margin=1.0, double p=2, double eps=1e-6, bool swap=false, bool size_average=true, bool reduce=true) -> Tensor
  variants: function

- func: trunc(Tensor self) -> Tensor

- func: trunc_(Tensor self) -> Tensor

- func: trunc_out(Tensor result, Tensor self) -> Tensor
  variants: function
  dispatch:
    CPU: _trunc_out_cpu
    CUDA: _trunc_out_cuda

- func: type_as(Tensor self, Tensor other) -> Tensor
  variants: method

- func: _unique(Tensor self, bool sorted=false, bool return_inverse=false) -> (Tensor, Tensor)
  dispatch:
    CPU: _unique_cpu
    CUDA: _unique_cuda

- func: _unsafe_view(Tensor self, IntList size) -> Tensor
  variants: function

- func: unsqueeze(Tensor self, int64_t dim) -> Tensor

- func: unsqueeze_(Tensor self, int64_t dim) -> Tensor
  variants: method

- func: view_as(Tensor self, Tensor other) -> Tensor
  variants: method

# we define both of these because 'where' does the broadcast and '_s_where' doesn't;
# this allows us to implicitly calculate the broadcast derivative, while only dealing with the
# _s_where derivative.
- func: where(BoolTensor condition, Tensor self, Tensor other) -> Tensor
- func: _s_where(BoolTensor condition, Tensor self, Tensor other) -> Tensor
  dispatch:
    CPU: _s_where_cpu
    CUDA: _s_where_cuda

- func: zeros(Type dtype, IntList size) -> Tensor
  variants: function

- func: zeros_out(Tensor result, IntList size) -> Tensor
  variants: function

- func: zeros_like(Tensor self) -> Tensor
  variants: function

- func: zeros_like(Tensor self, *, Type dtype) -> Tensor
  variants: function

- func: _standard_gamma_grad(Tensor self, Tensor output) -> Tensor
  dispatch:
    CPU: _standard_gamma_grad_cpu
    CUDA: _standard_gamma_grad_cuda

- func: poisson(Tensor self, Generator* generator=nullptr) -> Tensor
  variants: function
  dispatch:
    CPU: _s_poisson_cpu
    CUDA: _s_poisson_cuda