Struct tch::Tensor

pub struct Tensor { /* fields omitted */ }

A tensor object.

Implementations

impl Tensor

pub fn new() -> Tensor

Creates a new tensor.

pub unsafe fn from_ptr(c_tensor: *mut C_tensor) -> Self

Creates a new tensor from the pointer to an existing C++ tensor.

Safety

The caller must ensures that the pointer outlives the Rust object.

pub unsafe fn clone_from_ptr(c_tensor: *mut C_tensor) -> Self

Creates a new tensor from the pointer to an existing C++ tensor.

Safety

A shallow copy of the pointer is made so there is no need for this pointer to remain valid for the whole lifetime of the Rust object.

pub fn as_ptr(&self) -> *const C_tensor

Returns a pointer to the underlying C++ tensor.

The caller must ensures that the Rust tensor object outlives this pointer.

pub fn as_mut_ptr(&mut self) -> *mut C_tensor

Returns a mutable pointer to the underlying C++ tensor.

The caller must ensures that the Rust tensor object outlives this pointer.

pub fn dim(&self) -> usize

Returns the number of dimension of the tensor.

pub fn size(&self) -> Vec<i64>

Returns the shape of the input tensor.

pub fn size1(&self) -> Result<i64, TchError>

Returns the tensor size for single dimension tensors.

pub fn size2(&self) -> Result<(i64, i64), TchError>

Returns the tensor sizes for two dimension tensors.

pub fn size3(&self) -> Result<(i64, i64, i64), TchError>

Returns the tensor sizes for three dimension tensors.

pub fn size4(&self) -> Result<(i64, i64, i64, i64), TchError>

Returns the tensor sizes for four dimension tensors.

pub fn size5(&self) -> Result<(i64, i64, i64, i64, i64), TchError>

Returns the tensor sizes for five dimension tensors.

pub fn size6(&self) -> Result<(i64, i64, i64, i64, i64, i64), TchError>

Returns the tensor sizes for six dimension tensors.

pub fn stride(&self) -> Vec<i64>

Returns the stride of the input tensor.

pub fn stride1(&self) -> Result<i64, TchError>

Returns the tensor strides for single dimension tensors.

pub fn stride2(&self) -> Result<(i64, i64), TchError>

Returns the tensor strides for two dimension tensors.

pub fn stride3(&self) -> Result<(i64, i64, i64), TchError>

Returns the tensor strides for three dimension tensors.

pub fn stride4(&self) -> Result<(i64, i64, i64, i64), TchError>

Returns the tensor strides for four dimension tensors.

pub fn stride5(&self) -> Result<(i64, i64, i64, i64, i64), TchError>

Returns the tensor strides for five dimension tensors.

pub fn stride6(&self) -> Result<(i64, i64, i64, i64, i64, i64), TchError>

Returns the tensor strides for six dimension tensors.

pub fn f_kind(&self) -> Result<Kind, TchError>

Returns the kind of elements stored in the input tensor. Returns an error on undefined tensors and unsupported data types.

pub fn kind(&self) -> Kind

Returns the kind of elements stored in the input tensor. Panics an error on undefined tensors and unsupported data types.

pub fn device(&self) -> Device

Returns the device on which the input tensor is located.

pub fn print(&self)

Prints the input tensor.

Caution: this uses the C++ printer which prints the whole tensor even if it is very large.

pub fn f_double_value(&self, idx: &[i64]) -> Result<f64, TchError>

Returns a double value on tensors holding a single element. An error is returned otherwise.

pub fn f_int64_value(&self, idx: &[i64]) -> Result<i64, TchError>

Returns an int value on tensors holding a single element. An error is returned otherwise.

pub fn double_value(&self, idx: &[i64]) -> f64

Returns a double value on tensors holding a single element. Panics otherwise.

pub fn int64_value(&self, idx: &[i64]) -> i64

Returns an int value on tensors holding a single element. Panics otherwise.

pub fn requires_grad(&self) -> bool

Returns true if gradient are currently tracked for this tensor.

pub fn data_ptr(&self) -> *mut c_void

Returns the address of the first element of this tensor.

pub fn defined(&self) -> bool

Returns true if the tensor is defined.

pub fn is_mkldnn(&self) -> bool

Returns true if the tensor is compatible with MKL-DNN (oneDNN).

pub fn is_sparse(&self) -> bool

Returns true if the tensor is sparse.

pub fn zero_grad(&mut self)

Zeroes the gradient tensor attached to this tensor if defined.

pub fn f_backward(&self) -> Result<(), TchError>

Runs the backward pass, populating the gradient tensors for tensors which gradients are tracked.

Gradients tracking can be turned on via set_requires_grad.

pub fn backward(&self)

Runs the backward pass, populating the gradient tensors for tensors which gradients are tracked.

Gradients tracking can be turned on via set_requires_grad. Panics if the C++ api returns an exception.

pub fn f_run_backward<T1, T2>(
    tensors: &[T1],
    inputs: &[T2],
    keep_graph: bool,
    create_graph: bool
) -> Result<Vec<Tensor>, TchError> where
    T1: Borrow<Tensor>,
    T2: Borrow<Tensor>, 

pub fn run_backward<T1, T2>(
    tensors: &[T1],
    inputs: &[T2],
    keep_graph: bool,
    create_graph: bool
) -> Vec<Tensor> where
    T1: Borrow<Tensor>,
    T2: Borrow<Tensor>, 

pub fn f_copy_data_u8(
    &self,
    dst: &mut [u8],
    numel: usize
) -> Result<(), TchError>

Copies numel elements from self to dst.

pub fn f_internal_amp_non_finite_check_and_unscale(
    &mut self,
    found_inf: &mut Tensor,
    inv_scale: &Tensor
) -> Result<(), TchError>

Unscale tensor while checking for infinities.

found_inf is a singleton tensor that is used to record the presence of infinite values. inv_scale is a scalar containing the inverse scaling factor. This method is only available for CUDA tensors.

pub fn internal_amp_non_finite_check_and_unscale(
    &mut self,
    found_inf: &mut Tensor,
    inv_scale: &Tensor
)

Unscale tensor while checking for infinities.

found_inf is a singleton tensor that is used to record the presence of infinite values. inv_scale is a scalar containing the inverse scaling factor. This method is only available for CUDA tensors.

pub fn copy_data_u8(&self, dst: &mut [u8], numel: usize)

Copies numel elements from self to dst.

pub fn f_copy_data<T: Element>(
    &self,
    dst: &mut [T],
    numel: usize
) -> Result<(), TchError>

Copies numel elements from self to dst.

pub fn copy_data<T: Element>(&self, dst: &mut [T], numel: usize)

Copies numel elements from self to dst.

pub fn numel(&self) -> usize

Returns the total number of elements stored in a tensor.

pub fn f_of_slice<T: Element>(data: &[T]) -> Result<Tensor, TchError>

Converts a slice to a tensor.

pub fn of_slice<T: Element>(data: &[T]) -> Tensor

Converts a slice to a tensor.

pub fn f_of_data_size(
    data: &[u8],
    size: &[i64],
    kind: Kind
) -> Result<Tensor, TchError>

Converts some byte data to a tensor with some specified kind and shape.

pub unsafe fn f_of_blob(
    data: *const u8,
    size: &[i64],
    strides: &[i64],
    kind: Kind,
    device: Device
) -> Result<Tensor, TchError>

Creates a tensor from data that is assumed to be initialized. Resize operations are now allowed on this tensor without copying the data first.

Safety

This will panic if data points to invalid data.

pub unsafe fn of_blob(
    data: *const u8,
    size: &[i64],
    strides: &[i64],
    kind: Kind,
    device: Device
) -> Tensor

Creates a tensor from data that is assumed to be initialized. Resize operations are now allowed on this tensor without copying the data first.

Safety

This will panic if data points to invalid data.

pub fn of_data_size(data: &[u8], size: &[i64], kind: Kind) -> Tensor

Converts some byte data to a tensor with some specified kind and shape.

pub fn shallow_clone(&self) -> Tensor

Returns a new tensor that share storage with the input tensor.

pub fn f_get(&self, index: i64) -> Result<Tensor, TchError>

Gets the sub-tensor at the given index.

pub fn get(&self, index: i64) -> Tensor

Gets the sub-tensor at the given index.

pub fn f_copy_(&mut self, src: &Tensor) -> Result<(), TchError>

Copies values from the argument tensor to the input tensor.

pub fn copy_(&mut self, src: &Tensor)

Copies values from the argument tensor to the input tensor.

pub fn load<T: AsRef<Path>>(path: T) -> Result<Tensor, TchError>

Loads a tensor from a file.

The file format is the same as the one used by the PyTorch C++ API.

pub fn save<T: AsRef<Path>>(&self, path: T) -> Result<(), TchError>

Saves a tensor to a file.

The file format is the same as the one used by the PyTorch C++ API.

pub fn save_multi<S: AsRef<str>, T: AsRef<Tensor>, P: AsRef<Path>>(
    named_tensors: &[(S, T)],
    path: P
) -> Result<(), TchError>

Saves some named tensors to a file

The file format is the same as the one used by the PyTorch C++ API.

pub fn load_multi<T: AsRef<Path>>(
    path: T
) -> Result<Vec<(String, Tensor)>, TchError>

Loads some named tensors from a file

The file format is the same as the one used by the PyTorch C++ API.

pub fn load_multi_with_device<T: AsRef<Path>>(
    path: T,
    device: Device
) -> Result<Vec<(String, Tensor)>, TchError>

Loads some named tensors from a file to a given device

The file format is the same as the one used by the PyTorch C++ API.

pub fn to_string(&self, lw: i64) -> Result<String, TchError>

Returns a string representation for the tensor.

The representation will contain all the tensor element hence may be huge for large tensors.

impl Tensor

pub fn f_internal_and_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_and_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_iand_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_iand_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_ilshift_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_ilshift_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_ior_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_ior_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_irshift_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_irshift_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_ixor_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_ixor_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_lshift_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_lshift_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_or_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_or_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_rshift_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_rshift_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_xor_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_internal_xor_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_adaptive_avg_pool2d(
    &self,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_internal_adaptive_avg_pool2d_backward(
    &self,
    grad_output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_adaptive_avg_pool3d(
    &self,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_internal_adaptive_avg_pool3d_backward(
    &self,
    grad_output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_add_batch_dim(
    &self,
    batch_dim: i64,
    level: i64
) -> Result<Tensor, TchError>

pub fn f_internal_add_relu(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_internal_add_relu_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_add_relu_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_aminmax(&self) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_aminmax_dim(
    &self,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_amp_update_scale_(
    &mut self,
    growth_tracker: &Tensor,
    found_inf: &Tensor,
    scale_growth_factor: f64,
    scale_backoff_factor: f64,
    growth_interval: i64
) -> Result<Tensor, TchError>

pub fn f_internal_baddbmm_mkl_(
    &mut self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_bmm(
    &self,
    mat2: &Tensor,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_internal_bmm_out(
    &self,
    out: &Tensor,
    mat2: &Tensor,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cast_byte(
    &self,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cast_char(
    &self,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cast_double(
    &self,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cast_float(
    &self,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cast_half(
    &self,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cast_int(
    &self,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cast_long(
    &self,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cast_short(
    &self,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cat<T: Borrow<Tensor>>(
    tensors: &[T],
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_cat_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T],
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_cdist_backward(
    grad: &Tensor,
    x1: &Tensor,
    x2: &Tensor,
    p: f64,
    cdist: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_cholesky_solve_helper(
    &self,
    a: &Tensor,
    upper: bool
) -> Result<Tensor, TchError>

pub fn f_internal_coalesce(&self) -> Result<Tensor, TchError>

pub fn f_internal_coalesced_(
    &mut self,
    coalesced: bool
) -> Result<Tensor, TchError>

pub fn f_internal_compute_linear_combination(
    &self,
    coefficients: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_compute_linear_combination_out(
    &self,
    out: &Tensor,
    coefficients: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_conj(&self) -> Result<Tensor, TchError>

pub fn f_internal_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    cudnn_enabled: bool,
    allow_tf32: bool
) -> Result<Tensor, TchError>

pub fn f_internal_convolution_deprecated<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    cudnn_enabled: bool
) -> Result<Tensor, TchError>

pub fn f_internal_convolution_mode<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &str,
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_internal_convolution_nogroup<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_internal_copy_from(
    &self,
    dst: &Tensor,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_internal_ctc_loss(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    blank: i64,
    zero_infinity: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_ctc_loss_backward(
    grad: &Tensor,
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    neg_log_likelihood: &Tensor,
    log_alpha: &Tensor,
    blank: i64,
    zero_infinity: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cudnn_ctc_loss(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    blank: i64,
    deterministic: bool,
    zero_infinity: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_cudnn_init_dropout_state(
    dropout: f64,
    train: bool,
    dropout_seed: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_internal_cudnn_rnn<T: Borrow<Tensor>>(
    &self,
    weight: &[T],
    weight_stride0: i64,
    weight_buf: Option<T>,
    hx: &Tensor,
    cx: Option<T>,
    mode: i64,
    hidden_size: i64,
    proj_size: i64,
    num_layers: i64,
    batch_first: bool,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_sizes: &[i64],
    dropout_state: Option<T>
) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_cudnn_rnn_flatten_weight<T: Borrow<Tensor>>(
    weight_arr: &[T],
    weight_stride0: i64,
    input_size: i64,
    mode: i64,
    hidden_size: i64,
    proj_size: i64,
    num_layers: i64,
    batch_first: bool,
    bidirectional: bool
) -> Result<Tensor, TchError>

pub fn f_internal_cufft_get_plan_cache_max_size(
    device_index: i64
) -> Result<i64, TchError>

pub fn f_internal_cufft_get_plan_cache_size(
    device_index: i64
) -> Result<i64, TchError>

pub fn f_internal_cumprod(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_internal_cumprod_out(
    &self,
    out: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_cumsum(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_internal_cumsum_out(
    &self,
    out: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_debug_has_internal_overlap(&self) -> Result<i64, TchError>

pub fn f_internal_dim_arange(
    like: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_dimi(&self) -> Result<i64, TchError>

pub fn f_internal_dimv(&self) -> Result<i64, TchError>

pub fn f_internal_dirichlet_grad(
    x: &Tensor,
    alpha: &Tensor,
    total: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_embedding_bag<T: Borrow<Tensor>>(
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    include_last_offset: bool,
    padding_idx: i64
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_embedding_bag_backward<T: Borrow<Tensor>>(
    grad: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    offset2bag: &Tensor,
    bag_size: &Tensor,
    maximum_indices: &Tensor,
    num_weights: i64,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    padding_idx: i64
) -> Result<Tensor, TchError>

pub fn f_internal_embedding_bag_dense_backward<T: Borrow<Tensor>>(
    grad: &Tensor,
    indices: &Tensor,
    offset2bag: &Tensor,
    bag_size: &Tensor,
    maximum_indices: &Tensor,
    num_weights: i64,
    scale_grad_by_freq: bool,
    mode: i64,
    per_sample_weights: Option<T>,
    padding_idx: i64
) -> Result<Tensor, TchError>

pub fn f_internal_embedding_bag_forward_only<T: Borrow<Tensor>>(
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    include_last_offset: bool,
    padding_idx: i64
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_embedding_bag_per_sample_weights_backward(
    grad: &Tensor,
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    offset2bag: &Tensor,
    mode: i64,
    padding_idx: i64
) -> Result<Tensor, TchError>

pub fn f_internal_embedding_bag_sparse_backward<T: Borrow<Tensor>>(
    grad: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    offset2bag: &Tensor,
    bag_size: &Tensor,
    num_weights: i64,
    scale_grad_by_freq: bool,
    mode: i64,
    per_sample_weights: Option<T>,
    padding_idx: i64
) -> Result<Tensor, TchError>

pub fn f_internal_empty_affine_quantized(
    size: &[i64],
    options: (Kind, Device),
    scale: f64,
    zero_point: i64
) -> Result<Tensor, TchError>

pub fn f_internal_empty_per_channel_affine_quantized(
    size: &[i64],
    scales: &Tensor,
    zero_points: &Tensor,
    axis: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_internal_euclidean_dist(
    x1: &Tensor,
    x2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_fake_quantize_learnable_per_channel_affine(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64,
    grad_factor: f64
) -> Result<Tensor, TchError>

pub fn f_internal_fake_quantize_learnable_per_channel_affine_backward(
    &self,
    grad: &Tensor,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64,
    grad_factor: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_fake_quantize_learnable_per_tensor_affine(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    quant_min: i64,
    quant_max: i64,
    grad_factor: f64
) -> Result<Tensor, TchError>

pub fn f_internal_fake_quantize_learnable_per_tensor_affine_backward(
    &self,
    grad: &Tensor,
    scale: &Tensor,
    zero_point: &Tensor,
    quant_min: i64,
    quant_max: i64,
    grad_factor: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_fft_c2c(
    &self,
    dim: &[i64],
    normalization: i64,
    forward: bool
) -> Result<Tensor, TchError>

pub fn f_internal_fft_c2c_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    normalization: i64,
    forward: bool
) -> Result<Tensor, TchError>

pub fn f_internal_fft_c2r(
    &self,
    dim: &[i64],
    normalization: i64,
    last_dim_size: i64
) -> Result<Tensor, TchError>

pub fn f_internal_fft_c2r_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    normalization: i64,
    last_dim_size: i64
) -> Result<Tensor, TchError>

pub fn f_internal_fft_r2c(
    &self,
    dim: &[i64],
    normalization: i64,
    onesided: bool
) -> Result<Tensor, TchError>

pub fn f_internal_fft_r2c_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    normalization: i64,
    onesided: bool
) -> Result<Tensor, TchError>

pub fn f_internal_fused_dropout(
    &self,
    p: f64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_fw_primal(&self, level: i64) -> Result<Tensor, TchError>

pub fn f_internal_gather_sparse_backward(
    &self,
    dim: i64,
    index: &Tensor,
    grad: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_grid_sampler_2d_cpu_fallback(
    &self,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Result<Tensor, TchError>

pub fn f_internal_grid_sampler_2d_cpu_fallback_backward(
    &self,
    grad_output: &Tensor,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_has_compatible_shallow_copy_type(
    &self,
    from: &Tensor
) -> Result<bool, TchError>

pub fn f_internal_index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_index_put_impl_<T: Borrow<Tensor>>(
    &mut self,
    indices: &[Option<T>],
    values: &Tensor,
    accumulate: bool,
    unsafe_: bool
) -> Result<Tensor, TchError>

pub fn f_internal_indices(&self) -> Result<Tensor, TchError>

pub fn f_internal_inverse_helper(&self) -> Result<Tensor, TchError>

pub fn f_internal_linalg_inv_out_helper_(
    &mut self,
    infos_lu: &Tensor,
    infos_getri: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_linalg_qr_helper(
    &self,
    mode: &str
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_linalg_solve_out_helper_(
    &mut self,
    other: &Tensor,
    infos: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_log_softmax(
    &self,
    dim: i64,
    half_to_float: bool
) -> Result<Tensor, TchError>

pub fn f_internal_log_softmax_backward_data(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_logcumsumexp(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_internal_logcumsumexp_out(
    &self,
    out: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_lu_with_info(
    &self,
    pivot: bool,
    check_errors: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_make_dual(
    primal: &Tensor,
    tangent: &Tensor,
    level: i64
) -> Result<Tensor, TchError>

pub fn f_internal_make_per_channel_quantized_tensor(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64
) -> Result<Tensor, TchError>

pub fn f_internal_make_per_tensor_quantized_tensor(
    &self,
    scale: f64,
    zero_point: i64
) -> Result<Tensor, TchError>

pub fn f_internal_masked_scale(
    &self,
    mask: &Tensor,
    scale: f64
) -> Result<Tensor, TchError>

pub fn f_internal_mkldnn_reshape(
    &self,
    shape: &[i64]
) -> Result<Tensor, TchError>

pub fn f_internal_mkldnn_transpose(
    &self,
    dim0: i64,
    dim1: i64
) -> Result<Tensor, TchError>

pub fn f_internal_mkldnn_transpose_(
    &mut self,
    dim0: i64,
    dim1: i64
) -> Result<Tensor, TchError>

pub fn f_internal_nnpack_available() -> Result<bool, TchError>

pub fn f_internal_nnpack_spatial_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64]
) -> Result<Tensor, TchError>

pub fn f_internal_nnpack_spatial_convolution_backward_input(
    &self,
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_internal_nnpack_spatial_convolution_backward_weight(
    &self,
    weightsize: &[i64],
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_internal_nnz(&self) -> Result<i64, TchError>

pub fn f_internal_pack_padded_sequence(
    &self,
    lengths: &Tensor,
    batch_first: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_pack_padded_sequence_backward(
    grad: &Tensor,
    input_size: &[i64],
    batch_sizes: &Tensor,
    batch_first: bool
) -> Result<Tensor, TchError>

pub fn f_internal_pad_packed_sequence<S: Into<Scalar>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    batch_first: bool,
    padding_value: S,
    total_length: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_pdist_backward(
    &self,
    grad: &Tensor,
    p: f64,
    pdist: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_remove_batch_dim(
    &self,
    level: i64,
    batch_size: i64,
    out_dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_reshape_from_tensor(
    &self,
    shape: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_rowwise_prune(
    weight: &Tensor,
    mask: &Tensor,
    compressed_indices_dtype: Kind
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_s_where(
    &self,
    condition: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_sample_dirichlet(&self) -> Result<Tensor, TchError>

pub fn f_internal_saturate_weight_to_fp16(
    weight: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_shape_as_tensor(&self) -> Result<Tensor, TchError>

pub fn f_internal_sobol_engine_draw(
    quasi: &Tensor,
    n: i64,
    sobolstate: &Tensor,
    dimension: i64,
    num_generated: i64,
    dtype: Kind
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_sobol_engine_ff_(
    &mut self,
    n: i64,
    sobolstate: &Tensor,
    dimension: i64,
    num_generated: i64
) -> Result<Tensor, TchError>

pub fn f_internal_sobol_engine_initialize_state_(
    &mut self,
    dimension: i64
) -> Result<Tensor, TchError>

pub fn f_internal_sobol_engine_scramble_(
    &mut self,
    ltm: &Tensor,
    dimension: i64
) -> Result<Tensor, TchError>

pub fn f_internal_softmax(
    &self,
    dim: i64,
    half_to_float: bool
) -> Result<Tensor, TchError>

pub fn f_internal_softmax_backward_data(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_solve_helper(
    &self,
    a: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_sparse_addmm(
    &self,
    sparse: &Tensor,
    dense: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_coo_tensor_unsafe(
    indices: &Tensor,
    values: &Tensor,
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_coo_tensor_with_dims(
    sparse_dim: i64,
    dense_dim: i64,
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_coo_tensor_with_dims_and_tensors(
    sparse_dim: i64,
    dense_dim: i64,
    size: &[i64],
    indices: &Tensor,
    values: &Tensor,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_csr_tensor(
    crow_indices: &Tensor,
    col_indices: &Tensor,
    values: &Tensor,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_csr_tensor_crow_col_value_size(
    crow_indices: &Tensor,
    col_indices: &Tensor,
    values: &Tensor,
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_log_softmax(
    &self,
    dim: i64,
    half_to_float: bool
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_log_softmax_backward_data(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_log_softmax_int(
    &self,
    dim: i64,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_mask_helper(
    tr: &Tensor,
    mask_indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_mm(
    sparse: &Tensor,
    dense: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_softmax(
    &self,
    dim: i64,
    half_to_float: bool
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_softmax_backward_data(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_softmax_int(
    &self,
    dim: i64,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sparse_matmul(
    &self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sum(&self) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sum_backward(
    &self,
    grad: &Tensor,
    dim: &[i64]
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sum_dim(&self, dim: &[i64]) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sum_dim_dtype(
    &self,
    dim: &[i64],
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sum_dtype(
    &self,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_internal_stack<T: Borrow<Tensor>>(
    tensors: &[T],
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_stack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T],
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_standard_gamma(&self) -> Result<Tensor, TchError>

pub fn f_internal_standard_gamma_grad(
    &self,
    output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_svd_helper(
    &self,
    some: bool,
    compute_uv: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_symeig_helper(
    &self,
    eigenvectors: bool,
    upper: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_test_ambiguous_defaults(
    dummy: &Tensor,
    a: i64,
    b: i64
) -> Result<Tensor, TchError>

pub fn f_internal_test_ambiguous_defaults_b(
    dummy: &Tensor,
    a: i64,
    b: &str
) -> Result<Tensor, TchError>

pub fn f_internal_test_optional_filled_intlist<'a>(
    values: &Tensor,
    addends: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>

pub fn f_internal_test_optional_floatlist(
    values: &Tensor,
    addends: &[f64]
) -> Result<Tensor, TchError>

pub fn f_internal_test_optional_intlist<'a>(
    values: &Tensor,
    addends: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>

pub fn f_internal_test_serialization_subcmul(
    &self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_test_string_default(
    dummy: &Tensor,
    a: &str,
    b: &str
) -> Result<Tensor, TchError>

pub fn f_internal_trilinear(
    i1: &Tensor,
    i2: &Tensor,
    i3: &Tensor,
    expand1: &[i64],
    expand2: &[i64],
    expand3: &[i64],
    sumdim: &[i64],
    unroll_dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_unique(
    &self,
    sorted: bool,
    return_inverse: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_unique2(
    &self,
    sorted: bool,
    return_inverse: bool,
    return_counts: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_unpack_dual(
    dual: &Tensor,
    level: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_unsafe_view(&self, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_internal_use_cudnn_ctc_loss(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    blank: i64
) -> Result<bool, TchError>

pub fn f_internal_use_cudnn_rnn_flatten_weight() -> Result<bool, TchError>

pub fn f_internal_values(&self) -> Result<Tensor, TchError>

pub fn f_internal_version(&self) -> Result<i64, TchError>

pub fn f_internal_weight_norm(
    v: &Tensor,
    g: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_internal_weight_norm_cuda_interface(
    v: &Tensor,
    g: &Tensor,
    dim: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_weight_norm_cuda_interface_backward(
    grad_w: &Tensor,
    saved_v: &Tensor,
    saved_g: &Tensor,
    saved_norms: &Tensor,
    dim: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_weight_norm_differentiable_backward(
    grad_w: &Tensor,
    saved_v: &Tensor,
    saved_g: &Tensor,
    saved_norms: &Tensor,
    dim: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_abs(&self) -> Result<Tensor, TchError>

pub fn f_abs_(&mut self) -> Result<Tensor, TchError>

pub fn f_abs_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_absolute(&self) -> Result<Tensor, TchError>

pub fn f_absolute_(&mut self) -> Result<Tensor, TchError>

pub fn f_absolute_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_acos(&self) -> Result<Tensor, TchError>

pub fn f_acos_(&mut self) -> Result<Tensor, TchError>

pub fn f_acos_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_acosh(&self) -> Result<Tensor, TchError>

pub fn f_acosh_(&mut self) -> Result<Tensor, TchError>

pub fn f_acosh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool1d(
    &self,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool2d(
    &self,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool2d_out(
    &self,
    out: &Tensor,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool3d(
    &self,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool3d_backward(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool3d_out(
    &self,
    out: &Tensor,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_adaptive_max_pool1d(
    &self,
    output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>

pub fn f_adaptive_max_pool2d(
    &self,
    output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>

pub fn f_adaptive_max_pool2d_backward(
    &self,
    grad_output: &Tensor,
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_adaptive_max_pool2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_adaptive_max_pool2d_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>

pub fn f_adaptive_max_pool3d(
    &self,
    output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>

pub fn f_adaptive_max_pool3d_backward(
    &self,
    grad_output: &Tensor,
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_adaptive_max_pool3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_adaptive_max_pool3d_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>

pub fn f_add(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_add_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_add_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_add_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_add_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_addbmm(
    &self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addbmm_(
    &mut self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addbmm_out(
    &self,
    out: &Tensor,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addcdiv(
    &self,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addcdiv_(
    &mut self,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addcdiv_out(
    &self,
    out: &Tensor,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addcmul(
    &self,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addcmul_(
    &mut self,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addcmul_out(
    &self,
    out: &Tensor,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_addmm_(
    &mut self,
    mat1: &Tensor,
    mat2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addmm_out(
    &self,
    out: &Tensor,
    mat1: &Tensor,
    mat2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addmv(&self, mat: &Tensor, vec: &Tensor) -> Result<Tensor, TchError>

pub fn f_addmv_(
    &mut self,
    mat: &Tensor,
    vec: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addmv_out(
    &self,
    out: &Tensor,
    mat: &Tensor,
    vec: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addr(&self, vec1: &Tensor, vec2: &Tensor) -> Result<Tensor, TchError>

pub fn f_addr_(
    &mut self,
    vec1: &Tensor,
    vec2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_addr_out(
    &self,
    out: &Tensor,
    vec1: &Tensor,
    vec2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_affine_grid_generator(
    theta: &Tensor,
    size: &[i64],
    align_corners: bool
) -> Result<Tensor, TchError>

pub fn f_affine_grid_generator_backward(
    grad: &Tensor,
    size: &[i64],
    align_corners: bool
) -> Result<Tensor, TchError>

pub fn f_alias(&self) -> Result<Tensor, TchError>

pub fn f_align_as(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_align_tensors<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Vec<Tensor>, TchError>

pub fn f_all(&self) -> Result<Tensor, TchError>

pub fn f_all_dim(&self, dim: i64, keepdim: bool) -> Result<Tensor, TchError>

pub fn f_all_out(
    &self,
    out: &Tensor,
    dim: i64,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_allclose(
    &self,
    other: &Tensor,
    rtol: f64,
    atol: f64,
    equal_nan: bool
) -> Result<bool, TchError>

pub fn f_alpha_dropout(&self, p: f64, train: bool) -> Result<Tensor, TchError>

pub fn f_alpha_dropout_(
    &mut self,
    p: f64,
    train: bool
) -> Result<Tensor, TchError>

pub fn f_amax(&self, dim: &[i64], keepdim: bool) -> Result<Tensor, TchError>

pub fn f_amax_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_amin(&self, dim: &[i64], keepdim: bool) -> Result<Tensor, TchError>

pub fn f_amin_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_angle(&self) -> Result<Tensor, TchError>

pub fn f_angle_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_any(&self) -> Result<Tensor, TchError>

pub fn f_any_dim(&self, dim: i64, keepdim: bool) -> Result<Tensor, TchError>

pub fn f_any_out(
    &self,
    out: &Tensor,
    dim: i64,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_arange<S: Into<Scalar>>(
    end: S,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_arange_out<S: Into<Scalar>>(
    out: &Tensor,
    end: S
) -> Result<Tensor, TchError>

pub fn f_arange_start<S: Into<Scalar>>(
    start: S,
    end: S,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_arange_start_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S
) -> Result<Tensor, TchError>

pub fn f_arange_start_step<S: Into<Scalar>>(
    start: S,
    end: S,
    step: S,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_arccos(&self) -> Result<Tensor, TchError>

pub fn f_arccos_(&mut self) -> Result<Tensor, TchError>

pub fn f_arccos_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_arccosh(&self) -> Result<Tensor, TchError>

pub fn f_arccosh_(&mut self) -> Result<Tensor, TchError>

pub fn f_arccosh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_arcsin(&self) -> Result<Tensor, TchError>

pub fn f_arcsin_(&mut self) -> Result<Tensor, TchError>

pub fn f_arcsin_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_arcsinh(&self) -> Result<Tensor, TchError>

pub fn f_arcsinh_(&mut self) -> Result<Tensor, TchError>

pub fn f_arcsinh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_arctan(&self) -> Result<Tensor, TchError>

pub fn f_arctan_(&mut self) -> Result<Tensor, TchError>

pub fn f_arctan_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_arctanh(&self) -> Result<Tensor, TchError>

pub fn f_arctanh_(&mut self) -> Result<Tensor, TchError>

pub fn f_arctanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_argmax(
    &self,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_argmax_out(
    &self,
    out: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_argmin(
    &self,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_argmin_out(
    &self,
    out: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_argsort(&self, dim: i64, descending: bool) -> Result<Tensor, TchError>

pub fn f_as_strided(
    &self,
    size: &[i64],
    stride: &[i64],
    storage_offset: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_as_strided_(
    &mut self,
    size: &[i64],
    stride: &[i64],
    storage_offset: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_asin(&self) -> Result<Tensor, TchError>

pub fn f_asin_(&mut self) -> Result<Tensor, TchError>

pub fn f_asin_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_asinh(&self) -> Result<Tensor, TchError>

pub fn f_asinh_(&mut self) -> Result<Tensor, TchError>

pub fn f_asinh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_atan(&self) -> Result<Tensor, TchError>

pub fn f_atan2(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_atan2_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_atan2_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_atan_(&mut self) -> Result<Tensor, TchError>

pub fn f_atan_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_atanh(&self) -> Result<Tensor, TchError>

pub fn f_atanh_(&mut self) -> Result<Tensor, TchError>

pub fn f_atanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_atleast_1d(&self) -> Result<Tensor, TchError>

pub fn f_atleast_1d_sequence<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Vec<Tensor>, TchError>

pub fn f_atleast_2d(&self) -> Result<Tensor, TchError>

pub fn f_atleast_2d_sequence<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Vec<Tensor>, TchError>

pub fn f_atleast_3d(&self) -> Result<Tensor, TchError>

pub fn f_atleast_3d_sequence<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Vec<Tensor>, TchError>

pub fn f_avg_pool1d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool
) -> Result<Tensor, TchError>

pub fn f_avg_pool2d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_avg_pool2d_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_avg_pool2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_avg_pool2d_out(
    &self,
    out: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_avg_pool3d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_avg_pool3d_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_avg_pool3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_avg_pool3d_out(
    &self,
    out: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_baddbmm(
    &self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_baddbmm_(
    &mut self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_baddbmm_out(
    &self,
    out: &Tensor,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_bartlett_window(
    window_length: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_bartlett_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    momentum: f64,
    eps: f64,
    cudnn_enabled: bool
) -> Result<Tensor, TchError>

pub fn f_batch_norm_backward_elemt<T: Borrow<Tensor>>(
    &self,
    grad_out: &Tensor,
    mean: &Tensor,
    invstd: &Tensor,
    weight: Option<T>,
    mean_dy: &Tensor,
    mean_dy_xmu: &Tensor,
    count: &Tensor
) -> Result<Tensor, TchError>

pub fn f_batch_norm_backward_reduce<T: Borrow<Tensor>>(
    &self,
    grad_out: &Tensor,
    mean: &Tensor,
    invstd: &Tensor,
    weight: Option<T>,
    input_g: bool,
    weight_g: bool,
    bias_g: bool
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_batch_norm_elemt<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    mean: &Tensor,
    invstd: &Tensor,
    eps: f64
) -> Result<Tensor, TchError>

pub fn f_batch_norm_elemt_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    weight: Option<T>,
    bias: Option<T>,
    mean: &Tensor,
    invstd: &Tensor,
    eps: f64
) -> Result<Tensor, TchError>

pub fn f_batch_norm_gather_stats<T: Borrow<Tensor>>(
    &self,
    mean: &Tensor,
    invstd: &Tensor,
    running_mean: Option<T>,
    running_var: Option<T>,
    momentum: f64,
    eps: f64,
    count: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_batch_norm_gather_stats_with_counts<T: Borrow<Tensor>>(
    &self,
    mean: &Tensor,
    invstd: &Tensor,
    running_mean: Option<T>,
    running_var: Option<T>,
    momentum: f64,
    eps: f64,
    counts: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_batch_norm_stats(&self, eps: f64) -> Result<(Tensor, Tensor), TchError>

pub fn f_batch_norm_update_stats<T: Borrow<Tensor>>(
    &self,
    running_mean: Option<T>,
    running_var: Option<T>,
    momentum: f64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_bernoulli(&self) -> Result<Tensor, TchError>

pub fn f_bernoulli_(&mut self, p: &Tensor) -> Result<Tensor, TchError>

pub fn f_bernoulli_float_(&mut self, p: f64) -> Result<Tensor, TchError>

pub fn f_bernoulli_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_bernoulli_p(&self, p: f64) -> Result<Tensor, TchError>

pub fn f_bilinear<T: Borrow<Tensor>>(
    input1: &Tensor,
    input2: &Tensor,
    weight: &Tensor,
    bias: Option<T>
) -> Result<Tensor, TchError>

pub fn f_binary_cross_entropy<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_binary_cross_entropy_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_binary_cross_entropy_backward_grad_input<T: Borrow<Tensor>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_binary_cross_entropy_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_binary_cross_entropy_with_logits<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    pos_weight: Option<T>,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_binary_cross_entropy_with_logits_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    pos_weight: Option<T>,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_bincount<T: Borrow<Tensor>>(
    &self,
    weights: Option<T>,
    minlength: i64
) -> Result<Tensor, TchError>

pub fn f_binomial(count: &Tensor, prob: &Tensor) -> Result<Tensor, TchError>

pub fn f_bitwise_and<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_bitwise_and_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_bitwise_and_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_bitwise_and_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_bitwise_and_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_bitwise_and_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_bitwise_not(&self) -> Result<Tensor, TchError>

pub fn f_bitwise_not_(&mut self) -> Result<Tensor, TchError>

pub fn f_bitwise_not_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_bitwise_or<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_bitwise_or_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_bitwise_or_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_bitwise_or_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_bitwise_or_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_bitwise_or_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_bitwise_xor<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_bitwise_xor_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_bitwise_xor_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_bitwise_xor_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_bitwise_xor_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_bitwise_xor_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_blackman_window(
    window_length: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_blackman_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_block_diag<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_bmm(&self, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_bmm_out(&self, out: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_broadcast_tensors<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Vec<Tensor>, TchError>

pub fn f_broadcast_to(&self, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_bucketize(
    &self,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Result<Tensor, TchError>

pub fn f_bucketize_scalar<S: Into<Scalar>>(
    self_scalar: S,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Result<Tensor, TchError>

pub fn f_bucketize_tensor_out(
    &self,
    out: &Tensor,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Result<Tensor, TchError>

pub fn f_can_cast(from: Kind, to: Kind) -> Result<bool, TchError>

pub fn f_cartesian_prod<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_cat<T: Borrow<Tensor>>(
    tensors: &[T],
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_cat_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T],
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_cauchy_(&mut self, median: f64, sigma: f64) -> Result<Tensor, TchError>

pub fn f_cdist(
    x1: &Tensor,
    x2: &Tensor,
    p: f64,
    compute_mode: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_ceil(&self) -> Result<Tensor, TchError>

pub fn f_ceil_(&mut self) -> Result<Tensor, TchError>

pub fn f_ceil_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_celu(&self) -> Result<Tensor, TchError>

pub fn f_celu_(&mut self) -> Result<Tensor, TchError>

pub fn f_chain_matmul<T: Borrow<Tensor>>(
    matrices: &[T]
) -> Result<Tensor, TchError>

pub fn f_chain_matmul_out<T: Borrow<Tensor>>(
    out: &Tensor,
    matrices: &[T]
) -> Result<Tensor, TchError>

pub fn f_channel_shuffle(&self, groups: i64) -> Result<Tensor, TchError>

pub fn f_cholesky(&self, upper: bool) -> Result<Tensor, TchError>

pub fn f_cholesky_inverse(&self, upper: bool) -> Result<Tensor, TchError>

pub fn f_cholesky_inverse_out(
    &self,
    out: &Tensor,
    upper: bool
) -> Result<Tensor, TchError>

pub fn f_cholesky_out(
    &self,
    out: &Tensor,
    upper: bool
) -> Result<Tensor, TchError>

pub fn f_cholesky_solve(
    &self,
    input2: &Tensor,
    upper: bool
) -> Result<Tensor, TchError>

pub fn f_cholesky_solve_out(
    &self,
    out: &Tensor,
    input2: &Tensor,
    upper: bool
) -> Result<Tensor, TchError>

pub fn f_choose_qparams_optimized(
    &self,
    numel: i64,
    n_bins: i64,
    ratio: f64,
    bit_width: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_chunk(&self, chunks: i64, dim: i64) -> Result<Vec<Tensor>, TchError>

pub fn f_clamp<S: Into<Scalar>>(
    &self,
    min: S,
    max: S
) -> Result<Tensor, TchError>

pub fn f_clamp_<S: Into<Scalar>>(
    &mut self,
    min: S,
    max: S
) -> Result<Tensor, TchError>

pub fn f_clamp_max<S: Into<Scalar>>(&self, max: S) -> Result<Tensor, TchError>

pub fn f_clamp_max_<S: Into<Scalar>>(
    &mut self,
    max: S
) -> Result<Tensor, TchError>

pub fn f_clamp_max_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    max: S
) -> Result<Tensor, TchError>

pub fn f_clamp_max_tensor(&self, max: &Tensor) -> Result<Tensor, TchError>

pub fn f_clamp_max_tensor_(&mut self, max: &Tensor) -> Result<Tensor, TchError>

pub fn f_clamp_max_tensor_out(
    &self,
    out: &Tensor,
    max: &Tensor
) -> Result<Tensor, TchError>

pub fn f_clamp_min<S: Into<Scalar>>(&self, min: S) -> Result<Tensor, TchError>

pub fn f_clamp_min_<S: Into<Scalar>>(
    &mut self,
    min: S
) -> Result<Tensor, TchError>

pub fn f_clamp_min_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    min: S
) -> Result<Tensor, TchError>

pub fn f_clamp_min_tensor(&self, min: &Tensor) -> Result<Tensor, TchError>

pub fn f_clamp_min_tensor_(&mut self, min: &Tensor) -> Result<Tensor, TchError>

pub fn f_clamp_min_tensor_out(
    &self,
    out: &Tensor,
    min: &Tensor
) -> Result<Tensor, TchError>

pub fn f_clamp_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    min: S,
    max: S
) -> Result<Tensor, TchError>

pub fn f_clamp_tensor<T: Borrow<Tensor>>(
    &self,
    min: Option<T>,
    max: Option<T>
) -> Result<Tensor, TchError>

pub fn f_clamp_tensor_<T: Borrow<Tensor>>(
    &mut self,
    min: Option<T>,
    max: Option<T>
) -> Result<Tensor, TchError>

pub fn f_clamp_tensor_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    min: Option<T>,
    max: Option<T>
) -> Result<Tensor, TchError>

pub fn f_clip<S: Into<Scalar>>(
    &self,
    min: S,
    max: S
) -> Result<Tensor, TchError>

pub fn f_clip_<S: Into<Scalar>>(
    &mut self,
    min: S,
    max: S
) -> Result<Tensor, TchError>

pub fn f_clip_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    min: S,
    max: S
) -> Result<Tensor, TchError>

pub fn f_clip_tensor<T: Borrow<Tensor>>(
    &self,
    min: Option<T>,
    max: Option<T>
) -> Result<Tensor, TchError>

pub fn f_clip_tensor_<T: Borrow<Tensor>>(
    &mut self,
    min: Option<T>,
    max: Option<T>
) -> Result<Tensor, TchError>

pub fn f_clip_tensor_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    min: Option<T>,
    max: Option<T>
) -> Result<Tensor, TchError>

pub fn f_coalesce(&self) -> Result<Tensor, TchError>

pub fn f_col2im(
    &self,
    output_size: &[i64],
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Result<Tensor, TchError>

pub fn f_col2im_backward(
    grad_output: &Tensor,
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Result<Tensor, TchError>

pub fn f_col2im_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Result<Tensor, TchError>

pub fn f_col2im_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Result<Tensor, TchError>

pub fn f_col_indices(&self) -> Result<Tensor, TchError>

pub fn f_column_stack<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_column_stack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_combinations(
    &self,
    r: i64,
    with_replacement: bool
) -> Result<Tensor, TchError>

pub fn f_complex(real: &Tensor, imag: &Tensor) -> Result<Tensor, TchError>

pub fn f_complex_out(
    out: &Tensor,
    real: &Tensor,
    imag: &Tensor
) -> Result<Tensor, TchError>

pub fn f_conj(&self) -> Result<Tensor, TchError>

pub fn f_conj_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_constant_pad_nd(&self, pad: &[i64]) -> Result<Tensor, TchError>

pub fn f_contiguous(&self) -> Result<Tensor, TchError>

pub fn f_conv1d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_conv1d_padding<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &str,
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_conv2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_conv2d_padding<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &str,
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_conv3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_conv3d_padding<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &str,
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_conv_depthwise3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_conv_depthwise3d_backward(
    &self,
    grad_input: &Tensor,
    grad_weight: &Tensor,
    grad_bias: &Tensor,
    grad_output: &Tensor,
    weight: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64]
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_conv_tbc(
    &self,
    weight: &Tensor,
    bias: &Tensor,
    pad: i64
) -> Result<Tensor, TchError>

pub fn f_conv_tbc_backward(
    &self,
    input: &Tensor,
    weight: &Tensor,
    bias: &Tensor,
    pad: i64
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_conv_transpose1d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    groups: i64,
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_conv_transpose2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    groups: i64,
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_conv_transpose3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    groups: i64,
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_convolution_overrideable<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_copy_sparse_to_sparse_(
    &mut self,
    src: &Tensor,
    non_blocking: bool
) -> Result<Tensor, TchError>

pub fn f_copysign(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_copysign_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_copysign_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_copysign_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_copysign_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_copysign_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_cos(&self) -> Result<Tensor, TchError>

pub fn f_cos_(&mut self) -> Result<Tensor, TchError>

pub fn f_cos_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_cosh(&self) -> Result<Tensor, TchError>

pub fn f_cosh_(&mut self) -> Result<Tensor, TchError>

pub fn f_cosh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_cosine_embedding_loss(
    input1: &Tensor,
    input2: &Tensor,
    target: &Tensor,
    margin: f64,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_cosine_similarity(
    x1: &Tensor,
    x2: &Tensor,
    dim: i64,
    eps: f64
) -> Result<Tensor, TchError>

pub fn f_count_nonzero(
    &self,
    dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_count_nonzero_dim_intlist(
    &self,
    dim: &[i64]
) -> Result<Tensor, TchError>

pub fn f_cross(
    &self,
    other: &Tensor,
    dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_cross_entropy_loss<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Result<Tensor, TchError>

pub fn f_cross_out(
    &self,
    out: &Tensor,
    other: &Tensor,
    dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_crow_indices(&self) -> Result<Tensor, TchError>

pub fn f_ctc_loss(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    blank: i64,
    reduction: Reduction,
    zero_infinity: bool
) -> Result<Tensor, TchError>

pub fn f_ctc_loss_tensor(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &Tensor,
    target_lengths: &Tensor,
    blank: i64,
    reduction: Reduction,
    zero_infinity: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_affine_grid_generator(
    theta: &Tensor,
    n: i64,
    c: i64,
    h: i64,
    w: i64
) -> Result<Tensor, TchError>

pub fn f_cudnn_affine_grid_generator_backward(
    grad: &Tensor,
    n: i64,
    c: i64,
    h: i64,
    w: i64
) -> Result<Tensor, TchError>

pub fn f_cudnn_batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    exponential_average_factor: f64,
    epsilon: f64
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_cudnn_batch_norm_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    weight: &Tensor,
    running_mean: Option<T>,
    running_var: Option<T>,
    save_mean: Option<T>,
    save_var: Option<T>,
    epsilon: f64,
    reservespace: &Tensor
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_cudnn_convolution(
    &self,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_add_relu<T: Borrow<Tensor>, S: Into<Scalar>>(
    &self,
    weight: &Tensor,
    z: &Tensor,
    alpha: S,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_backward_input(
    self_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_deprecated<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_deprecated2(
    &self,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_relu<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_transpose(
    &self,
    weight: &Tensor,
    padding: &[i64],
    output_padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_transpose_backward_input(
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_transpose_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_transpose_deprecated<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    output_padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution_transpose_deprecated2(
    &self,
    weight: &Tensor,
    padding: &[i64],
    output_padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_cudnn_grid_sampler(&self, grid: &Tensor) -> Result<Tensor, TchError>

pub fn f_cudnn_grid_sampler_backward(
    &self,
    grid: &Tensor,
    grad_output: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_cudnn_is_acceptable(&self) -> Result<bool, TchError>

pub fn f_cummax(&self, dim: i64) -> Result<(Tensor, Tensor), TchError>

pub fn f_cummax_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_cummaxmin_backward(
    &self,
    grad: &Tensor,
    indices: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_cummin(&self, dim: i64) -> Result<(Tensor, Tensor), TchError>

pub fn f_cummin_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_cumprod(&self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_cumprod_(&mut self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_cumprod_backward(
    &self,
    grad: &Tensor,
    dim: i64,
    output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_cumprod_out(
    &self,
    out: &Tensor,
    dim: i64,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_cumsum(&self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_cumsum_(&mut self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_cumsum_out(
    &self,
    out: &Tensor,
    dim: i64,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_data(&self) -> Result<Tensor, TchError>

pub fn f_deg2rad(&self) -> Result<Tensor, TchError>

pub fn f_deg2rad_(&mut self) -> Result<Tensor, TchError>

pub fn f_deg2rad_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_dense_dim(&self) -> Result<i64, TchError>

pub fn f_dequantize(&self) -> Result<Tensor, TchError>

pub fn f_dequantize_tensors<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Vec<Tensor>, TchError>

pub fn f_det(&self) -> Result<Tensor, TchError>

pub fn f_detach(&self) -> Result<Tensor, TchError>

pub fn f_detach_(&mut self) -> Result<Tensor, TchError>

pub fn f_diag(&self, diagonal: i64) -> Result<Tensor, TchError>

pub fn f_diag_backward(
    grad: &Tensor,
    input_sizes: &[i64],
    diagonal: i64
) -> Result<Tensor, TchError>

pub fn f_diag_embed(
    &self,
    offset: i64,
    dim1: i64,
    dim2: i64
) -> Result<Tensor, TchError>

pub fn f_diag_out(
    &self,
    out: &Tensor,
    diagonal: i64
) -> Result<Tensor, TchError>

pub fn f_diagflat(&self, offset: i64) -> Result<Tensor, TchError>

pub fn f_diagonal(
    &self,
    offset: i64,
    dim1: i64,
    dim2: i64
) -> Result<Tensor, TchError>

pub fn f_diagonal_backward(
    grad: &Tensor,
    input_sizes: &[i64],
    offset: i64,
    dim1: i64,
    dim2: i64
) -> Result<Tensor, TchError>

pub fn f_diff<T: Borrow<Tensor>>(
    &self,
    n: i64,
    dim: i64,
    prepend: Option<T>,
    append: Option<T>
) -> Result<Tensor, TchError>

pub fn f_diff_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    n: i64,
    dim: i64,
    prepend: Option<T>,
    append: Option<T>
) -> Result<Tensor, TchError>

pub fn f_digamma(&self) -> Result<Tensor, TchError>

pub fn f_digamma_(&mut self) -> Result<Tensor, TchError>

pub fn f_digamma_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_dist(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_div(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_div_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_div_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_div_out_mode(
    &self,
    out: &Tensor,
    other: &Tensor,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_div_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_div_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_div_scalar_mode<S: Into<Scalar>>(
    &self,
    other: S,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_div_scalar_mode_<S: Into<Scalar>>(
    &mut self,
    other: S,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_div_tensor_mode(
    &self,
    other: &Tensor,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_div_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_divide(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_divide_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_divide_out_mode(
    &self,
    out: &Tensor,
    other: &Tensor,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_divide_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_divide_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_divide_scalar_mode<S: Into<Scalar>>(
    &self,
    other: S,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_divide_scalar_mode_<S: Into<Scalar>>(
    &mut self,
    other: S,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_divide_tensor_mode(
    &self,
    other: &Tensor,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_divide_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Result<Tensor, TchError>

pub fn f_dot(&self, tensor: &Tensor) -> Result<Tensor, TchError>

pub fn f_dot_out(
    &self,
    out: &Tensor,
    tensor: &Tensor
) -> Result<Tensor, TchError>

pub fn f_dropout(&self, p: f64, train: bool) -> Result<Tensor, TchError>

pub fn f_dropout_(&mut self, p: f64, train: bool) -> Result<Tensor, TchError>

pub fn f_dsplit(&self, sections: i64) -> Result<Vec<Tensor>, TchError>

pub fn f_dsplit_array(&self, indices: &[i64]) -> Result<Vec<Tensor>, TchError>

pub fn f_dstack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>

pub fn f_dstack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_eig(&self, eigenvectors: bool) -> Result<(Tensor, Tensor), TchError>

pub fn f_eig_e(
    &self,
    e: &Tensor,
    v: &Tensor,
    eigenvectors: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_einsum<T: Borrow<Tensor>>(
    equation: &str,
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_elu(&self) -> Result<Tensor, TchError>

pub fn f_elu_(&mut self) -> Result<Tensor, TchError>

pub fn f_elu_backward<S: Into<Scalar>>(
    grad_output: &Tensor,
    alpha: S,
    scale: S,
    input_scale: S,
    is_result: bool,
    self_or_result: &Tensor
) -> Result<Tensor, TchError>

pub fn f_elu_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_embedding(
    weight: &Tensor,
    indices: &Tensor,
    padding_idx: i64,
    scale_grad_by_freq: bool,
    sparse: bool
) -> Result<Tensor, TchError>

pub fn f_embedding_backward(
    grad: &Tensor,
    indices: &Tensor,
    num_weights: i64,
    padding_idx: i64,
    scale_grad_by_freq: bool,
    sparse: bool
) -> Result<Tensor, TchError>

pub fn f_embedding_bag<T: Borrow<Tensor>>(
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    include_last_offset: bool
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_embedding_bag_padding_idx<T: Borrow<Tensor>>(
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    include_last_offset: bool,
    padding_idx: impl Into<Option<i64>>
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_embedding_dense_backward(
    grad_output: &Tensor,
    indices: &Tensor,
    num_weights: i64,
    padding_idx: i64,
    scale_grad_by_freq: bool
) -> Result<Tensor, TchError>

pub fn f_embedding_renorm_(
    &mut self,
    indices: &Tensor,
    max_norm: f64,
    norm_type: f64
) -> Result<Tensor, TchError>

pub fn f_embedding_sparse_backward(
    grad: &Tensor,
    indices: &Tensor,
    num_weights: i64,
    padding_idx: i64,
    scale_grad_by_freq: bool
) -> Result<Tensor, TchError>

pub fn f_empty(
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_empty_like(&self) -> Result<Tensor, TchError>

pub fn f_empty_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_empty_quantized(
    size: &[i64],
    qtensor: &Tensor
) -> Result<Tensor, TchError>

pub fn f_empty_strided(
    size: &[i64],
    stride: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_eq<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_eq_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_eq_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_eq_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_eq_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_eq_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_equal(&self, other: &Tensor) -> Result<bool, TchError>

pub fn f_erf(&self) -> Result<Tensor, TchError>

pub fn f_erf_(&mut self) -> Result<Tensor, TchError>

pub fn f_erf_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_erfc(&self) -> Result<Tensor, TchError>

pub fn f_erfc_(&mut self) -> Result<Tensor, TchError>

pub fn f_erfc_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_erfinv(&self) -> Result<Tensor, TchError>

pub fn f_erfinv_(&mut self) -> Result<Tensor, TchError>

pub fn f_erfinv_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_exp(&self) -> Result<Tensor, TchError>

pub fn f_exp2(&self) -> Result<Tensor, TchError>

pub fn f_exp2_(&mut self) -> Result<Tensor, TchError>

pub fn f_exp2_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_exp_(&mut self) -> Result<Tensor, TchError>

pub fn f_exp_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_expand(&self, size: &[i64], implicit: bool) -> Result<Tensor, TchError>

pub fn f_expand_as(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_expm1(&self) -> Result<Tensor, TchError>

pub fn f_expm1_(&mut self) -> Result<Tensor, TchError>

pub fn f_expm1_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_exponential_(&mut self, lambd: f64) -> Result<Tensor, TchError>

pub fn f_eye(n: i64, options: (Kind, Device)) -> Result<Tensor, TchError>

pub fn f_eye_m(
    n: i64,
    m: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_eye_m_out(out: &Tensor, n: i64, m: i64) -> Result<Tensor, TchError>

pub fn f_eye_out(out: &Tensor, n: i64) -> Result<Tensor, TchError>

pub fn f_fake_quantize_per_channel_affine(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64
) -> Result<Tensor, TchError>

pub fn f_fake_quantize_per_channel_affine_cachemask(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_fake_quantize_per_channel_affine_cachemask_backward(
    grad: &Tensor,
    mask: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fake_quantize_per_tensor_affine(
    &self,
    scale: f64,
    zero_point: i64,
    quant_min: i64,
    quant_max: i64
) -> Result<Tensor, TchError>

pub fn f_fake_quantize_per_tensor_affine_cachemask(
    &self,
    scale: f64,
    zero_point: i64,
    quant_min: i64,
    quant_max: i64
) -> Result<(Tensor, Tensor), TchError>

pub fn f_fake_quantize_per_tensor_affine_cachemask_backward(
    grad: &Tensor,
    mask: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fbgemm_linear_fp16_weight(
    &self,
    packed_weight: &Tensor,
    bias: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fbgemm_linear_fp16_weight_fp32_activation(
    &self,
    packed_weight: &Tensor,
    bias: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fbgemm_linear_int8_weight<S: Into<Scalar>>(
    &self,
    weight: &Tensor,
    packed: &Tensor,
    col_offsets: &Tensor,
    weight_scale: S,
    weight_zero_point: S,
    bias: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fbgemm_linear_int8_weight_fp32_activation<S: Into<Scalar>>(
    &self,
    weight: &Tensor,
    packed: &Tensor,
    col_offsets: &Tensor,
    weight_scale: S,
    weight_zero_point: S,
    bias: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fbgemm_pack_gemm_matrix_fp16(&self) -> Result<Tensor, TchError>

pub fn f_fbgemm_pack_quantized_matrix(&self) -> Result<Tensor, TchError>

pub fn f_fbgemm_pack_quantized_matrix_kn(
    &self,
    k: i64,
    n: i64
) -> Result<Tensor, TchError>

pub fn f_feature_alpha_dropout(
    &self,
    p: f64,
    train: bool
) -> Result<Tensor, TchError>

pub fn f_feature_alpha_dropout_(
    &mut self,
    p: f64,
    train: bool
) -> Result<Tensor, TchError>

pub fn f_feature_dropout(&self, p: f64, train: bool) -> Result<Tensor, TchError>

pub fn f_feature_dropout_(
    &mut self,
    p: f64,
    train: bool
) -> Result<Tensor, TchError>

pub fn f_fft_fft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_fft2<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_fft2_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_fft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_fftfreq(
    n: i64,
    d: f64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_fft_fftfreq_out(
    out: &Tensor,
    n: i64,
    d: f64
) -> Result<Tensor, TchError>

pub fn f_fft_fftn<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_fftn_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_fftshift<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>

pub fn f_fft_hfft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_hfft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_ifft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_ifft2<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_ifft2_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_ifft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_ifftn<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_ifftn_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_ifftshift<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>

pub fn f_fft_ihfft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_ihfft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_irfft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_irfft2<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_irfft2_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_irfft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_irfftn<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_irfftn_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_rfft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_rfft2<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_rfft2_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_rfft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_rfftfreq(
    n: i64,
    d: f64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_fft_rfftfreq_out(
    out: &Tensor,
    n: i64,
    d: f64
) -> Result<Tensor, TchError>

pub fn f_fft_rfftn<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fft_rfftn_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Result<Tensor, TchError>

pub fn f_fill_<S: Into<Scalar>>(&mut self, value: S) -> Result<Tensor, TchError>

pub fn f_fill_diagonal_<S: Into<Scalar>>(
    &mut self,
    fill_value: S,
    wrap: bool
) -> Result<Tensor, TchError>

pub fn f_fill_tensor_(&mut self, value: &Tensor) -> Result<Tensor, TchError>

pub fn f_fix(&self) -> Result<Tensor, TchError>

pub fn f_fix_(&mut self) -> Result<Tensor, TchError>

pub fn f_fix_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_flatten(
    &self,
    start_dim: i64,
    end_dim: i64
) -> Result<Tensor, TchError>

pub fn f_flatten_dense_tensors<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_flip(&self, dims: &[i64]) -> Result<Tensor, TchError>

pub fn f_fliplr(&self) -> Result<Tensor, TchError>

pub fn f_flipud(&self) -> Result<Tensor, TchError>

pub fn f_float_power(&self, exponent: &Tensor) -> Result<Tensor, TchError>

pub fn f_float_power_<S: Into<Scalar>>(
    &mut self,
    exponent: S
) -> Result<Tensor, TchError>

pub fn f_float_power_scalar<S: Into<Scalar>>(
    self_scalar: S,
    exponent: &Tensor
) -> Result<Tensor, TchError>

pub fn f_float_power_scalar_out<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    exponent: &Tensor
) -> Result<Tensor, TchError>

pub fn f_float_power_tensor_(
    &mut self,
    exponent: &Tensor
) -> Result<Tensor, TchError>

pub fn f_float_power_tensor_scalar<S: Into<Scalar>>(
    &self,
    exponent: S
) -> Result<Tensor, TchError>

pub fn f_float_power_tensor_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    exponent: S
) -> Result<Tensor, TchError>

pub fn f_float_power_tensor_tensor_out(
    &self,
    out: &Tensor,
    exponent: &Tensor
) -> Result<Tensor, TchError>

pub fn f_floor(&self) -> Result<Tensor, TchError>

pub fn f_floor_(&mut self) -> Result<Tensor, TchError>

pub fn f_floor_divide(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_floor_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_floor_divide_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_floor_divide_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_floor_divide_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_floor_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_fmax(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_fmax_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fmin(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_fmin_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fmod<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_fmod_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_fmod_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_fmod_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_fmod_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_fmod_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_frac(&self) -> Result<Tensor, TchError>

pub fn f_frac_(&mut self) -> Result<Tensor, TchError>

pub fn f_frac_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_fractional_max_pool2d(
    &self,
    kernel_size: &[i64],
    output_size: &[i64],
    random_samples: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_fractional_max_pool2d_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fractional_max_pool2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fractional_max_pool2d_output(
    &self,
    output: &Tensor,
    indices: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    random_samples: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_fractional_max_pool3d(
    &self,
    kernel_size: &[i64],
    output_size: &[i64],
    random_samples: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_fractional_max_pool3d_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fractional_max_pool3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fractional_max_pool3d_output(
    &self,
    output: &Tensor,
    indices: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    random_samples: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_frexp(&self) -> Result<(Tensor, Tensor), TchError>

pub fn f_frexp_tensor_out(
    &self,
    mantissa: &Tensor,
    exponent: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_frobenius_norm(&self) -> Result<Tensor, TchError>

pub fn f_frobenius_norm_dim(
    &self,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_frobenius_norm_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_from_file(
    filename: &str,
    shared: bool,
    size: impl Into<Option<i64>>,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_full<S: Into<Scalar>>(
    size: &[i64],
    fill_value: S,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_full_like<S: Into<Scalar>>(
    &self,
    fill_value: S
) -> Result<Tensor, TchError>

pub fn f_full_out<S: Into<Scalar>>(
    out: &Tensor,
    size: &[i64],
    fill_value: S
) -> Result<Tensor, TchError>

pub fn f_gather(
    &self,
    dim: i64,
    index: &Tensor,
    sparse_grad: bool
) -> Result<Tensor, TchError>

pub fn f_gather_backward(
    &self,
    grad: &Tensor,
    dim: i64,
    index: &Tensor,
    sparse_grad: bool
) -> Result<Tensor, TchError>

pub fn f_gather_out(
    &self,
    out: &Tensor,
    dim: i64,
    index: &Tensor,
    sparse_grad: bool
) -> Result<Tensor, TchError>

pub fn f_gcd(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_gcd_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_gcd_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_ge<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_ge_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_ge_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_ge_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ge_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ge_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_gelu(&self) -> Result<Tensor, TchError>

pub fn f_gelu_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>

pub fn f_geometric_(&mut self, p: f64) -> Result<Tensor, TchError>

pub fn f_geqrf(&self) -> Result<(Tensor, Tensor), TchError>

pub fn f_geqrf_a(
    &self,
    a: &Tensor,
    tau: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_ger(&self, vec2: &Tensor) -> Result<Tensor, TchError>

pub fn f_ger_out(&self, out: &Tensor, vec2: &Tensor) -> Result<Tensor, TchError>

pub fn f_glu(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_glu_backward(
    &self,
    grad_output: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_glu_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_glu_out(&self, out: &Tensor, dim: i64) -> Result<Tensor, TchError>

pub fn f_grad(&self) -> Result<Tensor, TchError>

pub fn f_greater<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_greater_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_greater_equal<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_greater_equal_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_greater_equal_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_greater_equal_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_greater_equal_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_greater_equal_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_greater_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_greater_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_greater_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_greater_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_grid_sampler(
    &self,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Result<Tensor, TchError>

pub fn f_grid_sampler_2d(
    &self,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Result<Tensor, TchError>

pub fn f_grid_sampler_2d_backward(
    &self,
    grad_output: &Tensor,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_grid_sampler_3d(
    &self,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Result<Tensor, TchError>

pub fn f_grid_sampler_3d_backward(
    &self,
    grad_output: &Tensor,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_group_norm<T: Borrow<Tensor>>(
    &self,
    num_groups: i64,
    weight: Option<T>,
    bias: Option<T>,
    eps: f64,
    cudnn_enabled: bool
) -> Result<Tensor, TchError>

pub fn f_gru<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_first: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_gru_cell<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: Option<T>,
    b_hh: Option<T>
) -> Result<Tensor, TchError>

pub fn f_gru_data<T: Borrow<Tensor>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_gt<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_gt_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_gt_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_gt_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_gt_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_gt_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_hamming_window(
    window_length: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_hamming_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_hamming_window_periodic_alpha(
    window_length: i64,
    periodic: bool,
    alpha: f64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_hamming_window_periodic_alpha_beta(
    window_length: i64,
    periodic: bool,
    alpha: f64,
    beta: f64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_hann_window(
    window_length: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_hann_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_hardshrink(&self) -> Result<Tensor, TchError>

pub fn f_hardshrink_backward<S: Into<Scalar>>(
    &self,
    grad_out: &Tensor,
    lambd: S
) -> Result<Tensor, TchError>

pub fn f_hardsigmoid(&self) -> Result<Tensor, TchError>

pub fn f_hardsigmoid_(&mut self) -> Result<Tensor, TchError>

pub fn f_hardsigmoid_backward(
    &self,
    grad_output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_hardsigmoid_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_hardswish(&self) -> Result<Tensor, TchError>

pub fn f_hardswish_(&mut self) -> Result<Tensor, TchError>

pub fn f_hardswish_backward(
    &self,
    grad_output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_hardswish_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_hardtanh(&self) -> Result<Tensor, TchError>

pub fn f_hardtanh_(&mut self) -> Result<Tensor, TchError>

pub fn f_hardtanh_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    min_val: S,
    max_val: S
) -> Result<Tensor, TchError>

pub fn f_hardtanh_backward_grad_input<S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    min_val: S,
    max_val: S
) -> Result<Tensor, TchError>

pub fn f_hardtanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_heaviside(&self, values: &Tensor) -> Result<Tensor, TchError>

pub fn f_heaviside_(&mut self, values: &Tensor) -> Result<Tensor, TchError>

pub fn f_heaviside_out(
    &self,
    out: &Tensor,
    values: &Tensor
) -> Result<Tensor, TchError>

pub fn f_hinge_embedding_loss(
    &self,
    target: &Tensor,
    margin: f64,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_histc(&self, bins: i64) -> Result<Tensor, TchError>

pub fn f_histc_out(&self, out: &Tensor, bins: i64) -> Result<Tensor, TchError>

pub fn f_hsplit(&self, sections: i64) -> Result<Vec<Tensor>, TchError>

pub fn f_hsplit_array(&self, indices: &[i64]) -> Result<Vec<Tensor>, TchError>

pub fn f_hspmm(mat1: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_hspmm_out(
    out: &Tensor,
    mat1: &Tensor,
    mat2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_hstack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>

pub fn f_hstack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_huber_loss(
    &self,
    target: &Tensor,
    reduction: Reduction,
    delta: f64
) -> Result<Tensor, TchError>

pub fn f_huber_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    delta: f64
) -> Result<Tensor, TchError>

pub fn f_huber_loss_backward_out(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    delta: f64
) -> Result<Tensor, TchError>

pub fn f_huber_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    delta: f64
) -> Result<Tensor, TchError>

pub fn f_hypot(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_hypot_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_hypot_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_i0(&self) -> Result<Tensor, TchError>

pub fn f_i0_(&mut self) -> Result<Tensor, TchError>

pub fn f_i0_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_igamma(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_igamma_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_igamma_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_igammac(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_igammac_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_igammac_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_im2col(
    &self,
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Result<Tensor, TchError>

pub fn f_im2col_backward(
    grad_output: &Tensor,
    input_size: &[i64],
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Result<Tensor, TchError>

pub fn f_im2col_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    input_size: &[i64],
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Result<Tensor, TchError>

pub fn f_im2col_out(
    &self,
    out: &Tensor,
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Result<Tensor, TchError>

pub fn f_imag(&self) -> Result<Tensor, TchError>

pub fn f_index<T: Borrow<Tensor>>(
    &self,
    indices: &[Option<T>]
) -> Result<Tensor, TchError>

pub fn f_index_add(
    &self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>

pub fn f_index_add_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>

pub fn f_index_add_alpha<S: Into<Scalar>>(
    &self,
    dim: i64,
    index: &Tensor,
    source: &Tensor,
    alpha: S
) -> Result<Tensor, TchError>

pub fn f_index_add_alpha_<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor,
    alpha: S
) -> Result<Tensor, TchError>

pub fn f_index_copy(
    &self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>

pub fn f_index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>

pub fn f_index_fill<S: Into<Scalar>>(
    &self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Result<Tensor, TchError>

pub fn f_index_fill_<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Result<Tensor, TchError>

pub fn f_index_fill_int_tensor(
    &self,
    dim: i64,
    index: &Tensor,
    value: &Tensor
) -> Result<Tensor, TchError>

pub fn f_index_fill_int_tensor_(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: &Tensor
) -> Result<Tensor, TchError>

pub fn f_index_put<T: Borrow<Tensor>>(
    &self,
    indices: &[Option<T>],
    values: &Tensor,
    accumulate: bool
) -> Result<Tensor, TchError>

pub fn f_index_put_<T: Borrow<Tensor>>(
    &mut self,
    indices: &[Option<T>],
    values: &Tensor,
    accumulate: bool
) -> Result<Tensor, TchError>

pub fn f_index_select(
    &self,
    dim: i64,
    index: &Tensor
) -> Result<Tensor, TchError>

pub fn f_index_select_backward(
    grad: &Tensor,
    self_sizes: &[i64],
    dim: i64,
    index: &Tensor
) -> Result<Tensor, TchError>

pub fn f_index_select_out(
    &self,
    out: &Tensor,
    dim: i64,
    index: &Tensor
) -> Result<Tensor, TchError>

pub fn f_indices(&self) -> Result<Tensor, TchError>

pub fn f_infinitely_differentiable_gelu_backward(
    &self,
    grad: &Tensor
) -> Result<Tensor, TchError>

pub fn f_inner(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_inner_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_instance_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    use_input_stats: bool,
    momentum: f64,
    eps: f64,
    cudnn_enabled: bool
) -> Result<Tensor, TchError>

pub fn f_int_repr(&self) -> Result<Tensor, TchError>

pub fn f_inverse(&self) -> Result<Tensor, TchError>

pub fn f_inverse_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_is_coalesced(&self) -> Result<bool, TchError>

pub fn f_is_complex(&self) -> Result<bool, TchError>

pub fn f_is_distributed(&self) -> Result<bool, TchError>

pub fn f_is_floating_point(&self) -> Result<bool, TchError>

pub fn f_is_leaf(&self) -> Result<bool, TchError>

pub fn f_is_nonzero(&self) -> Result<bool, TchError>

pub fn f_is_pinned(&self) -> Result<bool, TchError>

pub fn f_is_same_size(&self, other: &Tensor) -> Result<bool, TchError>

pub fn f_is_set_to(&self, tensor: &Tensor) -> Result<bool, TchError>

pub fn f_is_signed(&self) -> Result<bool, TchError>

pub fn f_is_vulkan_available() -> Result<bool, TchError>

pub fn f_isclose(
    &self,
    other: &Tensor,
    rtol: f64,
    atol: f64,
    equal_nan: bool
) -> Result<Tensor, TchError>

pub fn f_isfinite(&self) -> Result<Tensor, TchError>

pub fn f_isinf(&self) -> Result<Tensor, TchError>

pub fn f_isnan(&self) -> Result<Tensor, TchError>

pub fn f_isneginf(&self) -> Result<Tensor, TchError>

pub fn f_isneginf_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_isposinf(&self) -> Result<Tensor, TchError>

pub fn f_isposinf_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_isreal(&self) -> Result<Tensor, TchError>

pub fn f_istft<T: Borrow<Tensor>>(
    &self,
    n_fft: i64,
    hop_length: impl Into<Option<i64>>,
    win_length: impl Into<Option<i64>>,
    window: Option<T>,
    center: bool,
    normalized: bool,
    onesided: bool,
    length: impl Into<Option<i64>>,
    return_complex: bool
) -> Result<Tensor, TchError>

pub fn f_kaiser_window(
    window_length: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_kaiser_window_beta(
    window_length: i64,
    periodic: bool,
    beta: f64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_kaiser_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_kl_div(
    &self,
    target: &Tensor,
    reduction: Reduction,
    log_target: bool
) -> Result<Tensor, TchError>

pub fn f_kl_div_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    log_target: bool
) -> Result<Tensor, TchError>

pub fn f_kron(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_kron_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_kthvalue(
    &self,
    k: i64,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_kthvalue_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    k: i64,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_l1_loss(
    &self,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_l1_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_l1_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_l1_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_layer_norm<T: Borrow<Tensor>>(
    &self,
    normalized_shape: &[i64],
    weight: Option<T>,
    bias: Option<T>,
    eps: f64,
    cudnn_enable: bool
) -> Result<Tensor, TchError>

pub fn f_lcm(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_lcm_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_lcm_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_ldexp(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ldexp_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ldexp_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_le<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_le_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_le_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_le_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_le_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_le_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_leaky_relu(&self) -> Result<Tensor, TchError>

pub fn f_leaky_relu_(&mut self) -> Result<Tensor, TchError>

pub fn f_leaky_relu_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    negative_slope: S,
    self_is_result: bool
) -> Result<Tensor, TchError>

pub fn f_leaky_relu_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_lerp<S: Into<Scalar>>(
    &self,
    end: &Tensor,
    weight: S
) -> Result<Tensor, TchError>

pub fn f_lerp_<S: Into<Scalar>>(
    &mut self,
    end: &Tensor,
    weight: S
) -> Result<Tensor, TchError>

pub fn f_lerp_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    end: &Tensor,
    weight: S
) -> Result<Tensor, TchError>

pub fn f_lerp_tensor(
    &self,
    end: &Tensor,
    weight: &Tensor
) -> Result<Tensor, TchError>

pub fn f_lerp_tensor_(
    &mut self,
    end: &Tensor,
    weight: &Tensor
) -> Result<Tensor, TchError>

pub fn f_lerp_tensor_out(
    &self,
    out: &Tensor,
    end: &Tensor,
    weight: &Tensor
) -> Result<Tensor, TchError>

pub fn f_less<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_less_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_less_equal<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_less_equal_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_less_equal_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_less_equal_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_less_equal_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_less_equal_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_less_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_less_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_less_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_less_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_lgamma(&self) -> Result<Tensor, TchError>

pub fn f_lgamma_(&mut self) -> Result<Tensor, TchError>

pub fn f_lgamma_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_cholesky(&self) -> Result<Tensor, TchError>

pub fn f_linalg_cholesky_ex(
    &self,
    check_errors: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_cholesky_ex_l(
    &self,
    l: &Tensor,
    info: &Tensor,
    check_errors: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_cholesky_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_cond<S: Into<Scalar>>(&self, p: S) -> Result<Tensor, TchError>

pub fn f_linalg_cond_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    p: S
) -> Result<Tensor, TchError>

pub fn f_linalg_cond_p_str(&self, p: &str) -> Result<Tensor, TchError>

pub fn f_linalg_cond_p_str_out(
    &self,
    out: &Tensor,
    p: &str
) -> Result<Tensor, TchError>

pub fn f_linalg_det(&self) -> Result<Tensor, TchError>

pub fn f_linalg_det_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_eig(&self) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_eig_out(
    &self,
    eigenvalues: &Tensor,
    eigenvectors: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_eigh(&self, uplo: &str) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_eigh_eigvals(
    &self,
    eigvals: &Tensor,
    eigvecs: &Tensor,
    uplo: &str
) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_eigvals(&self) -> Result<Tensor, TchError>

pub fn f_linalg_eigvals_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_eigvalsh(&self, uplo: &str) -> Result<Tensor, TchError>

pub fn f_linalg_eigvalsh_out(
    &self,
    out: &Tensor,
    uplo: &str
) -> Result<Tensor, TchError>

pub fn f_linalg_householder_product(
    &self,
    tau: &Tensor
) -> Result<Tensor, TchError>

pub fn f_linalg_householder_product_out(
    &self,
    out: &Tensor,
    tau: &Tensor
) -> Result<Tensor, TchError>

pub fn f_linalg_inv(&self) -> Result<Tensor, TchError>

pub fn f_linalg_inv_ex(
    &self,
    check_errors: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_inv_ex_inverse(
    &self,
    inverse: &Tensor,
    info: &Tensor,
    check_errors: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_inv_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_lstsq(
    &self,
    b: &Tensor,
    rcond: impl Into<Option<f64>>,
    driver: &str
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_lstsq_out(
    &self,
    solution: &Tensor,
    residuals: &Tensor,
    rank: &Tensor,
    singular_values: &Tensor,
    b: &Tensor,
    rcond: impl Into<Option<f64>>,
    driver: &str
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_matrix_norm<S: Into<Scalar>>(
    &self,
    ord: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_norm_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    ord: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_norm_str_ord(
    &self,
    ord: &str,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_norm_str_ord_out(
    &self,
    out: &Tensor,
    ord: &str,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_power(&self, n: i64) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_power_out(
    &self,
    out: &Tensor,
    n: i64
) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank(
    &self,
    tol: impl Into<Option<f64>>,
    hermitian: bool
) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_out(
    &self,
    out: &Tensor,
    tol: impl Into<Option<f64>>,
    hermitian: bool
) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_out_tol_tensor(
    &self,
    out: &Tensor,
    tol: &Tensor,
    hermitian: bool
) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_tol_tensor(
    &self,
    tol: &Tensor,
    hermitian: bool
) -> Result<Tensor, TchError>

pub fn f_linalg_multi_dot<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_linalg_multi_dot_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_linalg_norm<'a, S: Into<Scalar>>(
    &self,
    ord: S,
    dim: impl Into<Option<&'a [i64]>>,
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_linalg_norm_ord_str<'a>(
    &self,
    ord: &str,
    dim: impl Into<Option<&'a [i64]>>,
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_linalg_norm_ord_str_out<'a>(
    &self,
    out: &Tensor,
    ord: &str,
    dim: impl Into<Option<&'a [i64]>>,
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_linalg_norm_out<'a, S: Into<Scalar>>(
    &self,
    out: &Tensor,
    ord: S,
    dim: impl Into<Option<&'a [i64]>>,
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_linalg_pinv(
    &self,
    rcond: f64,
    hermitian: bool
) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_out(
    &self,
    out: &Tensor,
    rcond: f64,
    hermitian: bool
) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_out_rcond_tensor(
    &self,
    out: &Tensor,
    rcond: &Tensor,
    hermitian: bool
) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_rcond_tensor(
    &self,
    rcond: &Tensor,
    hermitian: bool
) -> Result<Tensor, TchError>

pub fn f_linalg_qr(&self, mode: &str) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_qr_out(
    &self,
    q: &Tensor,
    r: &Tensor,
    mode: &str
) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_slogdet(&self) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_slogdet_out(
    &self,
    sign: &Tensor,
    logabsdet: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_solve(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_solve_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_linalg_svd(
    &self,
    full_matrices: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_svd_u(
    &self,
    u: &Tensor,
    s: &Tensor,
    vh: &Tensor,
    full_matrices: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_svdvals(&self) -> Result<Tensor, TchError>

pub fn f_linalg_svdvals_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_tensorinv(&self, ind: i64) -> Result<Tensor, TchError>

pub fn f_linalg_tensorinv_out(
    &self,
    out: &Tensor,
    ind: i64
) -> Result<Tensor, TchError>

pub fn f_linalg_tensorsolve<'a>(
    &self,
    other: &Tensor,
    dims: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>

pub fn f_linalg_tensorsolve_out<'a>(
    &self,
    out: &Tensor,
    other: &Tensor,
    dims: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>

pub fn f_linear<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>
) -> Result<Tensor, TchError>

pub fn f_linspace<S: Into<Scalar>>(
    start: S,
    end: S,
    steps: impl Into<Option<i64>>,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_linspace_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S,
    steps: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_log(&self) -> Result<Tensor, TchError>

pub fn f_log10(&self) -> Result<Tensor, TchError>

pub fn f_log10_(&mut self) -> Result<Tensor, TchError>

pub fn f_log10_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_log1p(&self) -> Result<Tensor, TchError>

pub fn f_log1p_(&mut self) -> Result<Tensor, TchError>

pub fn f_log1p_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_log2(&self) -> Result<Tensor, TchError>

pub fn f_log2_(&mut self) -> Result<Tensor, TchError>

pub fn f_log2_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_log_(&mut self) -> Result<Tensor, TchError>

pub fn f_log_normal_(&mut self, mean: f64, std: f64) -> Result<Tensor, TchError>

pub fn f_log_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_log_sigmoid(&self) -> Result<Tensor, TchError>

pub fn f_log_sigmoid_backward(
    &self,
    grad_output: &Tensor,
    buffer: &Tensor
) -> Result<Tensor, TchError>

pub fn f_log_sigmoid_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    buffer: &Tensor
) -> Result<Tensor, TchError>

pub fn f_log_sigmoid_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_log_softmax(&self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_logaddexp(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logaddexp2(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logaddexp2_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_logaddexp_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_logcumsumexp(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_logcumsumexp_out(
    &self,
    out: &Tensor,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_logdet(&self) -> Result<Tensor, TchError>

pub fn f_logical_and(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_and_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_and_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_logical_not(&self) -> Result<Tensor, TchError>

pub fn f_logical_not_(&mut self) -> Result<Tensor, TchError>

pub fn f_logical_not_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_or(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_or_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_or_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_logical_xor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_xor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_xor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_logit(&self, eps: impl Into<Option<f64>>) -> Result<Tensor, TchError>

pub fn f_logit_(
    &mut self,
    eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_logit_backward(
    &self,
    grad_output: &Tensor,
    eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_logit_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_logit_out(
    &self,
    out: &Tensor,
    eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_logspace<S: Into<Scalar>>(
    start: S,
    end: S,
    steps: impl Into<Option<i64>>,
    base: f64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_logspace_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S,
    steps: impl Into<Option<i64>>,
    base: f64
) -> Result<Tensor, TchError>

pub fn f_logsumexp(
    &self,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_logsumexp_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_lstm<T: Borrow<Tensor>>(
    &self,
    hx: &[T],
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_first: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_lstm_cell<T: Borrow<Tensor>>(
    &self,
    hx: &[T],
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: Option<T>,
    b_hh: Option<T>
) -> Result<(Tensor, Tensor), TchError>

pub fn f_lstm_data<T: Borrow<Tensor>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    hx: &[T],
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_lstsq(&self, a: &Tensor) -> Result<(Tensor, Tensor), TchError>

pub fn f_lstsq_x(
    &self,
    x: &Tensor,
    qr: &Tensor,
    a: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_lt<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_lt_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_lt_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_lt_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_lt_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_lt_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_lu_solve(
    &self,
    lu_data: &Tensor,
    lu_pivots: &Tensor
) -> Result<Tensor, TchError>

pub fn f_lu_solve_out(
    &self,
    out: &Tensor,
    lu_data: &Tensor,
    lu_pivots: &Tensor
) -> Result<Tensor, TchError>

pub fn f_lu_unpack(
    lu_data: &Tensor,
    lu_pivots: &Tensor,
    unpack_data: bool,
    unpack_pivots: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_lu_unpack_out(
    p: &Tensor,
    l: &Tensor,
    u: &Tensor,
    lu_data: &Tensor,
    lu_pivots: &Tensor,
    unpack_data: bool,
    unpack_pivots: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_margin_ranking_loss(
    input1: &Tensor,
    input2: &Tensor,
    target: &Tensor,
    margin: f64,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_masked_fill<S: Into<Scalar>>(
    &self,
    mask: &Tensor,
    value: S
) -> Result<Tensor, TchError>

pub fn f_masked_fill_<S: Into<Scalar>>(
    &mut self,
    mask: &Tensor,
    value: S
) -> Result<Tensor, TchError>

pub fn f_masked_fill_tensor(
    &self,
    mask: &Tensor,
    value: &Tensor
) -> Result<Tensor, TchError>

pub fn f_masked_fill_tensor_(
    &mut self,
    mask: &Tensor,
    value: &Tensor
) -> Result<Tensor, TchError>

pub fn f_masked_scatter(
    &self,
    mask: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>

pub fn f_masked_scatter_(
    &mut self,
    mask: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>

pub fn f_masked_select(&self, mask: &Tensor) -> Result<Tensor, TchError>

pub fn f_masked_select_backward(
    &self,
    grad: &Tensor,
    mask: &Tensor
) -> Result<Tensor, TchError>

pub fn f_masked_select_out(
    &self,
    out: &Tensor,
    mask: &Tensor
) -> Result<Tensor, TchError>

pub fn f_matmul(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_matmul_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_matrix_exp(&self) -> Result<Tensor, TchError>

pub fn f_matrix_exp_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>

pub fn f_matrix_power(&self, n: i64) -> Result<Tensor, TchError>

pub fn f_matrix_power_out(
    &self,
    out: &Tensor,
    n: i64
) -> Result<Tensor, TchError>

pub fn f_matrix_rank(&self, symmetric: bool) -> Result<Tensor, TchError>

pub fn f_matrix_rank_tol(
    &self,
    tol: f64,
    symmetric: bool
) -> Result<Tensor, TchError>

pub fn f_max(&self) -> Result<Tensor, TchError>

pub fn f_max_dim(
    &self,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_dim_max(
    &self,
    max: &Tensor,
    max_values: &Tensor,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_other(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_max_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_max_pool1d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<Tensor, TchError>

pub fn f_max_pool1d_with_indices(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_pool2d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<Tensor, TchError>

pub fn f_max_pool2d_with_indices(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_pool2d_with_indices_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool,
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_max_pool2d_with_indices_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool,
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_max_pool2d_with_indices_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_pool3d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<Tensor, TchError>

pub fn f_max_pool3d_with_indices(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_pool3d_with_indices_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool,
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_max_pool3d_with_indices_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool,
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_max_pool3d_with_indices_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_unpool2d(
    &self,
    indices: &Tensor,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_max_unpool2d_backward(
    &self,
    grad_output: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_max_unpool2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_max_unpool2d_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_max_unpool3d(
    &self,
    indices: &Tensor,
    output_size: &[i64],
    stride: &[i64],
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_max_unpool3d_backward(
    &self,
    grad_output: &Tensor,
    indices: &Tensor,
    output_size: &[i64],
    stride: &[i64],
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_max_unpool3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    indices: &Tensor,
    output_size: &[i64],
    stride: &[i64],
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_max_unpool3d_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    output_size: &[i64],
    stride: &[i64],
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_maximum(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_maximum_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_mean(&self, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_mean_dim(
    &self,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_mean_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_median(&self) -> Result<Tensor, TchError>

pub fn f_median_dim(
    &self,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_median_dim_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_meshgrid<T: Borrow<Tensor>>(
    tensors: &[T]
) -> Result<Vec<Tensor>, TchError>

pub fn f_min(&self) -> Result<Tensor, TchError>

pub fn f_min_dim(
    &self,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_min_dim_min(
    &self,
    min: &Tensor,
    min_indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_min_other(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_min_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_minimum(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_minimum_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_miopen_batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    exponential_average_factor: f64,
    epsilon: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_miopen_batch_norm_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    weight: &Tensor,
    running_mean: Option<T>,
    running_var: Option<T>,
    save_mean: Option<T>,
    save_var: Option<T>,
    epsilon: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_miopen_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_backward_bias(
    grad_output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_backward_input(
    self_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_transpose<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    output_padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_transpose_backward_input(
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_transpose_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_miopen_depthwise_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_miopen_depthwise_convolution_backward_input(
    self_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_miopen_depthwise_convolution_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Result<Tensor, TchError>

pub fn f_miopen_rnn<T: Borrow<Tensor>>(
    &self,
    weight: &[T],
    weight_stride0: i64,
    hx: &Tensor,
    cx: Option<T>,
    mode: i64,
    hidden_size: i64,
    num_layers: i64,
    batch_first: bool,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_sizes: &[i64],
    dropout_state: Option<T>
) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_mish(&self) -> Result<Tensor, TchError>

pub fn f_mish_(&mut self) -> Result<Tensor, TchError>

pub fn f_mish_backward(&self, grad_output: &Tensor) -> Result<Tensor, TchError>

pub fn f_mish_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_mkldnn_adaptive_avg_pool2d(
    &self,
    output_size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_mkldnn_adaptive_avg_pool2d_backward(
    &self,
    grad_output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_mkldnn_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_mkldnn_convolution_backward_input(
    self_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    bias_defined: bool
) -> Result<Tensor, TchError>

pub fn f_mkldnn_convolution_backward_weights(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    bias_defined: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_mkldnn_linear<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>
) -> Result<Tensor, TchError>

pub fn f_mkldnn_linear_backward_input(
    input_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor
) -> Result<Tensor, TchError>

pub fn f_mkldnn_linear_backward_weights(
    &self,
    grad_output: &Tensor,
    weight: &Tensor,
    bias_defined: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_mkldnn_max_pool2d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool2d_backward(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool3d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool3d_backward(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<Tensor, TchError>

pub fn f_mkldnn_reorder_conv2d_weight(
    &self,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_mkldnn_reorder_conv3d_weight(
    &self,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64
) -> Result<Tensor, TchError>

pub fn f_mm(&self, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_mm_out(&self, out: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_mode(
    &self,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_mode_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_moveaxis(
    &self,
    source: &[i64],
    destination: &[i64]
) -> Result<Tensor, TchError>

pub fn f_moveaxis_int(
    &self,
    source: i64,
    destination: i64
) -> Result<Tensor, TchError>

pub fn f_movedim(
    &self,
    source: &[i64],
    destination: &[i64]
) -> Result<Tensor, TchError>

pub fn f_movedim_int(
    &self,
    source: i64,
    destination: i64
) -> Result<Tensor, TchError>

pub fn f_mse_loss(
    &self,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_mse_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_mse_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_mse_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_msort(&self) -> Result<Tensor, TchError>

pub fn f_msort_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_mul(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_mul_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_mul_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_mul_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_mul_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_multi_margin_loss_backward<T: Borrow<Tensor>, S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    p: S,
    margin: S,
    weight: Option<T>,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_multi_margin_loss_backward_grad_input<T: Borrow<Tensor>, S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    p: S,
    margin: S,
    weight: Option<T>,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_multilabel_margin_loss(
    &self,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_multilabel_margin_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    is_target: &Tensor
) -> Result<Tensor, TchError>

pub fn f_multilabel_margin_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    is_target: &Tensor
) -> Result<Tensor, TchError>

pub fn f_multilabel_margin_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_multinomial(
    &self,
    num_samples: i64,
    replacement: bool
) -> Result<Tensor, TchError>

pub fn f_multinomial_out(
    &self,
    out: &Tensor,
    num_samples: i64,
    replacement: bool
) -> Result<Tensor, TchError>

pub fn f_multiply(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_multiply_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_multiply_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_multiply_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_multiply_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_mv(&self, vec: &Tensor) -> Result<Tensor, TchError>

pub fn f_mv_out(&self, out: &Tensor, vec: &Tensor) -> Result<Tensor, TchError>

pub fn f_mvlgamma(&self, p: i64) -> Result<Tensor, TchError>

pub fn f_mvlgamma_(&mut self, p: i64) -> Result<Tensor, TchError>

pub fn f_nan_to_num(
    &self,
    nan: impl Into<Option<f64>>,
    posinf: impl Into<Option<f64>>,
    neginf: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_nan_to_num_(
    &mut self,
    nan: impl Into<Option<f64>>,
    posinf: impl Into<Option<f64>>,
    neginf: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_nan_to_num_out(
    &self,
    out: &Tensor,
    nan: impl Into<Option<f64>>,
    posinf: impl Into<Option<f64>>,
    neginf: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_nanmedian(&self) -> Result<Tensor, TchError>

pub fn f_nanmedian_dim(
    &self,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_nanmedian_dim_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_nanquantile(
    &self,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_nanquantile_new(
    &self,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Result<Tensor, TchError>

pub fn f_nanquantile_new_out(
    &self,
    out: &Tensor,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Result<Tensor, TchError>

pub fn f_nanquantile_new_scalar(
    &self,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Result<Tensor, TchError>

pub fn f_nanquantile_new_scalar_out(
    &self,
    out: &Tensor,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Result<Tensor, TchError>

pub fn f_nanquantile_out(
    &self,
    out: &Tensor,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_nanquantile_scalar(
    &self,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_nanquantile_scalar_out(
    &self,
    out: &Tensor,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_nansum(&self, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_nansum_dim_intlist(
    &self,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_nansum_intlist_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_narrow(
    &self,
    dim: i64,
    start: i64,
    length: i64
) -> Result<Tensor, TchError>

pub fn f_narrow_copy(
    &self,
    dim: i64,
    start: i64,
    length: i64
) -> Result<Tensor, TchError>

pub fn f_narrow_copy_out(
    &self,
    out: &Tensor,
    dim: i64,
    start: i64,
    length: i64
) -> Result<Tensor, TchError>

pub fn f_narrow_tensor(
    &self,
    dim: i64,
    start: &Tensor,
    length: i64
) -> Result<Tensor, TchError>

pub fn f_native_batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    momentum: f64,
    eps: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_native_batch_norm_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    save_mean: &Tensor,
    save_invstd: &Tensor,
    weight: Option<T>,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    momentum: f64,
    eps: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_native_group_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    n: i64,
    c: i64,
    hxw: i64,
    group: i64,
    eps: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_native_layer_norm<T: Borrow<Tensor>>(
    &self,
    normalized_shape: &[i64],
    weight: Option<T>,
    bias: Option<T>,
    eps: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_native_norm(&self) -> Result<Tensor, TchError>

pub fn f_native_norm_scalaropt_dim_dtype<S: Into<Scalar>>(
    &self,
    p: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_ne<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_ne_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_ne_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_ne_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ne_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ne_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_neg(&self) -> Result<Tensor, TchError>

pub fn f_neg_(&mut self) -> Result<Tensor, TchError>

pub fn f_neg_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_negative(&self) -> Result<Tensor, TchError>

pub fn f_negative_(&mut self) -> Result<Tensor, TchError>

pub fn f_negative_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_new_empty(
    &self,
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_new_empty_strided(
    &self,
    size: &[i64],
    stride: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_new_full<S: Into<Scalar>>(
    &self,
    size: &[i64],
    fill_value: S,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_new_zeros(
    &self,
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_nextafter(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_nextafter_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_nextafter_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_nll_loss<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Result<Tensor, TchError>

pub fn f_nll_loss2d<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Result<Tensor, TchError>

pub fn f_nll_loss2d_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64,
    total_weight: &Tensor
) -> Result<Tensor, TchError>

pub fn f_nll_loss2d_backward_grad_input<T: Borrow<Tensor>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64,
    total_weight: &Tensor
) -> Result<Tensor, TchError>

pub fn f_nll_loss2d_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Result<Tensor, TchError>

pub fn f_nll_loss_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64,
    total_weight: &Tensor
) -> Result<Tensor, TchError>

pub fn f_nll_loss_backward_grad_input<T: Borrow<Tensor>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64,
    total_weight: &Tensor
) -> Result<Tensor, TchError>

pub fn f_nll_loss_nd<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Result<Tensor, TchError>

pub fn f_nll_loss_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Result<Tensor, TchError>

pub fn f_nonzero(&self) -> Result<Tensor, TchError>

pub fn f_nonzero_numpy(&self) -> Result<Vec<Tensor>, TchError>

pub fn f_nonzero_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_norm(&self) -> Result<Tensor, TchError>

pub fn f_norm_dtype_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    p: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_norm_except_dim(
    v: &Tensor,
    pow: i64,
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_norm_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    p: S,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_norm_scalaropt_dim<S: Into<Scalar>>(
    &self,
    p: S,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_norm_scalaropt_dim_dtype<S: Into<Scalar>>(
    &self,
    p: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_norm_scalaropt_dtype<S: Into<Scalar>>(
    &self,
    p: S,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_normal(
    out: &Tensor,
    mean: &Tensor,
    std: f64
) -> Result<Tensor, TchError>

pub fn f_normal_(&mut self, mean: f64, std: f64) -> Result<Tensor, TchError>

pub fn f_normal_float_float_out(
    out: &Tensor,
    mean: f64,
    std: f64,
    size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_normal_float_tensor_out(
    out: &Tensor,
    mean: f64,
    std: &Tensor
) -> Result<Tensor, TchError>

pub fn f_normal_tensor_tensor_out(
    out: &Tensor,
    mean: &Tensor,
    std: &Tensor
) -> Result<Tensor, TchError>

pub fn f_not_equal<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_not_equal_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_not_equal_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_not_equal_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_not_equal_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_not_equal_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_nuclear_norm(&self, keepdim: bool) -> Result<Tensor, TchError>

pub fn f_nuclear_norm_dim(
    &self,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_nuclear_norm_dim_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_nuclear_norm_out(
    &self,
    out: &Tensor,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_numpy_t(&self) -> Result<Tensor, TchError>

pub fn f_one_hot(&self, num_classes: i64) -> Result<Tensor, TchError>

pub fn f_ones(size: &[i64], options: (Kind, Device)) -> Result<Tensor, TchError>

pub fn f_ones_like(&self) -> Result<Tensor, TchError>

pub fn f_ones_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_orgqr(&self, input2: &Tensor) -> Result<Tensor, TchError>

pub fn f_orgqr_out(
    &self,
    out: &Tensor,
    input2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_ormqr(
    &self,
    input2: &Tensor,
    input3: &Tensor,
    left: bool,
    transpose: bool
) -> Result<Tensor, TchError>

pub fn f_ormqr_out(
    &self,
    out: &Tensor,
    input2: &Tensor,
    input3: &Tensor,
    left: bool,
    transpose: bool
) -> Result<Tensor, TchError>

pub fn f_outer(&self, vec2: &Tensor) -> Result<Tensor, TchError>

pub fn f_outer_out(
    &self,
    out: &Tensor,
    vec2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_output_nr(&self) -> Result<i64, TchError>

pub fn f_pad_sequence<T: Borrow<Tensor>>(
    sequences: &[T],
    batch_first: bool,
    padding_value: f64
) -> Result<Tensor, TchError>

pub fn f_pairwise_distance(
    x1: &Tensor,
    x2: &Tensor,
    p: f64,
    eps: f64,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_pdist(&self, p: f64) -> Result<Tensor, TchError>

pub fn f_permute(&self, dims: &[i64]) -> Result<Tensor, TchError>

pub fn f_pin_memory(&self) -> Result<Tensor, TchError>

pub fn f_pinverse(&self, rcond: f64) -> Result<Tensor, TchError>

pub fn f_pixel_shuffle(&self, upscale_factor: i64) -> Result<Tensor, TchError>

pub fn f_pixel_unshuffle(
    &self,
    downscale_factor: i64
) -> Result<Tensor, TchError>

pub fn f_poisson(&self) -> Result<Tensor, TchError>

pub fn f_poisson_nll_loss(
    &self,
    target: &Tensor,
    log_input: bool,
    full: bool,
    eps: f64,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_polar(abs: &Tensor, angle: &Tensor) -> Result<Tensor, TchError>

pub fn f_polar_out(
    out: &Tensor,
    abs: &Tensor,
    angle: &Tensor
) -> Result<Tensor, TchError>

pub fn f_polygamma(&self, n: i64) -> Result<Tensor, TchError>

pub fn f_polygamma_(&mut self, n: i64) -> Result<Tensor, TchError>

pub fn f_polygamma_out(&self, out: &Tensor, n: i64) -> Result<Tensor, TchError>

pub fn f_positive(&self) -> Result<Tensor, TchError>

pub fn f_pow<S: Into<Scalar>>(&self, exponent: S) -> Result<Tensor, TchError>

pub fn f_pow_<S: Into<Scalar>>(
    &mut self,
    exponent: S
) -> Result<Tensor, TchError>

pub fn f_pow_scalar<S: Into<Scalar>>(
    self_scalar: S,
    exponent: &Tensor
) -> Result<Tensor, TchError>

pub fn f_pow_scalar_out<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    exponent: &Tensor
) -> Result<Tensor, TchError>

pub fn f_pow_tensor_(&mut self, exponent: &Tensor) -> Result<Tensor, TchError>

pub fn f_pow_tensor_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    exponent: S
) -> Result<Tensor, TchError>

pub fn f_pow_tensor_tensor(&self, exponent: &Tensor) -> Result<Tensor, TchError>

pub fn f_pow_tensor_tensor_out(
    &self,
    out: &Tensor,
    exponent: &Tensor
) -> Result<Tensor, TchError>

pub fn f_prelu(&self, weight: &Tensor) -> Result<Tensor, TchError>

pub fn f_prelu_backward(
    &self,
    grad_output: &Tensor,
    weight: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_prod(&self, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_prod_dim_int(
    &self,
    dim: i64,
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_prod_int_out(
    &self,
    out: &Tensor,
    dim: i64,
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_put(
    &self,
    index: &Tensor,
    source: &Tensor,
    accumulate: bool
) -> Result<Tensor, TchError>

pub fn f_put_(
    &mut self,
    index: &Tensor,
    source: &Tensor,
    accumulate: bool
) -> Result<Tensor, TchError>

pub fn f_q_per_channel_axis(&self) -> Result<i64, TchError>

pub fn f_q_per_channel_scales(&self) -> Result<Tensor, TchError>

pub fn f_q_per_channel_zero_points(&self) -> Result<Tensor, TchError>

pub fn f_q_scale(&self) -> Result<f64, TchError>

pub fn f_q_zero_point(&self) -> Result<i64, TchError>

pub fn f_qr(&self, some: bool) -> Result<(Tensor, Tensor), TchError>

pub fn f_qr_q(
    &self,
    q: &Tensor,
    r: &Tensor,
    some: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_quantile(
    &self,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_quantile_new(
    &self,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Result<Tensor, TchError>

pub fn f_quantile_new_out(
    &self,
    out: &Tensor,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Result<Tensor, TchError>

pub fn f_quantile_new_scalar(
    &self,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Result<Tensor, TchError>

pub fn f_quantile_new_scalar_out(
    &self,
    out: &Tensor,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Result<Tensor, TchError>

pub fn f_quantile_out(
    &self,
    out: &Tensor,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_quantile_scalar(
    &self,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_quantile_scalar_out(
    &self,
    out: &Tensor,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_quantize_per_channel(
    &self,
    scales: &Tensor,
    zero_points: &Tensor,
    axis: i64,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_quantize_per_tensor(
    &self,
    scale: f64,
    zero_point: i64,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_quantize_per_tensor_tensors<T: Borrow<Tensor>>(
    tensors: &[T],
    scales: &Tensor,
    zero_points: &Tensor,
    dtype: Kind
) -> Result<Vec<Tensor>, TchError>

pub fn f_quantized_batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    mean: &Tensor,
    var: &Tensor,
    eps: f64,
    output_scale: f64,
    output_zero_point: i64
) -> Result<Tensor, TchError>

pub fn f_quantized_gru_cell<S: Into<Scalar>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: &Tensor,
    b_hh: &Tensor,
    packed_ih: &Tensor,
    packed_hh: &Tensor,
    col_offsets_ih: &Tensor,
    col_offsets_hh: &Tensor,
    scale_ih: S,
    scale_hh: S,
    zero_point_ih: S,
    zero_point_hh: S
) -> Result<Tensor, TchError>

pub fn f_quantized_lstm_cell<T: Borrow<Tensor>, S: Into<Scalar>>(
    &self,
    hx: &[T],
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: &Tensor,
    b_hh: &Tensor,
    packed_ih: &Tensor,
    packed_hh: &Tensor,
    col_offsets_ih: &Tensor,
    col_offsets_hh: &Tensor,
    scale_ih: S,
    scale_hh: S,
    zero_point_ih: S,
    zero_point_hh: S
) -> Result<(Tensor, Tensor), TchError>

pub fn f_quantized_max_pool1d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<Tensor, TchError>

pub fn f_quantized_max_pool2d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Result<Tensor, TchError>

pub fn f_quantized_rnn_relu_cell<S: Into<Scalar>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: &Tensor,
    b_hh: &Tensor,
    packed_ih: &Tensor,
    packed_hh: &Tensor,
    col_offsets_ih: &Tensor,
    col_offsets_hh: &Tensor,
    scale_ih: S,
    scale_hh: S,
    zero_point_ih: S,
    zero_point_hh: S
) -> Result<Tensor, TchError>

pub fn f_quantized_rnn_tanh_cell<S: Into<Scalar>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: &Tensor,
    b_hh: &Tensor,
    packed_ih: &Tensor,
    packed_hh: &Tensor,
    col_offsets_ih: &Tensor,
    col_offsets_hh: &Tensor,
    scale_ih: S,
    scale_hh: S,
    zero_point_ih: S,
    zero_point_hh: S
) -> Result<Tensor, TchError>

pub fn f_rad2deg(&self) -> Result<Tensor, TchError>

pub fn f_rad2deg_(&mut self) -> Result<Tensor, TchError>

pub fn f_rad2deg_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_rand(size: &[i64], options: (Kind, Device)) -> Result<Tensor, TchError>

pub fn f_rand_like(&self) -> Result<Tensor, TchError>

pub fn f_rand_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_randint(
    high: i64,
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_randint_like(&self, high: i64) -> Result<Tensor, TchError>

pub fn f_randint_like_low_dtype(
    &self,
    low: i64,
    high: i64
) -> Result<Tensor, TchError>

pub fn f_randint_low(
    low: i64,
    high: i64,
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_randint_low_out(
    out: &Tensor,
    low: i64,
    high: i64,
    size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_randint_out(
    out: &Tensor,
    high: i64,
    size: &[i64]
) -> Result<Tensor, TchError>

pub fn f_randn(
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_randn_like(&self) -> Result<Tensor, TchError>

pub fn f_randn_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_random_(&mut self) -> Result<Tensor, TchError>

pub fn f_random_from_(
    &mut self,
    from: i64,
    to: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_random_to_(&mut self, to: i64) -> Result<Tensor, TchError>

pub fn f_randperm(n: i64, options: (Kind, Device)) -> Result<Tensor, TchError>

pub fn f_randperm_out(out: &Tensor, n: i64) -> Result<Tensor, TchError>

pub fn f_range<S: Into<Scalar>>(
    start: S,
    end: S,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_range_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S
) -> Result<Tensor, TchError>

pub fn f_range_step<S: Into<Scalar>>(
    start: S,
    end: S,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_ravel(&self) -> Result<Tensor, TchError>

pub fn f_real(&self) -> Result<Tensor, TchError>

pub fn f_reciprocal(&self) -> Result<Tensor, TchError>

pub fn f_reciprocal_(&mut self) -> Result<Tensor, TchError>

pub fn f_reciprocal_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_reflection_pad1d(&self, padding: &[i64]) -> Result<Tensor, TchError>

pub fn f_reflection_pad1d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_reflection_pad1d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_reflection_pad1d_out(
    &self,
    out: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_reflection_pad2d(&self, padding: &[i64]) -> Result<Tensor, TchError>

pub fn f_reflection_pad2d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_reflection_pad2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_reflection_pad2d_out(
    &self,
    out: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_relu(&self) -> Result<Tensor, TchError>

pub fn f_relu6(&self) -> Result<Tensor, TchError>

pub fn f_relu6_(&mut self) -> Result<Tensor, TchError>

pub fn f_relu_(&mut self) -> Result<Tensor, TchError>

pub fn f_remainder<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_remainder_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_remainder_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_remainder_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_remainder_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_remainder_tensor_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_renorm<S: Into<Scalar>>(
    &self,
    p: S,
    dim: i64,
    maxnorm: S
) -> Result<Tensor, TchError>

pub fn f_renorm_<S: Into<Scalar>>(
    &mut self,
    p: S,
    dim: i64,
    maxnorm: S
) -> Result<Tensor, TchError>

pub fn f_renorm_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    p: S,
    dim: i64,
    maxnorm: S
) -> Result<Tensor, TchError>

pub fn f_repeat(&self, repeats: &[i64]) -> Result<Tensor, TchError>

pub fn f_repeat_interleave(repeats: &Tensor) -> Result<Tensor, TchError>

pub fn f_repeat_interleave_self_int(
    &self,
    repeats: i64,
    dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_repeat_interleave_self_tensor(
    &self,
    repeats: &Tensor,
    dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_replication_pad1d(&self, padding: &[i64]) -> Result<Tensor, TchError>

pub fn f_replication_pad1d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_replication_pad1d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_replication_pad1d_out(
    &self,
    out: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_replication_pad2d(&self, padding: &[i64]) -> Result<Tensor, TchError>

pub fn f_replication_pad2d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_replication_pad2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_replication_pad2d_out(
    &self,
    out: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_replication_pad3d(&self, padding: &[i64]) -> Result<Tensor, TchError>

pub fn f_replication_pad3d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_replication_pad3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_replication_pad3d_out(
    &self,
    out: &Tensor,
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_requires_grad_(
    &mut self,
    requires_grad: bool
) -> Result<Tensor, TchError>

pub fn f_reshape(&self, shape: &[i64]) -> Result<Tensor, TchError>

pub fn f_reshape_as(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_resize_(&mut self, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_resize_as_(
    &mut self,
    the_template: &Tensor
) -> Result<Tensor, TchError>

pub fn f_resize_as_sparse_(
    &mut self,
    the_template: &Tensor
) -> Result<Tensor, TchError>

pub fn f_rnn_relu<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_first: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_rnn_relu_cell<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: Option<T>,
    b_hh: Option<T>
) -> Result<Tensor, TchError>

pub fn f_rnn_relu_data<T: Borrow<Tensor>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_rnn_tanh<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_first: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_rnn_tanh_cell<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: Option<T>,
    b_hh: Option<T>
) -> Result<Tensor, TchError>

pub fn f_rnn_tanh_data<T: Borrow<Tensor>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_roll(&self, shifts: &[i64], dims: &[i64]) -> Result<Tensor, TchError>

pub fn f_rot90(&self, k: i64, dims: &[i64]) -> Result<Tensor, TchError>

pub fn f_round(&self) -> Result<Tensor, TchError>

pub fn f_round_(&mut self) -> Result<Tensor, TchError>

pub fn f_round_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_row_stack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>

pub fn f_row_stack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_rrelu(&self, training: bool) -> Result<Tensor, TchError>

pub fn f_rrelu_(&mut self, training: bool) -> Result<Tensor, TchError>

pub fn f_rrelu_with_noise(
    &self,
    noise: &Tensor,
    training: bool
) -> Result<Tensor, TchError>

pub fn f_rrelu_with_noise_(
    &mut self,
    noise: &Tensor,
    training: bool
) -> Result<Tensor, TchError>

pub fn f_rrelu_with_noise_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    noise: &Tensor,
    lower: S,
    upper: S,
    training: bool,
    self_is_result: bool
) -> Result<Tensor, TchError>

pub fn f_rrelu_with_noise_out(
    &self,
    out: &Tensor,
    noise: &Tensor,
    training: bool
) -> Result<Tensor, TchError>

pub fn f_rsqrt(&self) -> Result<Tensor, TchError>

pub fn f_rsqrt_(&mut self) -> Result<Tensor, TchError>

pub fn f_rsqrt_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_rsub(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_rsub_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_scalar_tensor<S: Into<Scalar>>(
    s: S,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_scatter(
    &self,
    dim: i64,
    index: &Tensor,
    src: &Tensor
) -> Result<Tensor, TchError>

pub fn f_scatter_(
    &mut self,
    dim: i64,
    index: &Tensor,
    src: &Tensor
) -> Result<Tensor, TchError>

pub fn f_scatter_add(
    &self,
    dim: i64,
    index: &Tensor,
    src: &Tensor
) -> Result<Tensor, TchError>

pub fn f_scatter_add_(
    &mut self,
    dim: i64,
    index: &Tensor,
    src: &Tensor
) -> Result<Tensor, TchError>

pub fn f_scatter_reduce_(
    &mut self,
    dim: i64,
    index: &Tensor,
    src: &Tensor,
    reduce: &str
) -> Result<Tensor, TchError>

pub fn f_scatter_value<S: Into<Scalar>>(
    &self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Result<Tensor, TchError>

pub fn f_scatter_value_<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Result<Tensor, TchError>

pub fn f_scatter_value_reduce_<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S,
    reduce: &str
) -> Result<Tensor, TchError>

pub fn f_searchsorted(
    &self,
    sorted_sequence: &Tensor,
    out_int32: bool,
    right: bool
) -> Result<Tensor, TchError>

pub fn f_searchsorted_scalar<S: Into<Scalar>>(
    sorted_sequence: &Tensor,
    self_scalar: S,
    out_int32: bool,
    right: bool
) -> Result<Tensor, TchError>

pub fn f_searchsorted_tensor_out(
    &self,
    out: &Tensor,
    sorted_sequence: &Tensor,
    out_int32: bool,
    right: bool
) -> Result<Tensor, TchError>

pub fn f_segment_reduce<T: Borrow<Tensor>, S: Into<Scalar>>(
    data: &Tensor,
    reduce: &str,
    lengths: Option<T>,
    indices: Option<T>,
    axis: i64,
    unsafe_: bool,
    initial: S
) -> Result<Tensor, TchError>

pub fn f_segment_reduce_backward<T: Borrow<Tensor>>(
    grad: &Tensor,
    output: &Tensor,
    data: &Tensor,
    lengths: Option<T>
) -> Result<Tensor, TchError>

pub fn f_select(&self, dim: i64, index: i64) -> Result<Tensor, TchError>

pub fn f_select_backward(
    grad: &Tensor,
    input_sizes: &[i64],
    dim: i64,
    index: i64
) -> Result<Tensor, TchError>

pub fn f_selu(&self) -> Result<Tensor, TchError>

pub fn f_selu_(&mut self) -> Result<Tensor, TchError>

pub fn f_set_(&mut self) -> Result<Tensor, TchError>

pub fn f_set_requires_grad(&self, r: bool) -> Result<Tensor, TchError>

pub fn f_set_source_tensor_(
    &mut self,
    source: &Tensor
) -> Result<Tensor, TchError>

pub fn f_sgn(&self) -> Result<Tensor, TchError>

pub fn f_sgn_(&mut self) -> Result<Tensor, TchError>

pub fn f_sgn_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sigmoid(&self) -> Result<Tensor, TchError>

pub fn f_sigmoid_(&mut self) -> Result<Tensor, TchError>

pub fn f_sigmoid_backward(
    grad_output: &Tensor,
    output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_sigmoid_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_sigmoid_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sign(&self) -> Result<Tensor, TchError>

pub fn f_sign_(&mut self) -> Result<Tensor, TchError>

pub fn f_sign_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_signbit(&self) -> Result<Tensor, TchError>

pub fn f_signbit_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_silu(&self) -> Result<Tensor, TchError>

pub fn f_silu_(&mut self) -> Result<Tensor, TchError>

pub fn f_silu_backward(&self, grad_output: &Tensor) -> Result<Tensor, TchError>

pub fn f_silu_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sin(&self) -> Result<Tensor, TchError>

pub fn f_sin_(&mut self) -> Result<Tensor, TchError>

pub fn f_sin_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sinc(&self) -> Result<Tensor, TchError>

pub fn f_sinc_(&mut self) -> Result<Tensor, TchError>

pub fn f_sinc_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sinh(&self) -> Result<Tensor, TchError>

pub fn f_sinh_(&mut self) -> Result<Tensor, TchError>

pub fn f_sinh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_slice(
    &self,
    dim: i64,
    start: impl Into<Option<i64>>,
    end: impl Into<Option<i64>>,
    step: i64
) -> Result<Tensor, TchError>

pub fn f_slice_backward(
    grad: &Tensor,
    input_sizes: &[i64],
    dim: i64,
    start: i64,
    end: i64,
    step: i64
) -> Result<Tensor, TchError>

pub fn f_slogdet(&self) -> Result<(Tensor, Tensor), TchError>

pub fn f_slow_conv3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_slow_conv3d_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64]
) -> Result<Tensor, TchError>

pub fn f_slow_conv_dilated2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_slow_conv_dilated3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_slow_conv_transpose2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_slow_conv_transpose2d_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_slow_conv_transpose3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_slow_conv_transpose3d_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    dilation: &[i64]
) -> Result<Tensor, TchError>

pub fn f_smm(&self, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss(
    &self,
    target: &Tensor,
    reduction: Reduction,
    beta: f64
) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    beta: f64
) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    beta: f64
) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    beta: f64
) -> Result<Tensor, TchError>

pub fn f_soft_margin_loss(
    &self,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_soft_margin_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_soft_margin_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_soft_margin_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_softmax(&self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_softplus(&self) -> Result<Tensor, TchError>

pub fn f_softplus_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    beta: S,
    threshold: S,
    output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_softplus_backward_grad_input<S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    beta: S,
    threshold: S,
    output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_softplus_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_softshrink(&self) -> Result<Tensor, TchError>

pub fn f_softshrink_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    lambd: S
) -> Result<Tensor, TchError>

pub fn f_softshrink_backward_grad_input<S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    lambd: S
) -> Result<Tensor, TchError>

pub fn f_softshrink_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_solve(&self, a: &Tensor) -> Result<(Tensor, Tensor), TchError>

pub fn f_solve_solution(
    &self,
    solution: &Tensor,
    lu: &Tensor,
    a: &Tensor
) -> Result<(Tensor, Tensor), TchError>

pub fn f_sort(
    &self,
    dim: i64,
    descending: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_sort_stable(
    &self,
    stable: bool,
    dim: i64,
    descending: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_sort_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    descending: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_sort_values_stable(
    &self,
    values: &Tensor,
    indices: &Tensor,
    stable: bool,
    dim: i64,
    descending: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_sparse_coo_tensor(
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_sparse_coo_tensor_indices(
    indices: &Tensor,
    values: &Tensor,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_sparse_coo_tensor_indices_size(
    indices: &Tensor,
    values: &Tensor,
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_sparse_dim(&self) -> Result<i64, TchError>

pub fn f_sparse_mask(&self, mask: &Tensor) -> Result<Tensor, TchError>

pub fn f_sparse_resize_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Result<Tensor, TchError>

pub fn f_sparse_resize_and_clear_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Result<Tensor, TchError>

pub fn f_special_entr(&self) -> Result<Tensor, TchError>

pub fn f_special_entr_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_erf(&self) -> Result<Tensor, TchError>

pub fn f_special_erf_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_erfc(&self) -> Result<Tensor, TchError>

pub fn f_special_erfc_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_erfinv(&self) -> Result<Tensor, TchError>

pub fn f_special_erfinv_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_exp2(&self) -> Result<Tensor, TchError>

pub fn f_special_exp2_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_expit(&self) -> Result<Tensor, TchError>

pub fn f_special_expit_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_expm1(&self) -> Result<Tensor, TchError>

pub fn f_special_expm1_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_gammaln(&self) -> Result<Tensor, TchError>

pub fn f_special_gammaln_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_i0e(&self) -> Result<Tensor, TchError>

pub fn f_special_i0e_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_logit(
    &self,
    eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_special_logit_out(
    &self,
    out: &Tensor,
    eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_special_xlog1py(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_other_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_other_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_self_scalar<S: Into<Scalar>>(
    self_scalar: S,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_self_scalar_out<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_split(
    &self,
    split_size: i64,
    dim: i64
) -> Result<Vec<Tensor>, TchError>

pub fn f_split_with_sizes(
    &self,
    split_sizes: &[i64],
    dim: i64
) -> Result<Vec<Tensor>, TchError>

pub fn f_sqrt(&self) -> Result<Tensor, TchError>

pub fn f_sqrt_(&mut self) -> Result<Tensor, TchError>

pub fn f_sqrt_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_square(&self) -> Result<Tensor, TchError>

pub fn f_square_(&mut self) -> Result<Tensor, TchError>

pub fn f_square_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_squeeze(&self) -> Result<Tensor, TchError>

pub fn f_squeeze_(&mut self) -> Result<Tensor, TchError>

pub fn f_squeeze_dim(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_squeeze_dim_(&mut self, dim: i64) -> Result<Tensor, TchError>

pub fn f_sspaddmm(
    &self,
    mat1: &Tensor,
    mat2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_sspaddmm_out(
    &self,
    out: &Tensor,
    mat1: &Tensor,
    mat2: &Tensor
) -> Result<Tensor, TchError>

pub fn f_stack<T: Borrow<Tensor>>(
    tensors: &[T],
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_stack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T],
    dim: i64
) -> Result<Tensor, TchError>

pub fn f_std(&self, unbiased: bool) -> Result<Tensor, TchError>

pub fn f_std_correction<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_std_correction_out<'a>(
    &self,
    out: &Tensor,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_std_dim(
    &self,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_std_mean(&self, unbiased: bool) -> Result<(Tensor, Tensor), TchError>

pub fn f_std_mean_correction<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_std_mean_dim(
    &self,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_std_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_stft<T: Borrow<Tensor>>(
    &self,
    n_fft: i64,
    hop_length: impl Into<Option<i64>>,
    win_length: impl Into<Option<i64>>,
    window: Option<T>,
    normalized: bool,
    onesided: bool,
    return_complex: bool
) -> Result<Tensor, TchError>

pub fn f_sub(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_sub_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_sub_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_sub_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_sub_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_subtract(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_subtract_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_subtract_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_subtract_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_subtract_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_sum(&self, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_sum_dim_intlist(
    &self,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_sum_intlist_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_sum_to_size(&self, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_svd(
    &self,
    some: bool,
    compute_uv: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_svd_u(
    &self,
    u: &Tensor,
    s: &Tensor,
    v: &Tensor,
    some: bool,
    compute_uv: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_swapaxes(&self, axis0: i64, axis1: i64) -> Result<Tensor, TchError>

pub fn f_swapaxes_(
    &mut self,
    axis0: i64,
    axis1: i64
) -> Result<Tensor, TchError>

pub fn f_swapdims(&self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>

pub fn f_swapdims_(&mut self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>

pub fn f_symeig(
    &self,
    eigenvectors: bool,
    upper: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_symeig_e(
    &self,
    e: &Tensor,
    v: &Tensor,
    eigenvectors: bool,
    upper: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_tr(&self) -> Result<Tensor, TchError>

pub fn f_t_(&mut self) -> Result<Tensor, TchError>

pub fn f_take(&self, index: &Tensor) -> Result<Tensor, TchError>

pub fn f_take_along_dim(
    &self,
    indices: &Tensor,
    dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_take_along_dim_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_take_out(
    &self,
    out: &Tensor,
    index: &Tensor
) -> Result<Tensor, TchError>

pub fn f_tan(&self) -> Result<Tensor, TchError>

pub fn f_tan_(&mut self) -> Result<Tensor, TchError>

pub fn f_tan_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_tanh(&self) -> Result<Tensor, TchError>

pub fn f_tanh_(&mut self) -> Result<Tensor, TchError>

pub fn f_tanh_backward(
    grad_output: &Tensor,
    output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_tanh_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_tanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_tensor_split(
    &self,
    sections: i64,
    dim: i64
) -> Result<Vec<Tensor>, TchError>

pub fn f_tensor_split_indices(
    &self,
    indices: &[i64],
    dim: i64
) -> Result<Vec<Tensor>, TchError>

pub fn f_tensor_split_tensor_indices_or_sections(
    &self,
    tensor_indices_or_sections: &Tensor,
    dim: i64
) -> Result<Vec<Tensor>, TchError>

pub fn f_tensordot(
    &self,
    other: &Tensor,
    dims_self: &[i64],
    dims_other: &[i64]
) -> Result<Tensor, TchError>

pub fn f_tensordot_out(
    &self,
    out: &Tensor,
    other: &Tensor,
    dims_self: &[i64],
    dims_other: &[i64]
) -> Result<Tensor, TchError>

pub fn f_threshold<S: Into<Scalar>>(
    &self,
    threshold: S,
    value: S
) -> Result<Tensor, TchError>

pub fn f_threshold_<S: Into<Scalar>>(
    &mut self,
    threshold: S,
    value: S
) -> Result<Tensor, TchError>

pub fn f_threshold_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    threshold: S
) -> Result<Tensor, TchError>

pub fn f_threshold_backward_grad_input<S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    threshold: S
) -> Result<Tensor, TchError>

pub fn f_threshold_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    threshold: S,
    value: S
) -> Result<Tensor, TchError>

pub fn f_tile(&self, dims: &[i64]) -> Result<Tensor, TchError>

pub fn f_to(&self, device: Device) -> Result<Tensor, TchError>

pub fn f_to_dense(&self, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_to_dense_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>

pub fn f_to_device_(
    &self,
    device: Device,
    dtype: Kind,
    non_blocking: bool,
    copy: bool
) -> Result<Tensor, TchError>

pub fn f_to_dtype(
    &self,
    dtype: Kind,
    non_blocking: bool,
    copy: bool
) -> Result<Tensor, TchError>

pub fn f_to_dtype_layout(
    &self,
    options: (Kind, Device),
    non_blocking: bool,
    copy: bool
) -> Result<Tensor, TchError>

pub fn f_to_mkldnn(&self, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_to_mkldnn_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>

pub fn f_to_other(
    &self,
    other: &Tensor,
    non_blocking: bool,
    copy: bool
) -> Result<Tensor, TchError>

pub fn f_to_sparse(&self) -> Result<Tensor, TchError>

pub fn f_to_sparse_sparse_dim(
    &self,
    sparse_dim: i64
) -> Result<Tensor, TchError>

pub fn f_topk(
    &self,
    k: i64,
    dim: i64,
    largest: bool,
    sorted: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_topk_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    k: i64,
    dim: i64,
    largest: bool,
    sorted: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_totype(&self, scalar_type: Kind) -> Result<Tensor, TchError>

pub fn f_trace(&self) -> Result<Tensor, TchError>

pub fn f_trace_backward(
    grad: &Tensor,
    sizes: &[i64]
) -> Result<Tensor, TchError>

pub fn f_transpose(&self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>

pub fn f_transpose_(&mut self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>

pub fn f_trapz(y: &Tensor, x: &Tensor, dim: i64) -> Result<Tensor, TchError>

pub fn f_trapz_dx(y: &Tensor, dx: f64, dim: i64) -> Result<Tensor, TchError>

pub fn f_triangular_solve(
    &self,
    a: &Tensor,
    upper: bool,
    transpose: bool,
    unitriangular: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_triangular_solve_x(
    &self,
    x: &Tensor,
    m: &Tensor,
    a: &Tensor,
    upper: bool,
    transpose: bool,
    unitriangular: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_tril(&self, diagonal: i64) -> Result<Tensor, TchError>

pub fn f_tril_(&mut self, diagonal: i64) -> Result<Tensor, TchError>

pub fn f_tril_indices(
    row: i64,
    col: i64,
    offset: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_tril_out(
    &self,
    out: &Tensor,
    diagonal: i64
) -> Result<Tensor, TchError>

pub fn f_triplet_margin_loss(
    anchor: &Tensor,
    positive: &Tensor,
    negative: &Tensor,
    margin: f64,
    p: f64,
    eps: f64,
    swap: bool,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_triu(&self, diagonal: i64) -> Result<Tensor, TchError>

pub fn f_triu_(&mut self, diagonal: i64) -> Result<Tensor, TchError>

pub fn f_triu_indices(
    row: i64,
    col: i64,
    offset: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_triu_out(
    &self,
    out: &Tensor,
    diagonal: i64
) -> Result<Tensor, TchError>

pub fn f_true_divide(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_true_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_true_divide_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_true_divide_scalar<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_true_divide_scalar_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_trunc(&self) -> Result<Tensor, TchError>

pub fn f_trunc_(&mut self) -> Result<Tensor, TchError>

pub fn f_trunc_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_type_as(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_unbind(&self, dim: i64) -> Result<Vec<Tensor>, TchError>

pub fn f_unflatten(&self, dim: i64, sizes: &[i64]) -> Result<Tensor, TchError>

pub fn f_unflatten_dense_tensors<T: Borrow<Tensor>>(
    flat: &Tensor,
    tensors: &[T]
) -> Result<Vec<Tensor>, TchError>

pub fn f_unfold(
    &self,
    dimension: i64,
    size: i64,
    step: i64
) -> Result<Tensor, TchError>

pub fn f_unfold_backward(
    grad_in: &Tensor,
    input_sizes: &[i64],
    dim: i64,
    size: i64,
    step: i64
) -> Result<Tensor, TchError>

pub fn f_uniform_(&mut self, from: f64, to: f64) -> Result<Tensor, TchError>

pub fn f_unique_consecutive(
    &self,
    return_inverse: bool,
    return_counts: bool,
    dim: impl Into<Option<i64>>
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_unique_dim(
    &self,
    dim: i64,
    sorted: bool,
    return_inverse: bool,
    return_counts: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_unique_dim_consecutive(
    &self,
    dim: i64,
    return_inverse: bool,
    return_counts: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_unsafe_chunk(
    &self,
    chunks: i64,
    dim: i64
) -> Result<Vec<Tensor>, TchError>

pub fn f_unsafe_split(
    &self,
    split_size: i64,
    dim: i64
) -> Result<Vec<Tensor>, TchError>

pub fn f_unsafe_split_with_sizes(
    &self,
    split_sizes: &[i64],
    dim: i64
) -> Result<Vec<Tensor>, TchError>

pub fn f_unsqueeze(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_unsqueeze_(&mut self, dim: i64) -> Result<Tensor, TchError>

pub fn f_upsample_bicubic2d(
    &self,
    output_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_bicubic2d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_bicubic2d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_bicubic2d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    align_corners: bool,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_bicubic2d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_bicubic2d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    align_corners: bool,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_bilinear2d(
    &self,
    output_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_bilinear2d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_bilinear2d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_bilinear2d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    align_corners: bool,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_bilinear2d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_bilinear2d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    align_corners: bool,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d(
    &self,
    output_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    align_corners: bool,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    align_corners: bool,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d(
    &self,
    output_size: &[i64],
    scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest2d(
    &self,
    output_size: &[i64],
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest2d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest2d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest2d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest2d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest2d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest3d(
    &self,
    output_size: &[i64],
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest3d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest3d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest3d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest3d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_nearest3d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_trilinear3d(
    &self,
    output_size: &[i64],
    align_corners: bool,
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_trilinear3d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_trilinear3d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_trilinear3d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    align_corners: bool,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_upsample_trilinear3d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

pub fn f_upsample_trilinear3d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    align_corners: bool,
    scale_factors: &[f64]
) -> Result<Tensor, TchError>

pub fn f_value_selecting_reduction_backward(
    grad: &Tensor,
    dim: i64,
    indices: &Tensor,
    sizes: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_values(&self) -> Result<Tensor, TchError>

pub fn f_vander(
    x: &Tensor,
    n: impl Into<Option<i64>>,
    increasing: bool
) -> Result<Tensor, TchError>

pub fn f_var(&self, unbiased: bool) -> Result<Tensor, TchError>

pub fn f_var_correction<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_var_correction_out<'a>(
    &self,
    out: &Tensor,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_var_dim(
    &self,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_var_mean(&self, unbiased: bool) -> Result<(Tensor, Tensor), TchError>

pub fn f_var_mean_correction<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_var_mean_dim(
    &self,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_var_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_vdot(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_vdot_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_view_(&self, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_view_as(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_view_as_complex(&self) -> Result<Tensor, TchError>

pub fn f_view_as_real(&self) -> Result<Tensor, TchError>

pub fn f_view_dtype(&self, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_vsplit(&self, sections: i64) -> Result<Vec<Tensor>, TchError>

pub fn f_vsplit_array(&self, indices: &[i64]) -> Result<Vec<Tensor>, TchError>

pub fn f_vstack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>

pub fn f_vstack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T]
) -> Result<Tensor, TchError>

pub fn f_where_(condition: &Tensor) -> Result<Vec<Tensor>, TchError>

pub fn f_where_scalar<S: Into<Scalar>>(
    condition: &Tensor,
    self_scalar: S,
    other: S
) -> Result<Tensor, TchError>

pub fn f_where_scalarother<S: Into<Scalar>>(
    &self,
    condition: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_where_scalarself<S: Into<Scalar>>(
    condition: &Tensor,
    self_scalar: S,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_where_self(
    &self,
    condition: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_xlogy(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_xlogy_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_xlogy_outscalar_other<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Result<Tensor, TchError>

pub fn f_xlogy_outscalar_self<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_xlogy_outtensor(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_xlogy_scalar_other<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_xlogy_scalar_other_<S: Into<Scalar>>(
    &mut self,
    other: S
) -> Result<Tensor, TchError>

pub fn f_xlogy_scalar_self<S: Into<Scalar>>(
    self_scalar: S,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_zero_(&mut self) -> Result<Tensor, TchError>

pub fn f_zeros(
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_zeros_like(&self) -> Result<Tensor, TchError>

pub fn f_zeros_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>

impl Tensor

pub fn internal_and_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_and_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_iand_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_iand_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_ilshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_ilshift_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_ior_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_ior_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_irshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_irshift_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_ixor_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_ixor_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_lshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_lshift_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_or_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_or_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_rshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_rshift_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_xor_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_xor_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_adaptive_avg_pool2d(&self, output_size: &[i64]) -> Tensor

pub fn internal_adaptive_avg_pool2d_backward(
    &self,
    grad_output: &Tensor
) -> Tensor

pub fn internal_adaptive_avg_pool3d(&self, output_size: &[i64]) -> Tensor

pub fn internal_adaptive_avg_pool3d_backward(
    &self,
    grad_output: &Tensor
) -> Tensor

pub fn internal_add_batch_dim(&self, batch_dim: i64, level: i64) -> Tensor

pub fn internal_add_relu(&self, other: &Tensor) -> Tensor

pub fn internal_add_relu_(&mut self, other: &Tensor) -> Tensor

pub fn internal_add_relu_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn internal_aminmax(&self) -> (Tensor, Tensor)

pub fn internal_aminmax_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn internal_amp_update_scale_(
    &mut self,
    growth_tracker: &Tensor,
    found_inf: &Tensor,
    scale_growth_factor: f64,
    scale_backoff_factor: f64,
    growth_interval: i64
) -> Tensor

pub fn internal_baddbmm_mkl_(
    &mut self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Tensor

pub fn internal_bmm(&self, mat2: &Tensor, deterministic: bool) -> Tensor

pub fn internal_bmm_out(
    &self,
    out: &Tensor,
    mat2: &Tensor,
    deterministic: bool
) -> Tensor

pub fn internal_cast_byte(&self, non_blocking: bool) -> Tensor

pub fn internal_cast_char(&self, non_blocking: bool) -> Tensor

pub fn internal_cast_double(&self, non_blocking: bool) -> Tensor

pub fn internal_cast_float(&self, non_blocking: bool) -> Tensor

pub fn internal_cast_half(&self, non_blocking: bool) -> Tensor

pub fn internal_cast_int(&self, non_blocking: bool) -> Tensor

pub fn internal_cast_long(&self, non_blocking: bool) -> Tensor

pub fn internal_cast_short(&self, non_blocking: bool) -> Tensor

pub fn internal_cat<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor

pub fn internal_cat_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T],
    dim: i64
) -> Tensor

pub fn internal_cdist_backward(
    grad: &Tensor,
    x1: &Tensor,
    x2: &Tensor,
    p: f64,
    cdist: &Tensor
) -> Tensor

pub fn internal_cholesky_solve_helper(&self, a: &Tensor, upper: bool) -> Tensor

pub fn internal_coalesce(&self) -> Tensor

pub fn internal_coalesced_(&mut self, coalesced: bool) -> Tensor

pub fn internal_compute_linear_combination(
    &self,
    coefficients: &Tensor
) -> Tensor

pub fn internal_compute_linear_combination_out(
    &self,
    out: &Tensor,
    coefficients: &Tensor
) -> Tensor

pub fn internal_conj(&self) -> Tensor

pub fn internal_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    cudnn_enabled: bool,
    allow_tf32: bool
) -> Tensor

pub fn internal_convolution_deprecated<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    cudnn_enabled: bool
) -> Tensor

pub fn internal_convolution_mode<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &str,
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn internal_convolution_nogroup<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64]
) -> Tensor

pub fn internal_copy_from(&self, dst: &Tensor, non_blocking: bool) -> Tensor

pub fn internal_ctc_loss(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    blank: i64,
    zero_infinity: bool
) -> (Tensor, Tensor)

pub fn internal_ctc_loss_backward(
    grad: &Tensor,
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    neg_log_likelihood: &Tensor,
    log_alpha: &Tensor,
    blank: i64,
    zero_infinity: bool
) -> Tensor

pub fn internal_cudnn_ctc_loss(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    blank: i64,
    deterministic: bool,
    zero_infinity: bool
) -> (Tensor, Tensor)

pub fn internal_cudnn_init_dropout_state(
    dropout: f64,
    train: bool,
    dropout_seed: i64,
    options: (Kind, Device)
) -> Tensor

pub fn internal_cudnn_rnn<T: Borrow<Tensor>>(
    &self,
    weight: &[T],
    weight_stride0: i64,
    weight_buf: Option<T>,
    hx: &Tensor,
    cx: Option<T>,
    mode: i64,
    hidden_size: i64,
    proj_size: i64,
    num_layers: i64,
    batch_first: bool,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_sizes: &[i64],
    dropout_state: Option<T>
) -> (Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn internal_cudnn_rnn_flatten_weight<T: Borrow<Tensor>>(
    weight_arr: &[T],
    weight_stride0: i64,
    input_size: i64,
    mode: i64,
    hidden_size: i64,
    proj_size: i64,
    num_layers: i64,
    batch_first: bool,
    bidirectional: bool
) -> Tensor

pub fn internal_cufft_get_plan_cache_max_size(device_index: i64) -> i64

pub fn internal_cufft_get_plan_cache_size(device_index: i64) -> i64

pub fn internal_cumprod(&self, dim: i64) -> Tensor

pub fn internal_cumprod_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn internal_cumsum(&self, dim: i64) -> Tensor

pub fn internal_cumsum_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn internal_debug_has_internal_overlap(&self) -> i64

pub fn internal_dim_arange(like: &Tensor, dim: i64) -> Tensor

pub fn internal_dimi(&self) -> i64

pub fn internal_dimv(&self) -> i64

pub fn internal_dirichlet_grad(
    x: &Tensor,
    alpha: &Tensor,
    total: &Tensor
) -> Tensor

pub fn internal_embedding_bag<T: Borrow<Tensor>>(
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    include_last_offset: bool,
    padding_idx: i64
) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_embedding_bag_backward<T: Borrow<Tensor>>(
    grad: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    offset2bag: &Tensor,
    bag_size: &Tensor,
    maximum_indices: &Tensor,
    num_weights: i64,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    padding_idx: i64
) -> Tensor

pub fn internal_embedding_bag_dense_backward<T: Borrow<Tensor>>(
    grad: &Tensor,
    indices: &Tensor,
    offset2bag: &Tensor,
    bag_size: &Tensor,
    maximum_indices: &Tensor,
    num_weights: i64,
    scale_grad_by_freq: bool,
    mode: i64,
    per_sample_weights: Option<T>,
    padding_idx: i64
) -> Tensor

pub fn internal_embedding_bag_forward_only<T: Borrow<Tensor>>(
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    include_last_offset: bool,
    padding_idx: i64
) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_embedding_bag_per_sample_weights_backward(
    grad: &Tensor,
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    offset2bag: &Tensor,
    mode: i64,
    padding_idx: i64
) -> Tensor

pub fn internal_embedding_bag_sparse_backward<T: Borrow<Tensor>>(
    grad: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    offset2bag: &Tensor,
    bag_size: &Tensor,
    num_weights: i64,
    scale_grad_by_freq: bool,
    mode: i64,
    per_sample_weights: Option<T>,
    padding_idx: i64
) -> Tensor

pub fn internal_empty_affine_quantized(
    size: &[i64],
    options: (Kind, Device),
    scale: f64,
    zero_point: i64
) -> Tensor

pub fn internal_empty_per_channel_affine_quantized(
    size: &[i64],
    scales: &Tensor,
    zero_points: &Tensor,
    axis: i64,
    options: (Kind, Device)
) -> Tensor

pub fn internal_euclidean_dist(x1: &Tensor, x2: &Tensor) -> Tensor

pub fn internal_fake_quantize_learnable_per_channel_affine(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64,
    grad_factor: f64
) -> Tensor

pub fn internal_fake_quantize_learnable_per_channel_affine_backward(
    &self,
    grad: &Tensor,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64,
    grad_factor: f64
) -> (Tensor, Tensor, Tensor)

pub fn internal_fake_quantize_learnable_per_tensor_affine(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    quant_min: i64,
    quant_max: i64,
    grad_factor: f64
) -> Tensor

pub fn internal_fake_quantize_learnable_per_tensor_affine_backward(
    &self,
    grad: &Tensor,
    scale: &Tensor,
    zero_point: &Tensor,
    quant_min: i64,
    quant_max: i64,
    grad_factor: f64
) -> (Tensor, Tensor, Tensor)

pub fn internal_fft_c2c(
    &self,
    dim: &[i64],
    normalization: i64,
    forward: bool
) -> Tensor

pub fn internal_fft_c2c_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    normalization: i64,
    forward: bool
) -> Tensor

pub fn internal_fft_c2r(
    &self,
    dim: &[i64],
    normalization: i64,
    last_dim_size: i64
) -> Tensor

pub fn internal_fft_c2r_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    normalization: i64,
    last_dim_size: i64
) -> Tensor

pub fn internal_fft_r2c(
    &self,
    dim: &[i64],
    normalization: i64,
    onesided: bool
) -> Tensor

pub fn internal_fft_r2c_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    normalization: i64,
    onesided: bool
) -> Tensor

pub fn internal_fused_dropout(&self, p: f64) -> (Tensor, Tensor)

pub fn internal_fw_primal(&self, level: i64) -> Tensor

pub fn internal_gather_sparse_backward(
    &self,
    dim: i64,
    index: &Tensor,
    grad: &Tensor
) -> Tensor

pub fn internal_grid_sampler_2d_cpu_fallback(
    &self,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Tensor

pub fn internal_grid_sampler_2d_cpu_fallback_backward(
    &self,
    grad_output: &Tensor,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> (Tensor, Tensor)

pub fn internal_has_compatible_shallow_copy_type(&self, from: &Tensor) -> bool

pub fn internal_index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Tensor

pub fn internal_index_put_impl_<T: Borrow<Tensor>>(
    &mut self,
    indices: &[Option<T>],
    values: &Tensor,
    accumulate: bool,
    unsafe_: bool
) -> Tensor

pub fn internal_indices(&self) -> Tensor

pub fn internal_inverse_helper(&self) -> Tensor

pub fn internal_linalg_inv_out_helper_(
    &mut self,
    infos_lu: &Tensor,
    infos_getri: &Tensor
) -> Tensor

pub fn internal_linalg_qr_helper(&self, mode: &str) -> (Tensor, Tensor)

pub fn internal_linalg_solve_out_helper_(
    &mut self,
    other: &Tensor,
    infos: &Tensor
) -> Tensor

pub fn internal_log_softmax(&self, dim: i64, half_to_float: bool) -> Tensor

pub fn internal_log_softmax_backward_data(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    dim: i64
) -> Tensor

pub fn internal_logcumsumexp(&self, dim: i64) -> Tensor

pub fn internal_logcumsumexp_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn internal_lu_with_info(
    &self,
    pivot: bool,
    check_errors: bool
) -> (Tensor, Tensor, Tensor)

pub fn internal_make_dual(
    primal: &Tensor,
    tangent: &Tensor,
    level: i64
) -> Tensor

pub fn internal_make_per_channel_quantized_tensor(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64
) -> Tensor

pub fn internal_make_per_tensor_quantized_tensor(
    &self,
    scale: f64,
    zero_point: i64
) -> Tensor

pub fn internal_masked_scale(&self, mask: &Tensor, scale: f64) -> Tensor

pub fn internal_mkldnn_reshape(&self, shape: &[i64]) -> Tensor

pub fn internal_mkldnn_transpose(&self, dim0: i64, dim1: i64) -> Tensor

pub fn internal_mkldnn_transpose_(&mut self, dim0: i64, dim1: i64) -> Tensor

pub fn internal_nnpack_available() -> bool

pub fn internal_nnpack_spatial_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64]
) -> Tensor

pub fn internal_nnpack_spatial_convolution_backward_input(
    &self,
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn internal_nnpack_spatial_convolution_backward_weight(
    &self,
    weightsize: &[i64],
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn internal_nnz(&self) -> i64

pub fn internal_pack_padded_sequence(
    &self,
    lengths: &Tensor,
    batch_first: bool
) -> (Tensor, Tensor)

pub fn internal_pack_padded_sequence_backward(
    grad: &Tensor,
    input_size: &[i64],
    batch_sizes: &Tensor,
    batch_first: bool
) -> Tensor

pub fn internal_pad_packed_sequence<S: Into<Scalar>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    batch_first: bool,
    padding_value: S,
    total_length: i64
) -> (Tensor, Tensor)

pub fn internal_pdist_backward(
    &self,
    grad: &Tensor,
    p: f64,
    pdist: &Tensor
) -> Tensor

pub fn internal_remove_batch_dim(
    &self,
    level: i64,
    batch_size: i64,
    out_dim: i64
) -> Tensor

pub fn internal_reshape_from_tensor(&self, shape: &Tensor) -> Tensor

pub fn internal_rowwise_prune(
    weight: &Tensor,
    mask: &Tensor,
    compressed_indices_dtype: Kind
) -> (Tensor, Tensor)

pub fn internal_s_where(&self, condition: &Tensor, other: &Tensor) -> Tensor

pub fn internal_sample_dirichlet(&self) -> Tensor

pub fn internal_saturate_weight_to_fp16(weight: &Tensor) -> Tensor

pub fn internal_shape_as_tensor(&self) -> Tensor

pub fn internal_sobol_engine_draw(
    quasi: &Tensor,
    n: i64,
    sobolstate: &Tensor,
    dimension: i64,
    num_generated: i64,
    dtype: Kind
) -> (Tensor, Tensor)

pub fn internal_sobol_engine_ff_(
    &mut self,
    n: i64,
    sobolstate: &Tensor,
    dimension: i64,
    num_generated: i64
) -> Tensor

pub fn internal_sobol_engine_initialize_state_(
    &mut self,
    dimension: i64
) -> Tensor

pub fn internal_sobol_engine_scramble_(
    &mut self,
    ltm: &Tensor,
    dimension: i64
) -> Tensor

pub fn internal_softmax(&self, dim: i64, half_to_float: bool) -> Tensor

pub fn internal_softmax_backward_data(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    dim: i64
) -> Tensor

pub fn internal_solve_helper(&self, a: &Tensor) -> (Tensor, Tensor)

pub fn internal_sparse_addmm(&self, sparse: &Tensor, dense: &Tensor) -> Tensor

pub fn internal_sparse_coo_tensor_unsafe(
    indices: &Tensor,
    values: &Tensor,
    size: &[i64],
    options: (Kind, Device)
) -> Tensor

pub fn internal_sparse_coo_tensor_with_dims(
    sparse_dim: i64,
    dense_dim: i64,
    size: &[i64],
    options: (Kind, Device)
) -> Tensor

pub fn internal_sparse_coo_tensor_with_dims_and_tensors(
    sparse_dim: i64,
    dense_dim: i64,
    size: &[i64],
    indices: &Tensor,
    values: &Tensor,
    options: (Kind, Device)
) -> Tensor

pub fn internal_sparse_csr_tensor(
    crow_indices: &Tensor,
    col_indices: &Tensor,
    values: &Tensor,
    options: (Kind, Device)
) -> Tensor

pub fn internal_sparse_csr_tensor_crow_col_value_size(
    crow_indices: &Tensor,
    col_indices: &Tensor,
    values: &Tensor,
    size: &[i64],
    options: (Kind, Device)
) -> Tensor

pub fn internal_sparse_log_softmax(
    &self,
    dim: i64,
    half_to_float: bool
) -> Tensor

pub fn internal_sparse_log_softmax_backward_data(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    dim: i64
) -> Tensor

pub fn internal_sparse_log_softmax_int(&self, dim: i64, dtype: Kind) -> Tensor

pub fn internal_sparse_mask_helper(tr: &Tensor, mask_indices: &Tensor) -> Tensor

pub fn internal_sparse_mm(sparse: &Tensor, dense: &Tensor) -> Tensor

pub fn internal_sparse_softmax(&self, dim: i64, half_to_float: bool) -> Tensor

pub fn internal_sparse_softmax_backward_data(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    dim: i64
) -> Tensor

pub fn internal_sparse_softmax_int(&self, dim: i64, dtype: Kind) -> Tensor

pub fn internal_sparse_sparse_matmul(&self, other: &Tensor) -> Tensor

pub fn internal_sparse_sum(&self) -> Tensor

pub fn internal_sparse_sum_backward(&self, grad: &Tensor, dim: &[i64]) -> Tensor

pub fn internal_sparse_sum_dim(&self, dim: &[i64]) -> Tensor

pub fn internal_sparse_sum_dim_dtype(&self, dim: &[i64], dtype: Kind) -> Tensor

pub fn internal_sparse_sum_dtype(&self, dtype: Kind) -> Tensor

pub fn internal_stack<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor

pub fn internal_stack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T],
    dim: i64
) -> Tensor

pub fn internal_standard_gamma(&self) -> Tensor

pub fn internal_standard_gamma_grad(&self, output: &Tensor) -> Tensor

pub fn internal_svd_helper(
    &self,
    some: bool,
    compute_uv: bool
) -> (Tensor, Tensor, Tensor)

pub fn internal_symeig_helper(
    &self,
    eigenvectors: bool,
    upper: bool
) -> (Tensor, Tensor)

pub fn internal_test_ambiguous_defaults(
    dummy: &Tensor,
    a: i64,
    b: i64
) -> Tensor

pub fn internal_test_ambiguous_defaults_b(
    dummy: &Tensor,
    a: i64,
    b: &str
) -> Tensor

pub fn internal_test_optional_filled_intlist<'a>(
    values: &Tensor,
    addends: impl Into<Option<&'a [i64]>>
) -> Tensor

pub fn internal_test_optional_floatlist(
    values: &Tensor,
    addends: &[f64]
) -> Tensor

pub fn internal_test_optional_intlist<'a>(
    values: &Tensor,
    addends: impl Into<Option<&'a [i64]>>
) -> Tensor

pub fn internal_test_serialization_subcmul(&self, other: &Tensor) -> Tensor

pub fn internal_test_string_default(dummy: &Tensor, a: &str, b: &str) -> Tensor

pub fn internal_trilinear(
    i1: &Tensor,
    i2: &Tensor,
    i3: &Tensor,
    expand1: &[i64],
    expand2: &[i64],
    expand3: &[i64],
    sumdim: &[i64],
    unroll_dim: i64
) -> Tensor

pub fn internal_unique(
    &self,
    sorted: bool,
    return_inverse: bool
) -> (Tensor, Tensor)

pub fn internal_unique2(
    &self,
    sorted: bool,
    return_inverse: bool,
    return_counts: bool
) -> (Tensor, Tensor, Tensor)

pub fn internal_unpack_dual(dual: &Tensor, level: i64) -> (Tensor, Tensor)

pub fn internal_unsafe_view(&self, size: &[i64]) -> Tensor

pub fn internal_use_cudnn_ctc_loss(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    blank: i64
) -> bool

pub fn internal_use_cudnn_rnn_flatten_weight() -> bool

pub fn internal_values(&self) -> Tensor

pub fn internal_version(&self) -> i64

pub fn internal_weight_norm(v: &Tensor, g: &Tensor, dim: i64) -> Tensor

pub fn internal_weight_norm_cuda_interface(
    v: &Tensor,
    g: &Tensor,
    dim: i64
) -> (Tensor, Tensor)

pub fn internal_weight_norm_cuda_interface_backward(
    grad_w: &Tensor,
    saved_v: &Tensor,
    saved_g: &Tensor,
    saved_norms: &Tensor,
    dim: i64
) -> (Tensor, Tensor)

pub fn internal_weight_norm_differentiable_backward(
    grad_w: &Tensor,
    saved_v: &Tensor,
    saved_g: &Tensor,
    saved_norms: &Tensor,
    dim: i64
) -> (Tensor, Tensor)

pub fn abs(&self) -> Tensor

pub fn abs_(&mut self) -> Tensor

pub fn abs_out(&self, out: &Tensor) -> Tensor

pub fn absolute(&self) -> Tensor

pub fn absolute_(&mut self) -> Tensor

pub fn absolute_out(&self, out: &Tensor) -> Tensor

pub fn acos(&self) -> Tensor

pub fn acos_(&mut self) -> Tensor

pub fn acos_out(&self, out: &Tensor) -> Tensor

pub fn acosh(&self) -> Tensor

pub fn acosh_(&mut self) -> Tensor

pub fn acosh_out(&self, out: &Tensor) -> Tensor

pub fn adaptive_avg_pool1d(&self, output_size: &[i64]) -> Tensor

pub fn adaptive_avg_pool2d(&self, output_size: &[i64]) -> Tensor

pub fn adaptive_avg_pool2d_out(
    &self,
    out: &Tensor,
    output_size: &[i64]
) -> Tensor

pub fn adaptive_avg_pool3d(&self, output_size: &[i64]) -> Tensor

pub fn adaptive_avg_pool3d_backward(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor
) -> Tensor

pub fn adaptive_avg_pool3d_out(
    &self,
    out: &Tensor,
    output_size: &[i64]
) -> Tensor

pub fn adaptive_max_pool1d(&self, output_size: &[i64]) -> (Tensor, Tensor)

pub fn adaptive_max_pool2d(&self, output_size: &[i64]) -> (Tensor, Tensor)

pub fn adaptive_max_pool2d_backward(
    &self,
    grad_output: &Tensor,
    indices: &Tensor
) -> Tensor

pub fn adaptive_max_pool2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    indices: &Tensor
) -> Tensor

pub fn adaptive_max_pool2d_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> (Tensor, Tensor)

pub fn adaptive_max_pool3d(&self, output_size: &[i64]) -> (Tensor, Tensor)

pub fn adaptive_max_pool3d_backward(
    &self,
    grad_output: &Tensor,
    indices: &Tensor
) -> Tensor

pub fn adaptive_max_pool3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    indices: &Tensor
) -> Tensor

pub fn adaptive_max_pool3d_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> (Tensor, Tensor)

pub fn g_add(&self, other: &Tensor) -> Tensor

pub fn g_add_(&mut self, other: &Tensor) -> Tensor

pub fn add_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn g_add_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_add_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn addbmm(&self, batch1: &Tensor, batch2: &Tensor) -> Tensor

pub fn addbmm_(&mut self, batch1: &Tensor, batch2: &Tensor) -> Tensor

pub fn addbmm_out(
    &self,
    out: &Tensor,
    batch1: &Tensor,
    batch2: &Tensor
) -> Tensor

pub fn addcdiv(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

pub fn addcdiv_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

pub fn addcdiv_out(
    &self,
    out: &Tensor,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Tensor

pub fn addcmul(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

pub fn addcmul_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

pub fn addcmul_out(
    &self,
    out: &Tensor,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Tensor

pub fn addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn addmm_(&mut self, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn addmm_out(&self, out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn addmv(&self, mat: &Tensor, vec: &Tensor) -> Tensor

pub fn addmv_(&mut self, mat: &Tensor, vec: &Tensor) -> Tensor

pub fn addmv_out(&self, out: &Tensor, mat: &Tensor, vec: &Tensor) -> Tensor

pub fn addr(&self, vec1: &Tensor, vec2: &Tensor) -> Tensor

pub fn addr_(&mut self, vec1: &Tensor, vec2: &Tensor) -> Tensor

pub fn addr_out(&self, out: &Tensor, vec1: &Tensor, vec2: &Tensor) -> Tensor

pub fn affine_grid_generator(
    theta: &Tensor,
    size: &[i64],
    align_corners: bool
) -> Tensor

pub fn affine_grid_generator_backward(
    grad: &Tensor,
    size: &[i64],
    align_corners: bool
) -> Tensor

pub fn alias(&self) -> Tensor

pub fn align_as(&self, other: &Tensor) -> Tensor

pub fn align_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn all(&self) -> Tensor

pub fn all_dim(&self, dim: i64, keepdim: bool) -> Tensor

pub fn all_out(&self, out: &Tensor, dim: i64, keepdim: bool) -> Tensor

pub fn allclose(
    &self,
    other: &Tensor,
    rtol: f64,
    atol: f64,
    equal_nan: bool
) -> bool

pub fn alpha_dropout(&self, p: f64, train: bool) -> Tensor

pub fn alpha_dropout_(&mut self, p: f64, train: bool) -> Tensor

pub fn amax(&self, dim: &[i64], keepdim: bool) -> Tensor

pub fn amax_out(&self, out: &Tensor, dim: &[i64], keepdim: bool) -> Tensor

pub fn amin(&self, dim: &[i64], keepdim: bool) -> Tensor

pub fn amin_out(&self, out: &Tensor, dim: &[i64], keepdim: bool) -> Tensor

pub fn angle(&self) -> Tensor

pub fn angle_out(&self, out: &Tensor) -> Tensor

pub fn any(&self) -> Tensor

pub fn any_dim(&self, dim: i64, keepdim: bool) -> Tensor

pub fn any_out(&self, out: &Tensor, dim: i64, keepdim: bool) -> Tensor

pub fn arange<S: Into<Scalar>>(end: S, options: (Kind, Device)) -> Tensor

pub fn arange_out<S: Into<Scalar>>(out: &Tensor, end: S) -> Tensor

pub fn arange_start<S: Into<Scalar>>(
    start: S,
    end: S,
    options: (Kind, Device)
) -> Tensor

pub fn arange_start_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S
) -> Tensor

pub fn arange_start_step<S: Into<Scalar>>(
    start: S,
    end: S,
    step: S,
    options: (Kind, Device)
) -> Tensor

pub fn arccos(&self) -> Tensor

pub fn arccos_(&mut self) -> Tensor

pub fn arccos_out(&self, out: &Tensor) -> Tensor

pub fn arccosh(&self) -> Tensor

pub fn arccosh_(&mut self) -> Tensor

pub fn arccosh_out(&self, out: &Tensor) -> Tensor

pub fn arcsin(&self) -> Tensor

pub fn arcsin_(&mut self) -> Tensor

pub fn arcsin_out(&self, out: &Tensor) -> Tensor

pub fn arcsinh(&self) -> Tensor

pub fn arcsinh_(&mut self) -> Tensor

pub fn arcsinh_out(&self, out: &Tensor) -> Tensor

pub fn arctan(&self) -> Tensor

pub fn arctan_(&mut self) -> Tensor

pub fn arctan_out(&self, out: &Tensor) -> Tensor

pub fn arctanh(&self) -> Tensor

pub fn arctanh_(&mut self) -> Tensor

pub fn arctanh_out(&self, out: &Tensor) -> Tensor

pub fn argmax(&self, dim: impl Into<Option<i64>>, keepdim: bool) -> Tensor

pub fn argmax_out(
    &self,
    out: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn argmin(&self, dim: impl Into<Option<i64>>, keepdim: bool) -> Tensor

pub fn argmin_out(
    &self,
    out: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn argsort(&self, dim: i64, descending: bool) -> Tensor

pub fn as_strided(
    &self,
    size: &[i64],
    stride: &[i64],
    storage_offset: impl Into<Option<i64>>
) -> Tensor

pub fn as_strided_(
    &mut self,
    size: &[i64],
    stride: &[i64],
    storage_offset: impl Into<Option<i64>>
) -> Tensor

pub fn asin(&self) -> Tensor

pub fn asin_(&mut self) -> Tensor

pub fn asin_out(&self, out: &Tensor) -> Tensor

pub fn asinh(&self) -> Tensor

pub fn asinh_(&mut self) -> Tensor

pub fn asinh_out(&self, out: &Tensor) -> Tensor

pub fn atan(&self) -> Tensor

pub fn atan2(&self, other: &Tensor) -> Tensor

pub fn atan2_(&mut self, other: &Tensor) -> Tensor

pub fn atan2_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn atan_(&mut self) -> Tensor

pub fn atan_out(&self, out: &Tensor) -> Tensor

pub fn atanh(&self) -> Tensor

pub fn atanh_(&mut self) -> Tensor

pub fn atanh_out(&self, out: &Tensor) -> Tensor

pub fn atleast_1d(&self) -> Tensor

pub fn atleast_1d_sequence<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn atleast_2d(&self) -> Tensor

pub fn atleast_2d_sequence<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn atleast_3d(&self) -> Tensor

pub fn atleast_3d_sequence<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn avg_pool1d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool
) -> Tensor

pub fn avg_pool2d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Tensor

pub fn avg_pool2d_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Tensor

pub fn avg_pool2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Tensor

pub fn avg_pool2d_out(
    &self,
    out: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Tensor

pub fn avg_pool3d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Tensor

pub fn avg_pool3d_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Tensor

pub fn avg_pool3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Tensor

pub fn avg_pool3d_out(
    &self,
    out: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    ceil_mode: bool,
    count_include_pad: bool,
    divisor_override: impl Into<Option<i64>>
) -> Tensor

pub fn baddbmm(&self, batch1: &Tensor, batch2: &Tensor) -> Tensor

pub fn baddbmm_(&mut self, batch1: &Tensor, batch2: &Tensor) -> Tensor

pub fn baddbmm_out(
    &self,
    out: &Tensor,
    batch1: &Tensor,
    batch2: &Tensor
) -> Tensor

pub fn bartlett_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn bartlett_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Tensor

pub fn batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    momentum: f64,
    eps: f64,
    cudnn_enabled: bool
) -> Tensor

pub fn batch_norm_backward_elemt<T: Borrow<Tensor>>(
    &self,
    grad_out: &Tensor,
    mean: &Tensor,
    invstd: &Tensor,
    weight: Option<T>,
    mean_dy: &Tensor,
    mean_dy_xmu: &Tensor,
    count: &Tensor
) -> Tensor

pub fn batch_norm_backward_reduce<T: Borrow<Tensor>>(
    &self,
    grad_out: &Tensor,
    mean: &Tensor,
    invstd: &Tensor,
    weight: Option<T>,
    input_g: bool,
    weight_g: bool,
    bias_g: bool
) -> (Tensor, Tensor, Tensor, Tensor)

pub fn batch_norm_elemt<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    mean: &Tensor,
    invstd: &Tensor,
    eps: f64
) -> Tensor

pub fn batch_norm_elemt_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    weight: Option<T>,
    bias: Option<T>,
    mean: &Tensor,
    invstd: &Tensor,
    eps: f64
) -> Tensor

pub fn batch_norm_gather_stats<T: Borrow<Tensor>>(
    &self,
    mean: &Tensor,
    invstd: &Tensor,
    running_mean: Option<T>,
    running_var: Option<T>,
    momentum: f64,
    eps: f64,
    count: i64
) -> (Tensor, Tensor)

pub fn batch_norm_gather_stats_with_counts<T: Borrow<Tensor>>(
    &self,
    mean: &Tensor,
    invstd: &Tensor,
    running_mean: Option<T>,
    running_var: Option<T>,
    momentum: f64,
    eps: f64,
    counts: &Tensor
) -> (Tensor, Tensor)

pub fn batch_norm_stats(&self, eps: f64) -> (Tensor, Tensor)

pub fn batch_norm_update_stats<T: Borrow<Tensor>>(
    &self,
    running_mean: Option<T>,
    running_var: Option<T>,
    momentum: f64
) -> (Tensor, Tensor)

pub fn bernoulli(&self) -> Tensor

pub fn bernoulli_(&mut self, p: &Tensor) -> Tensor

pub fn bernoulli_float_(&mut self, p: f64) -> Tensor

pub fn bernoulli_out(&self, out: &Tensor) -> Tensor

pub fn bernoulli_p(&self, p: f64) -> Tensor

pub fn bilinear<T: Borrow<Tensor>>(
    input1: &Tensor,
    input2: &Tensor,
    weight: &Tensor,
    bias: Option<T>
) -> Tensor

pub fn binary_cross_entropy<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction
) -> Tensor

pub fn binary_cross_entropy_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction
) -> Tensor

pub fn binary_cross_entropy_backward_grad_input<T: Borrow<Tensor>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction
) -> Tensor

pub fn binary_cross_entropy_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction
) -> Tensor

pub fn binary_cross_entropy_with_logits<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    pos_weight: Option<T>,
    reduction: Reduction
) -> Tensor

pub fn binary_cross_entropy_with_logits_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    pos_weight: Option<T>,
    reduction: Reduction
) -> Tensor

pub fn bincount<T: Borrow<Tensor>>(
    &self,
    weights: Option<T>,
    minlength: i64
) -> Tensor

pub fn binomial(count: &Tensor, prob: &Tensor) -> Tensor

pub fn bitwise_and<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn bitwise_and_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn bitwise_and_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn bitwise_and_tensor(&self, other: &Tensor) -> Tensor

pub fn bitwise_and_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_and_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn bitwise_not(&self) -> Tensor

pub fn bitwise_not_(&mut self) -> Tensor

pub fn bitwise_not_out(&self, out: &Tensor) -> Tensor

pub fn bitwise_or<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn bitwise_or_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn bitwise_or_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn bitwise_or_tensor(&self, other: &Tensor) -> Tensor

pub fn bitwise_or_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_or_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn bitwise_xor<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn bitwise_xor_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn bitwise_xor_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn bitwise_xor_tensor(&self, other: &Tensor) -> Tensor

pub fn bitwise_xor_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_xor_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn blackman_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn blackman_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Tensor

pub fn block_diag<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn bmm(&self, mat2: &Tensor) -> Tensor

pub fn bmm_out(&self, out: &Tensor, mat2: &Tensor) -> Tensor

pub fn broadcast_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn broadcast_to(&self, size: &[i64]) -> Tensor

pub fn bucketize(
    &self,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Tensor

pub fn bucketize_scalar<S: Into<Scalar>>(
    self_scalar: S,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Tensor

pub fn bucketize_tensor_out(
    &self,
    out: &Tensor,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Tensor

pub fn can_cast(from: Kind, to: Kind) -> bool

pub fn cartesian_prod<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn cat<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor

pub fn cat_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T],
    dim: i64
) -> Tensor

pub fn cauchy_(&mut self, median: f64, sigma: f64) -> Tensor

pub fn cdist(
    x1: &Tensor,
    x2: &Tensor,
    p: f64,
    compute_mode: impl Into<Option<i64>>
) -> Tensor

pub fn ceil(&self) -> Tensor

pub fn ceil_(&mut self) -> Tensor

pub fn ceil_out(&self, out: &Tensor) -> Tensor

pub fn celu(&self) -> Tensor

pub fn celu_(&mut self) -> Tensor

pub fn chain_matmul<T: Borrow<Tensor>>(matrices: &[T]) -> Tensor

pub fn chain_matmul_out<T: Borrow<Tensor>>(
    out: &Tensor,
    matrices: &[T]
) -> Tensor

pub fn channel_shuffle(&self, groups: i64) -> Tensor

pub fn cholesky(&self, upper: bool) -> Tensor

pub fn cholesky_inverse(&self, upper: bool) -> Tensor

pub fn cholesky_inverse_out(&self, out: &Tensor, upper: bool) -> Tensor

pub fn cholesky_out(&self, out: &Tensor, upper: bool) -> Tensor

pub fn cholesky_solve(&self, input2: &Tensor, upper: bool) -> Tensor

pub fn cholesky_solve_out(
    &self,
    out: &Tensor,
    input2: &Tensor,
    upper: bool
) -> Tensor

pub fn choose_qparams_optimized(
    &self,
    numel: i64,
    n_bins: i64,
    ratio: f64,
    bit_width: i64
) -> (Tensor, Tensor)

pub fn chunk(&self, chunks: i64, dim: i64) -> Vec<Tensor>

pub fn clamp<S: Into<Scalar>>(&self, min: S, max: S) -> Tensor

pub fn clamp_<S: Into<Scalar>>(&mut self, min: S, max: S) -> Tensor

pub fn clamp_max<S: Into<Scalar>>(&self, max: S) -> Tensor

pub fn clamp_max_<S: Into<Scalar>>(&mut self, max: S) -> Tensor

pub fn clamp_max_out<S: Into<Scalar>>(&self, out: &Tensor, max: S) -> Tensor

pub fn clamp_max_tensor(&self, max: &Tensor) -> Tensor

pub fn clamp_max_tensor_(&mut self, max: &Tensor) -> Tensor

pub fn clamp_max_tensor_out(&self, out: &Tensor, max: &Tensor) -> Tensor

pub fn clamp_min<S: Into<Scalar>>(&self, min: S) -> Tensor

pub fn clamp_min_<S: Into<Scalar>>(&mut self, min: S) -> Tensor

pub fn clamp_min_out<S: Into<Scalar>>(&self, out: &Tensor, min: S) -> Tensor

pub fn clamp_min_tensor(&self, min: &Tensor) -> Tensor

pub fn clamp_min_tensor_(&mut self, min: &Tensor) -> Tensor

pub fn clamp_min_tensor_out(&self, out: &Tensor, min: &Tensor) -> Tensor

pub fn clamp_out<S: Into<Scalar>>(&self, out: &Tensor, min: S, max: S) -> Tensor

pub fn clamp_tensor<T: Borrow<Tensor>>(
    &self,
    min: Option<T>,
    max: Option<T>
) -> Tensor

pub fn clamp_tensor_<T: Borrow<Tensor>>(
    &mut self,
    min: Option<T>,
    max: Option<T>
) -> Tensor

pub fn clamp_tensor_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    min: Option<T>,
    max: Option<T>
) -> Tensor

pub fn clip<S: Into<Scalar>>(&self, min: S, max: S) -> Tensor

pub fn clip_<S: Into<Scalar>>(&mut self, min: S, max: S) -> Tensor

pub fn clip_out<S: Into<Scalar>>(&self, out: &Tensor, min: S, max: S) -> Tensor

pub fn clip_tensor<T: Borrow<Tensor>>(
    &self,
    min: Option<T>,
    max: Option<T>
) -> Tensor

pub fn clip_tensor_<T: Borrow<Tensor>>(
    &mut self,
    min: Option<T>,
    max: Option<T>
) -> Tensor

pub fn clip_tensor_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    min: Option<T>,
    max: Option<T>
) -> Tensor

pub fn coalesce(&self) -> Tensor

pub fn col2im(
    &self,
    output_size: &[i64],
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Tensor

pub fn col2im_backward(
    grad_output: &Tensor,
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Tensor

pub fn col2im_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Tensor

pub fn col2im_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Tensor

pub fn col_indices(&self) -> Tensor

pub fn column_stack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn column_stack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T]
) -> Tensor

pub fn combinations(&self, r: i64, with_replacement: bool) -> Tensor

pub fn complex(real: &Tensor, imag: &Tensor) -> Tensor

pub fn complex_out(out: &Tensor, real: &Tensor, imag: &Tensor) -> Tensor

pub fn conj(&self) -> Tensor

pub fn conj_out(&self, out: &Tensor) -> Tensor

pub fn constant_pad_nd(&self, pad: &[i64]) -> Tensor

pub fn contiguous(&self) -> Tensor

pub fn conv1d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn conv1d_padding<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &str,
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn conv2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn conv2d_padding<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &str,
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn conv3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn conv3d_padding<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &str,
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn conv_depthwise3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64]
) -> Tensor

pub fn conv_depthwise3d_backward(
    &self,
    grad_input: &Tensor,
    grad_weight: &Tensor,
    grad_bias: &Tensor,
    grad_output: &Tensor,
    weight: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64]
) -> (Tensor, Tensor, Tensor)

pub fn conv_tbc(&self, weight: &Tensor, bias: &Tensor, pad: i64) -> Tensor

pub fn conv_tbc_backward(
    &self,
    input: &Tensor,
    weight: &Tensor,
    bias: &Tensor,
    pad: i64
) -> (Tensor, Tensor, Tensor)

pub fn conv_transpose1d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    groups: i64,
    dilation: &[i64]
) -> Tensor

pub fn conv_transpose2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    groups: i64,
    dilation: &[i64]
) -> Tensor

pub fn conv_transpose3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    groups: i64,
    dilation: &[i64]
) -> Tensor

pub fn convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64],
    groups: i64
) -> Tensor

pub fn convolution_overrideable<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    transposed: bool,
    output_padding: &[i64],
    groups: i64
) -> Tensor

pub fn copy_sparse_to_sparse_(
    &mut self,
    src: &Tensor,
    non_blocking: bool
) -> Tensor

pub fn copysign(&self, other: &Tensor) -> Tensor

pub fn copysign_(&mut self, other: &Tensor) -> Tensor

pub fn copysign_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn copysign_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn copysign_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn copysign_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn cos(&self) -> Tensor

pub fn cos_(&mut self) -> Tensor

pub fn cos_out(&self, out: &Tensor) -> Tensor

pub fn cosh(&self) -> Tensor

pub fn cosh_(&mut self) -> Tensor

pub fn cosh_out(&self, out: &Tensor) -> Tensor

pub fn cosine_embedding_loss(
    input1: &Tensor,
    input2: &Tensor,
    target: &Tensor,
    margin: f64,
    reduction: Reduction
) -> Tensor

pub fn cosine_similarity(x1: &Tensor, x2: &Tensor, dim: i64, eps: f64) -> Tensor

pub fn count_nonzero(&self, dim: impl Into<Option<i64>>) -> Tensor

pub fn count_nonzero_dim_intlist(&self, dim: &[i64]) -> Tensor

pub fn cross(&self, other: &Tensor, dim: impl Into<Option<i64>>) -> Tensor

pub fn cross_entropy_loss<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Tensor

pub fn cross_out(
    &self,
    out: &Tensor,
    other: &Tensor,
    dim: impl Into<Option<i64>>
) -> Tensor

pub fn crow_indices(&self) -> Tensor

pub fn ctc_loss(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &[i64],
    target_lengths: &[i64],
    blank: i64,
    reduction: Reduction,
    zero_infinity: bool
) -> Tensor

pub fn ctc_loss_tensor(
    log_probs: &Tensor,
    targets: &Tensor,
    input_lengths: &Tensor,
    target_lengths: &Tensor,
    blank: i64,
    reduction: Reduction,
    zero_infinity: bool
) -> Tensor

pub fn cudnn_affine_grid_generator(
    theta: &Tensor,
    n: i64,
    c: i64,
    h: i64,
    w: i64
) -> Tensor

pub fn cudnn_affine_grid_generator_backward(
    grad: &Tensor,
    n: i64,
    c: i64,
    h: i64,
    w: i64
) -> Tensor

pub fn cudnn_batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    exponential_average_factor: f64,
    epsilon: f64
) -> (Tensor, Tensor, Tensor, Tensor)

pub fn cudnn_batch_norm_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    weight: &Tensor,
    running_mean: Option<T>,
    running_var: Option<T>,
    save_mean: Option<T>,
    save_var: Option<T>,
    epsilon: f64,
    reservespace: &Tensor
) -> (Tensor, Tensor, Tensor)

pub fn cudnn_convolution(
    &self,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Tensor

pub fn cudnn_convolution_add_relu<T: Borrow<Tensor>, S: Into<Scalar>>(
    &self,
    weight: &Tensor,
    z: &Tensor,
    alpha: S,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn cudnn_convolution_backward_input(
    self_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Tensor

pub fn cudnn_convolution_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Tensor

pub fn cudnn_convolution_deprecated<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn cudnn_convolution_deprecated2(
    &self,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn cudnn_convolution_relu<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn cudnn_convolution_transpose(
    &self,
    weight: &Tensor,
    padding: &[i64],
    output_padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Tensor

pub fn cudnn_convolution_transpose_backward_input(
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Tensor

pub fn cudnn_convolution_transpose_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool,
    allow_tf32: bool
) -> Tensor

pub fn cudnn_convolution_transpose_deprecated<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    output_padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn cudnn_convolution_transpose_deprecated2(
    &self,
    weight: &Tensor,
    padding: &[i64],
    output_padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn cudnn_grid_sampler(&self, grid: &Tensor) -> Tensor

pub fn cudnn_grid_sampler_backward(
    &self,
    grid: &Tensor,
    grad_output: &Tensor
) -> (Tensor, Tensor)

pub fn cudnn_is_acceptable(&self) -> bool

pub fn cummax(&self, dim: i64) -> (Tensor, Tensor)

pub fn cummax_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64
) -> (Tensor, Tensor)

pub fn cummaxmin_backward(
    &self,
    grad: &Tensor,
    indices: &Tensor,
    dim: i64
) -> Tensor

pub fn cummin(&self, dim: i64) -> (Tensor, Tensor)

pub fn cummin_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64
) -> (Tensor, Tensor)

pub fn cumprod(&self, dim: i64, dtype: Kind) -> Tensor

pub fn cumprod_(&mut self, dim: i64, dtype: Kind) -> Tensor

pub fn cumprod_backward(
    &self,
    grad: &Tensor,
    dim: i64,
    output: &Tensor
) -> Tensor

pub fn cumprod_out(&self, out: &Tensor, dim: i64, dtype: Kind) -> Tensor

pub fn cumsum(&self, dim: i64, dtype: Kind) -> Tensor

pub fn cumsum_(&mut self, dim: i64, dtype: Kind) -> Tensor

pub fn cumsum_out(&self, out: &Tensor, dim: i64, dtype: Kind) -> Tensor

pub fn data(&self) -> Tensor

pub fn deg2rad(&self) -> Tensor

pub fn deg2rad_(&mut self) -> Tensor

pub fn deg2rad_out(&self, out: &Tensor) -> Tensor

pub fn dense_dim(&self) -> i64

pub fn dequantize(&self) -> Tensor

pub fn dequantize_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn det(&self) -> Tensor

pub fn detach(&self) -> Tensor

pub fn detach_(&mut self) -> Tensor

pub fn diag(&self, diagonal: i64) -> Tensor

pub fn diag_backward(
    grad: &Tensor,
    input_sizes: &[i64],
    diagonal: i64
) -> Tensor

pub fn diag_embed(&self, offset: i64, dim1: i64, dim2: i64) -> Tensor

pub fn diag_out(&self, out: &Tensor, diagonal: i64) -> Tensor

pub fn diagflat(&self, offset: i64) -> Tensor

pub fn diagonal(&self, offset: i64, dim1: i64, dim2: i64) -> Tensor

pub fn diagonal_backward(
    grad: &Tensor,
    input_sizes: &[i64],
    offset: i64,
    dim1: i64,
    dim2: i64
) -> Tensor

pub fn diff<T: Borrow<Tensor>>(
    &self,
    n: i64,
    dim: i64,
    prepend: Option<T>,
    append: Option<T>
) -> Tensor

pub fn diff_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    n: i64,
    dim: i64,
    prepend: Option<T>,
    append: Option<T>
) -> Tensor

pub fn digamma(&self) -> Tensor

pub fn digamma_(&mut self) -> Tensor

pub fn digamma_out(&self, out: &Tensor) -> Tensor

pub fn dist(&self, other: &Tensor) -> Tensor

pub fn g_div(&self, other: &Tensor) -> Tensor

pub fn g_div_(&mut self, other: &Tensor) -> Tensor

pub fn div_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn div_out_mode(
    &self,
    out: &Tensor,
    other: &Tensor,
    rounding_mode: &str
) -> Tensor

pub fn g_div_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_div_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn g_div_scalar_mode<S: Into<Scalar>>(
    &self,
    other: S,
    rounding_mode: &str
) -> Tensor

pub fn g_div_scalar_mode_<S: Into<Scalar>>(
    &mut self,
    other: S,
    rounding_mode: &str
) -> Tensor

pub fn g_div_tensor_mode(&self, other: &Tensor, rounding_mode: &str) -> Tensor

pub fn g_div_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Tensor

pub fn divide(&self, other: &Tensor) -> Tensor

pub fn divide_(&mut self, other: &Tensor) -> Tensor

pub fn divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn divide_out_mode(
    &self,
    out: &Tensor,
    other: &Tensor,
    rounding_mode: &str
) -> Tensor

pub fn divide_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn divide_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn divide_scalar_mode<S: Into<Scalar>>(
    &self,
    other: S,
    rounding_mode: &str
) -> Tensor

pub fn divide_scalar_mode_<S: Into<Scalar>>(
    &mut self,
    other: S,
    rounding_mode: &str
) -> Tensor

pub fn divide_tensor_mode(&self, other: &Tensor, rounding_mode: &str) -> Tensor

pub fn divide_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Tensor

pub fn dot(&self, tensor: &Tensor) -> Tensor

pub fn dot_out(&self, out: &Tensor, tensor: &Tensor) -> Tensor

pub fn dropout(&self, p: f64, train: bool) -> Tensor

pub fn dropout_(&mut self, p: f64, train: bool) -> Tensor

pub fn dsplit(&self, sections: i64) -> Vec<Tensor>

pub fn dsplit_array(&self, indices: &[i64]) -> Vec<Tensor>

pub fn dstack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn dstack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor

pub fn eig(&self, eigenvectors: bool) -> (Tensor, Tensor)

pub fn eig_e(
    &self,
    e: &Tensor,
    v: &Tensor,
    eigenvectors: bool
) -> (Tensor, Tensor)

pub fn einsum<T: Borrow<Tensor>>(equation: &str, tensors: &[T]) -> Tensor

pub fn elu(&self) -> Tensor

pub fn elu_(&mut self) -> Tensor

pub fn elu_backward<S: Into<Scalar>>(
    grad_output: &Tensor,
    alpha: S,
    scale: S,
    input_scale: S,
    is_result: bool,
    self_or_result: &Tensor
) -> Tensor

pub fn elu_out(&self, out: &Tensor) -> Tensor

pub fn embedding(
    weight: &Tensor,
    indices: &Tensor,
    padding_idx: i64,
    scale_grad_by_freq: bool,
    sparse: bool
) -> Tensor

pub fn embedding_backward(
    grad: &Tensor,
    indices: &Tensor,
    num_weights: i64,
    padding_idx: i64,
    scale_grad_by_freq: bool,
    sparse: bool
) -> Tensor

pub fn embedding_bag<T: Borrow<Tensor>>(
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    include_last_offset: bool
) -> (Tensor, Tensor, Tensor, Tensor)

pub fn embedding_bag_padding_idx<T: Borrow<Tensor>>(
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    scale_grad_by_freq: bool,
    mode: i64,
    sparse: bool,
    per_sample_weights: Option<T>,
    include_last_offset: bool,
    padding_idx: impl Into<Option<i64>>
) -> (Tensor, Tensor, Tensor, Tensor)

pub fn embedding_dense_backward(
    grad_output: &Tensor,
    indices: &Tensor,
    num_weights: i64,
    padding_idx: i64,
    scale_grad_by_freq: bool
) -> Tensor

pub fn embedding_renorm_(
    &mut self,
    indices: &Tensor,
    max_norm: f64,
    norm_type: f64
) -> Tensor

pub fn embedding_sparse_backward(
    grad: &Tensor,
    indices: &Tensor,
    num_weights: i64,
    padding_idx: i64,
    scale_grad_by_freq: bool
) -> Tensor

pub fn empty(size: &[i64], options: (Kind, Device)) -> Tensor

pub fn empty_like(&self) -> Tensor

pub fn empty_out(out: &Tensor, size: &[i64]) -> Tensor

pub fn empty_quantized(size: &[i64], qtensor: &Tensor) -> Tensor

pub fn empty_strided(
    size: &[i64],
    stride: &[i64],
    options: (Kind, Device)
) -> Tensor

pub fn eq<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn eq_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn eq_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn eq_tensor(&self, other: &Tensor) -> Tensor

pub fn eq_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn eq_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn equal(&self, other: &Tensor) -> bool

pub fn erf(&self) -> Tensor

pub fn erf_(&mut self) -> Tensor

pub fn erf_out(&self, out: &Tensor) -> Tensor

pub fn erfc(&self) -> Tensor

pub fn erfc_(&mut self) -> Tensor

pub fn erfc_out(&self, out: &Tensor) -> Tensor

pub fn erfinv(&self) -> Tensor

pub fn erfinv_(&mut self) -> Tensor

pub fn erfinv_out(&self, out: &Tensor) -> Tensor

pub fn exp(&self) -> Tensor

pub fn exp2(&self) -> Tensor

pub fn exp2_(&mut self) -> Tensor

pub fn exp2_out(&self, out: &Tensor) -> Tensor

pub fn exp_(&mut self) -> Tensor

pub fn exp_out(&self, out: &Tensor) -> Tensor

pub fn expand(&self, size: &[i64], implicit: bool) -> Tensor

pub fn expand_as(&self, other: &Tensor) -> Tensor

pub fn expm1(&self) -> Tensor

pub fn expm1_(&mut self) -> Tensor

pub fn expm1_out(&self, out: &Tensor) -> Tensor

pub fn exponential_(&mut self, lambd: f64) -> Tensor

pub fn eye(n: i64, options: (Kind, Device)) -> Tensor

pub fn eye_m(n: i64, m: i64, options: (Kind, Device)) -> Tensor

pub fn eye_m_out(out: &Tensor, n: i64, m: i64) -> Tensor

pub fn eye_out(out: &Tensor, n: i64) -> Tensor

pub fn fake_quantize_per_channel_affine(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64
) -> Tensor

pub fn fake_quantize_per_channel_affine_cachemask(
    &self,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64
) -> (Tensor, Tensor)

pub fn fake_quantize_per_channel_affine_cachemask_backward(
    grad: &Tensor,
    mask: &Tensor
) -> Tensor

pub fn fake_quantize_per_tensor_affine(
    &self,
    scale: f64,
    zero_point: i64,
    quant_min: i64,
    quant_max: i64
) -> Tensor

pub fn fake_quantize_per_tensor_affine_cachemask(
    &self,
    scale: f64,
    zero_point: i64,
    quant_min: i64,
    quant_max: i64
) -> (Tensor, Tensor)

pub fn fake_quantize_per_tensor_affine_cachemask_backward(
    grad: &Tensor,
    mask: &Tensor
) -> Tensor

pub fn fbgemm_linear_fp16_weight(
    &self,
    packed_weight: &Tensor,
    bias: &Tensor
) -> Tensor

pub fn fbgemm_linear_fp16_weight_fp32_activation(
    &self,
    packed_weight: &Tensor,
    bias: &Tensor
) -> Tensor

pub fn fbgemm_linear_int8_weight<S: Into<Scalar>>(
    &self,
    weight: &Tensor,
    packed: &Tensor,
    col_offsets: &Tensor,
    weight_scale: S,
    weight_zero_point: S,
    bias: &Tensor
) -> Tensor

pub fn fbgemm_linear_int8_weight_fp32_activation<S: Into<Scalar>>(
    &self,
    weight: &Tensor,
    packed: &Tensor,
    col_offsets: &Tensor,
    weight_scale: S,
    weight_zero_point: S,
    bias: &Tensor
) -> Tensor

pub fn fbgemm_pack_gemm_matrix_fp16(&self) -> Tensor

pub fn fbgemm_pack_quantized_matrix(&self) -> Tensor

pub fn fbgemm_pack_quantized_matrix_kn(&self, k: i64, n: i64) -> Tensor

pub fn feature_alpha_dropout(&self, p: f64, train: bool) -> Tensor

pub fn feature_alpha_dropout_(&mut self, p: f64, train: bool) -> Tensor

pub fn feature_dropout(&self, p: f64, train: bool) -> Tensor

pub fn feature_dropout_(&mut self, p: f64, train: bool) -> Tensor

pub fn fft_fft(&self, n: impl Into<Option<i64>>, dim: i64, norm: &str) -> Tensor

pub fn fft_fft2<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Tensor

pub fn fft_fft2_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Tensor

pub fn fft_fft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_fftfreq(n: i64, d: f64, options: (Kind, Device)) -> Tensor

pub fn fft_fftfreq_out(out: &Tensor, n: i64, d: f64) -> Tensor

pub fn fft_fftn<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Tensor

pub fn fft_fftn_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Tensor

pub fn fft_fftshift<'a>(&self, dim: impl Into<Option<&'a [i64]>>) -> Tensor

pub fn fft_hfft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_hfft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_ifft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_ifft2<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Tensor

pub fn fft_ifft2_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Tensor

pub fn fft_ifft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_ifftn<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Tensor

pub fn fft_ifftn_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Tensor

pub fn fft_ifftshift<'a>(&self, dim: impl Into<Option<&'a [i64]>>) -> Tensor

pub fn fft_ihfft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_ihfft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_irfft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_irfft2<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Tensor

pub fn fft_irfft2_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Tensor

pub fn fft_irfft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_irfftn<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Tensor

pub fn fft_irfftn_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Tensor

pub fn fft_rfft(
    &self,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_rfft2<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Tensor

pub fn fft_rfft2_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: &[i64],
    norm: &str
) -> Tensor

pub fn fft_rfft_out(
    &self,
    out: &Tensor,
    n: impl Into<Option<i64>>,
    dim: i64,
    norm: &str
) -> Tensor

pub fn fft_rfftfreq(n: i64, d: f64, options: (Kind, Device)) -> Tensor

pub fn fft_rfftfreq_out(out: &Tensor, n: i64, d: f64) -> Tensor

pub fn fft_rfftn<'a>(
    &self,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Tensor

pub fn fft_rfftn_out<'a>(
    &self,
    out: &Tensor,
    s: impl Into<Option<&'a [i64]>>,
    dim: impl Into<Option<&'a [i64]>>,
    norm: &str
) -> Tensor

pub fn fill_<S: Into<Scalar>>(&mut self, value: S) -> Tensor

pub fn fill_diagonal_<S: Into<Scalar>>(
    &mut self,
    fill_value: S,
    wrap: bool
) -> Tensor

pub fn fill_tensor_(&mut self, value: &Tensor) -> Tensor

pub fn fix(&self) -> Tensor

pub fn fix_(&mut self) -> Tensor

pub fn fix_out(&self, out: &Tensor) -> Tensor

pub fn flatten(&self, start_dim: i64, end_dim: i64) -> Tensor

pub fn flatten_dense_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn flip(&self, dims: &[i64]) -> Tensor

pub fn fliplr(&self) -> Tensor

pub fn flipud(&self) -> Tensor

pub fn float_power(&self, exponent: &Tensor) -> Tensor

pub fn float_power_<S: Into<Scalar>>(&mut self, exponent: S) -> Tensor

pub fn float_power_scalar<S: Into<Scalar>>(
    self_scalar: S,
    exponent: &Tensor
) -> Tensor

pub fn float_power_scalar_out<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    exponent: &Tensor
) -> Tensor

pub fn float_power_tensor_(&mut self, exponent: &Tensor) -> Tensor

pub fn float_power_tensor_scalar<S: Into<Scalar>>(&self, exponent: S) -> Tensor

pub fn float_power_tensor_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    exponent: S
) -> Tensor

pub fn float_power_tensor_tensor_out(
    &self,
    out: &Tensor,
    exponent: &Tensor
) -> Tensor

pub fn floor(&self) -> Tensor

pub fn floor_(&mut self) -> Tensor

pub fn floor_divide(&self, other: &Tensor) -> Tensor

pub fn floor_divide_(&mut self, other: &Tensor) -> Tensor

pub fn floor_divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn floor_divide_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn floor_divide_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn floor_out(&self, out: &Tensor) -> Tensor

pub fn fmax(&self, other: &Tensor) -> Tensor

pub fn fmax_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn fmin(&self, other: &Tensor) -> Tensor

pub fn fmin_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn fmod<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn fmod_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn fmod_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn fmod_tensor(&self, other: &Tensor) -> Tensor

pub fn fmod_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn fmod_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn frac(&self) -> Tensor

pub fn frac_(&mut self) -> Tensor

pub fn frac_out(&self, out: &Tensor) -> Tensor

pub fn fractional_max_pool2d(
    &self,
    kernel_size: &[i64],
    output_size: &[i64],
    random_samples: &Tensor
) -> (Tensor, Tensor)

pub fn fractional_max_pool2d_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Tensor

pub fn fractional_max_pool2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Tensor

pub fn fractional_max_pool2d_output(
    &self,
    output: &Tensor,
    indices: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    random_samples: &Tensor
) -> (Tensor, Tensor)

pub fn fractional_max_pool3d(
    &self,
    kernel_size: &[i64],
    output_size: &[i64],
    random_samples: &Tensor
) -> (Tensor, Tensor)

pub fn fractional_max_pool3d_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Tensor

pub fn fractional_max_pool3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Tensor

pub fn fractional_max_pool3d_output(
    &self,
    output: &Tensor,
    indices: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    random_samples: &Tensor
) -> (Tensor, Tensor)

pub fn frexp(&self) -> (Tensor, Tensor)

pub fn frexp_tensor_out(
    &self,
    mantissa: &Tensor,
    exponent: &Tensor
) -> (Tensor, Tensor)

pub fn frobenius_norm(&self) -> Tensor

pub fn frobenius_norm_dim(&self, dim: &[i64], keepdim: bool) -> Tensor

pub fn frobenius_norm_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool
) -> Tensor

pub fn from_file(
    filename: &str,
    shared: bool,
    size: impl Into<Option<i64>>,
    options: (Kind, Device)
) -> Tensor

pub fn full<S: Into<Scalar>>(
    size: &[i64],
    fill_value: S,
    options: (Kind, Device)
) -> Tensor

pub fn full_like<S: Into<Scalar>>(&self, fill_value: S) -> Tensor

pub fn full_out<S: Into<Scalar>>(
    out: &Tensor,
    size: &[i64],
    fill_value: S
) -> Tensor

pub fn gather(&self, dim: i64, index: &Tensor, sparse_grad: bool) -> Tensor

pub fn gather_backward(
    &self,
    grad: &Tensor,
    dim: i64,
    index: &Tensor,
    sparse_grad: bool
) -> Tensor

pub fn gather_out(
    &self,
    out: &Tensor,
    dim: i64,
    index: &Tensor,
    sparse_grad: bool
) -> Tensor

pub fn gcd(&self, other: &Tensor) -> Tensor

pub fn gcd_(&mut self, other: &Tensor) -> Tensor

pub fn gcd_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn ge<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn ge_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn ge_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn ge_tensor(&self, other: &Tensor) -> Tensor

pub fn ge_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn ge_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn gelu(&self) -> Tensor

pub fn gelu_backward(&self, grad: &Tensor) -> Tensor

pub fn geometric_(&mut self, p: f64) -> Tensor

pub fn geqrf(&self) -> (Tensor, Tensor)

pub fn geqrf_a(&self, a: &Tensor, tau: &Tensor) -> (Tensor, Tensor)

pub fn ger(&self, vec2: &Tensor) -> Tensor

pub fn ger_out(&self, out: &Tensor, vec2: &Tensor) -> Tensor

pub fn glu(&self, dim: i64) -> Tensor

pub fn glu_backward(&self, grad_output: &Tensor, dim: i64) -> Tensor

pub fn glu_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    dim: i64
) -> Tensor

pub fn glu_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn grad(&self) -> Tensor

pub fn greater<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn greater_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn greater_equal<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn greater_equal_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn greater_equal_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn greater_equal_tensor(&self, other: &Tensor) -> Tensor

pub fn greater_equal_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn greater_equal_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn greater_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn greater_tensor(&self, other: &Tensor) -> Tensor

pub fn greater_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn greater_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn grid_sampler(
    &self,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Tensor

pub fn grid_sampler_2d(
    &self,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Tensor

pub fn grid_sampler_2d_backward(
    &self,
    grad_output: &Tensor,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> (Tensor, Tensor)

pub fn grid_sampler_3d(
    &self,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> Tensor

pub fn grid_sampler_3d_backward(
    &self,
    grad_output: &Tensor,
    grid: &Tensor,
    interpolation_mode: i64,
    padding_mode: i64,
    align_corners: bool
) -> (Tensor, Tensor)

pub fn group_norm<T: Borrow<Tensor>>(
    &self,
    num_groups: i64,
    weight: Option<T>,
    bias: Option<T>,
    eps: f64,
    cudnn_enabled: bool
) -> Tensor

pub fn gru<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_first: bool
) -> (Tensor, Tensor)

pub fn gru_cell<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: Option<T>,
    b_hh: Option<T>
) -> Tensor

pub fn gru_data<T: Borrow<Tensor>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool
) -> (Tensor, Tensor)

pub fn gt<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn gt_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn gt_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn gt_tensor(&self, other: &Tensor) -> Tensor

pub fn gt_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn gt_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn hamming_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn hamming_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Tensor

pub fn hamming_window_periodic_alpha(
    window_length: i64,
    periodic: bool,
    alpha: f64,
    options: (Kind, Device)
) -> Tensor

pub fn hamming_window_periodic_alpha_beta(
    window_length: i64,
    periodic: bool,
    alpha: f64,
    beta: f64,
    options: (Kind, Device)
) -> Tensor

pub fn hann_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn hann_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Tensor

pub fn hardshrink(&self) -> Tensor

pub fn hardshrink_backward<S: Into<Scalar>>(
    &self,
    grad_out: &Tensor,
    lambd: S
) -> Tensor

pub fn hardsigmoid(&self) -> Tensor

pub fn hardsigmoid_(&mut self) -> Tensor

pub fn hardsigmoid_backward(&self, grad_output: &Tensor) -> Tensor

pub fn hardsigmoid_out(&self, out: &Tensor) -> Tensor

pub fn hardswish(&self) -> Tensor

pub fn hardswish_(&mut self) -> Tensor

pub fn hardswish_backward(&self, grad_output: &Tensor) -> Tensor

pub fn hardswish_out(&self, out: &Tensor) -> Tensor

pub fn hardtanh(&self) -> Tensor

pub fn hardtanh_(&mut self) -> Tensor

pub fn hardtanh_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    min_val: S,
    max_val: S
) -> Tensor

pub fn hardtanh_backward_grad_input<S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    min_val: S,
    max_val: S
) -> Tensor

pub fn hardtanh_out(&self, out: &Tensor) -> Tensor

pub fn heaviside(&self, values: &Tensor) -> Tensor

pub fn heaviside_(&mut self, values: &Tensor) -> Tensor

pub fn heaviside_out(&self, out: &Tensor, values: &Tensor) -> Tensor

pub fn hinge_embedding_loss(
    &self,
    target: &Tensor,
    margin: f64,
    reduction: Reduction
) -> Tensor

pub fn histc(&self, bins: i64) -> Tensor

pub fn histc_out(&self, out: &Tensor, bins: i64) -> Tensor

pub fn hsplit(&self, sections: i64) -> Vec<Tensor>

pub fn hsplit_array(&self, indices: &[i64]) -> Vec<Tensor>

pub fn hspmm(mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn hspmm_out(out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn hstack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn hstack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor

pub fn huber_loss(
    &self,
    target: &Tensor,
    reduction: Reduction,
    delta: f64
) -> Tensor

pub fn huber_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    delta: f64
) -> Tensor

pub fn huber_loss_backward_out(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    delta: f64
) -> Tensor

pub fn huber_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    delta: f64
) -> Tensor

pub fn hypot(&self, other: &Tensor) -> Tensor

pub fn hypot_(&mut self, other: &Tensor) -> Tensor

pub fn hypot_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn i0(&self) -> Tensor

pub fn i0_(&mut self) -> Tensor

pub fn i0_out(&self, out: &Tensor) -> Tensor

pub fn igamma(&self, other: &Tensor) -> Tensor

pub fn igamma_(&mut self, other: &Tensor) -> Tensor

pub fn igamma_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn igammac(&self, other: &Tensor) -> Tensor

pub fn igammac_(&mut self, other: &Tensor) -> Tensor

pub fn igammac_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn im2col(
    &self,
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Tensor

pub fn im2col_backward(
    grad_output: &Tensor,
    input_size: &[i64],
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Tensor

pub fn im2col_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    input_size: &[i64],
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Tensor

pub fn im2col_out(
    &self,
    out: &Tensor,
    kernel_size: &[i64],
    dilation: &[i64],
    padding: &[i64],
    stride: &[i64]
) -> Tensor

pub fn imag(&self) -> Tensor

pub fn index<T: Borrow<Tensor>>(&self, indices: &[Option<T>]) -> Tensor

pub fn index_add(&self, dim: i64, index: &Tensor, source: &Tensor) -> Tensor

pub fn index_add_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Tensor

pub fn index_add_alpha<S: Into<Scalar>>(
    &self,
    dim: i64,
    index: &Tensor,
    source: &Tensor,
    alpha: S
) -> Tensor

pub fn index_add_alpha_<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor,
    alpha: S
) -> Tensor

pub fn index_copy(&self, dim: i64, index: &Tensor, source: &Tensor) -> Tensor

pub fn index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Tensor

pub fn index_fill<S: Into<Scalar>>(
    &self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Tensor

pub fn index_fill_<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Tensor

pub fn index_fill_int_tensor(
    &self,
    dim: i64,
    index: &Tensor,
    value: &Tensor
) -> Tensor

pub fn index_fill_int_tensor_(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: &Tensor
) -> Tensor

pub fn index_put<T: Borrow<Tensor>>(
    &self,
    indices: &[Option<T>],
    values: &Tensor,
    accumulate: bool
) -> Tensor

pub fn index_put_<T: Borrow<Tensor>>(
    &mut self,
    indices: &[Option<T>],
    values: &Tensor,
    accumulate: bool
) -> Tensor

pub fn index_select(&self, dim: i64, index: &Tensor) -> Tensor

pub fn index_select_backward(
    grad: &Tensor,
    self_sizes: &[i64],
    dim: i64,
    index: &Tensor
) -> Tensor

pub fn index_select_out(&self, out: &Tensor, dim: i64, index: &Tensor) -> Tensor

pub fn indices(&self) -> Tensor

pub fn infinitely_differentiable_gelu_backward(&self, grad: &Tensor) -> Tensor

pub fn inner(&self, other: &Tensor) -> Tensor

pub fn inner_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn instance_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    use_input_stats: bool,
    momentum: f64,
    eps: f64,
    cudnn_enabled: bool
) -> Tensor

pub fn int_repr(&self) -> Tensor

pub fn inverse(&self) -> Tensor

pub fn inverse_out(&self, out: &Tensor) -> Tensor

pub fn is_coalesced(&self) -> bool

pub fn is_complex(&self) -> bool

pub fn is_distributed(&self) -> bool

pub fn is_floating_point(&self) -> bool

pub fn is_leaf(&self) -> bool

pub fn is_nonzero(&self) -> bool

pub fn is_pinned(&self) -> bool

pub fn is_same_size(&self, other: &Tensor) -> bool

pub fn is_set_to(&self, tensor: &Tensor) -> bool

pub fn is_signed(&self) -> bool

pub fn is_vulkan_available() -> bool

pub fn isclose(
    &self,
    other: &Tensor,
    rtol: f64,
    atol: f64,
    equal_nan: bool
) -> Tensor

pub fn isfinite(&self) -> Tensor

pub fn isinf(&self) -> Tensor

pub fn isnan(&self) -> Tensor

pub fn isneginf(&self) -> Tensor

pub fn isneginf_out(&self, out: &Tensor) -> Tensor

pub fn isposinf(&self) -> Tensor

pub fn isposinf_out(&self, out: &Tensor) -> Tensor

pub fn isreal(&self) -> Tensor

pub fn istft<T: Borrow<Tensor>>(
    &self,
    n_fft: i64,
    hop_length: impl Into<Option<i64>>,
    win_length: impl Into<Option<i64>>,
    window: Option<T>,
    center: bool,
    normalized: bool,
    onesided: bool,
    length: impl Into<Option<i64>>,
    return_complex: bool
) -> Tensor

pub fn kaiser_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn kaiser_window_beta(
    window_length: i64,
    periodic: bool,
    beta: f64,
    options: (Kind, Device)
) -> Tensor

pub fn kaiser_window_periodic(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Tensor

pub fn kl_div(
    &self,
    target: &Tensor,
    reduction: Reduction,
    log_target: bool
) -> Tensor

pub fn kl_div_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    log_target: bool
) -> Tensor

pub fn kron(&self, other: &Tensor) -> Tensor

pub fn kron_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn kthvalue(&self, k: i64, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn kthvalue_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    k: i64,
    dim: i64,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn l1_loss(&self, target: &Tensor, reduction: Reduction) -> Tensor

pub fn l1_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn l1_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn l1_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn layer_norm<T: Borrow<Tensor>>(
    &self,
    normalized_shape: &[i64],
    weight: Option<T>,
    bias: Option<T>,
    eps: f64,
    cudnn_enable: bool
) -> Tensor

pub fn lcm(&self, other: &Tensor) -> Tensor

pub fn lcm_(&mut self, other: &Tensor) -> Tensor

pub fn lcm_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn ldexp(&self, other: &Tensor) -> Tensor

pub fn ldexp_(&mut self, other: &Tensor) -> Tensor

pub fn ldexp_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn le<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn le_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn le_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn le_tensor(&self, other: &Tensor) -> Tensor

pub fn le_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn le_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn leaky_relu(&self) -> Tensor

pub fn leaky_relu_(&mut self) -> Tensor

pub fn leaky_relu_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    negative_slope: S,
    self_is_result: bool
) -> Tensor

pub fn leaky_relu_out(&self, out: &Tensor) -> Tensor

pub fn lerp<S: Into<Scalar>>(&self, end: &Tensor, weight: S) -> Tensor

pub fn lerp_<S: Into<Scalar>>(&mut self, end: &Tensor, weight: S) -> Tensor

pub fn lerp_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    end: &Tensor,
    weight: S
) -> Tensor

pub fn lerp_tensor(&self, end: &Tensor, weight: &Tensor) -> Tensor

pub fn lerp_tensor_(&mut self, end: &Tensor, weight: &Tensor) -> Tensor

pub fn lerp_tensor_out(
    &self,
    out: &Tensor,
    end: &Tensor,
    weight: &Tensor
) -> Tensor

pub fn less<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn less_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn less_equal<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn less_equal_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn less_equal_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn less_equal_tensor(&self, other: &Tensor) -> Tensor

pub fn less_equal_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn less_equal_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn less_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn less_tensor(&self, other: &Tensor) -> Tensor

pub fn less_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn less_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn lgamma(&self) -> Tensor

pub fn lgamma_(&mut self) -> Tensor

pub fn lgamma_out(&self, out: &Tensor) -> Tensor

pub fn linalg_cholesky(&self) -> Tensor

pub fn linalg_cholesky_ex(&self, check_errors: bool) -> (Tensor, Tensor)

pub fn linalg_cholesky_ex_l(
    &self,
    l: &Tensor,
    info: &Tensor,
    check_errors: bool
) -> (Tensor, Tensor)

pub fn linalg_cholesky_out(&self, out: &Tensor) -> Tensor

pub fn linalg_cond<S: Into<Scalar>>(&self, p: S) -> Tensor

pub fn linalg_cond_out<S: Into<Scalar>>(&self, out: &Tensor, p: S) -> Tensor

pub fn linalg_cond_p_str(&self, p: &str) -> Tensor

pub fn linalg_cond_p_str_out(&self, out: &Tensor, p: &str) -> Tensor

pub fn linalg_det(&self) -> Tensor

pub fn linalg_det_out(&self, out: &Tensor) -> Tensor

pub fn linalg_eig(&self) -> (Tensor, Tensor)

pub fn linalg_eig_out(
    &self,
    eigenvalues: &Tensor,
    eigenvectors: &Tensor
) -> (Tensor, Tensor)

pub fn linalg_eigh(&self, uplo: &str) -> (Tensor, Tensor)

pub fn linalg_eigh_eigvals(
    &self,
    eigvals: &Tensor,
    eigvecs: &Tensor,
    uplo: &str
) -> (Tensor, Tensor)

pub fn linalg_eigvals(&self) -> Tensor

pub fn linalg_eigvals_out(&self, out: &Tensor) -> Tensor

pub fn linalg_eigvalsh(&self, uplo: &str) -> Tensor

pub fn linalg_eigvalsh_out(&self, out: &Tensor, uplo: &str) -> Tensor

pub fn linalg_householder_product(&self, tau: &Tensor) -> Tensor

pub fn linalg_householder_product_out(
    &self,
    out: &Tensor,
    tau: &Tensor
) -> Tensor

pub fn linalg_inv(&self) -> Tensor

pub fn linalg_inv_ex(&self, check_errors: bool) -> (Tensor, Tensor)

pub fn linalg_inv_ex_inverse(
    &self,
    inverse: &Tensor,
    info: &Tensor,
    check_errors: bool
) -> (Tensor, Tensor)

pub fn linalg_inv_out(&self, out: &Tensor) -> Tensor

pub fn linalg_lstsq(
    &self,
    b: &Tensor,
    rcond: impl Into<Option<f64>>,
    driver: &str
) -> (Tensor, Tensor, Tensor, Tensor)

pub fn linalg_lstsq_out(
    &self,
    solution: &Tensor,
    residuals: &Tensor,
    rank: &Tensor,
    singular_values: &Tensor,
    b: &Tensor,
    rcond: impl Into<Option<f64>>,
    driver: &str
) -> (Tensor, Tensor, Tensor, Tensor)

pub fn linalg_matrix_norm<S: Into<Scalar>>(
    &self,
    ord: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn linalg_matrix_norm_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    ord: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn linalg_matrix_norm_str_ord(
    &self,
    ord: &str,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn linalg_matrix_norm_str_ord_out(
    &self,
    out: &Tensor,
    ord: &str,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn linalg_matrix_power(&self, n: i64) -> Tensor

pub fn linalg_matrix_power_out(&self, out: &Tensor, n: i64) -> Tensor

pub fn linalg_matrix_rank(
    &self,
    tol: impl Into<Option<f64>>,
    hermitian: bool
) -> Tensor

pub fn linalg_matrix_rank_out(
    &self,
    out: &Tensor,
    tol: impl Into<Option<f64>>,
    hermitian: bool
) -> Tensor

pub fn linalg_matrix_rank_out_tol_tensor(
    &self,
    out: &Tensor,
    tol: &Tensor,
    hermitian: bool
) -> Tensor

pub fn linalg_matrix_rank_tol_tensor(
    &self,
    tol: &Tensor,
    hermitian: bool
) -> Tensor

pub fn linalg_multi_dot<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn linalg_multi_dot_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T]
) -> Tensor

pub fn linalg_norm<'a, S: Into<Scalar>>(
    &self,
    ord: S,
    dim: impl Into<Option<&'a [i64]>>,
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn linalg_norm_ord_str<'a>(
    &self,
    ord: &str,
    dim: impl Into<Option<&'a [i64]>>,
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn linalg_norm_ord_str_out<'a>(
    &self,
    out: &Tensor,
    ord: &str,
    dim: impl Into<Option<&'a [i64]>>,
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn linalg_norm_out<'a, S: Into<Scalar>>(
    &self,
    out: &Tensor,
    ord: S,
    dim: impl Into<Option<&'a [i64]>>,
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn linalg_pinv(&self, rcond: f64, hermitian: bool) -> Tensor

pub fn linalg_pinv_out(
    &self,
    out: &Tensor,
    rcond: f64,
    hermitian: bool
) -> Tensor

pub fn linalg_pinv_out_rcond_tensor(
    &self,
    out: &Tensor,
    rcond: &Tensor,
    hermitian: bool
) -> Tensor

pub fn linalg_pinv_rcond_tensor(
    &self,
    rcond: &Tensor,
    hermitian: bool
) -> Tensor

pub fn linalg_qr(&self, mode: &str) -> (Tensor, Tensor)

pub fn linalg_qr_out(
    &self,
    q: &Tensor,
    r: &Tensor,
    mode: &str
) -> (Tensor, Tensor)

pub fn linalg_slogdet(&self) -> (Tensor, Tensor)

pub fn linalg_slogdet_out(
    &self,
    sign: &Tensor,
    logabsdet: &Tensor
) -> (Tensor, Tensor)

pub fn linalg_solve(&self, other: &Tensor) -> Tensor

pub fn linalg_solve_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn linalg_svd(&self, full_matrices: bool) -> (Tensor, Tensor, Tensor)

pub fn linalg_svd_u(
    &self,
    u: &Tensor,
    s: &Tensor,
    vh: &Tensor,
    full_matrices: bool
) -> (Tensor, Tensor, Tensor)

pub fn linalg_svdvals(&self) -> Tensor

pub fn linalg_svdvals_out(&self, out: &Tensor) -> Tensor

pub fn linalg_tensorinv(&self, ind: i64) -> Tensor

pub fn linalg_tensorinv_out(&self, out: &Tensor, ind: i64) -> Tensor

pub fn linalg_tensorsolve<'a>(
    &self,
    other: &Tensor,
    dims: impl Into<Option<&'a [i64]>>
) -> Tensor

pub fn linalg_tensorsolve_out<'a>(
    &self,
    out: &Tensor,
    other: &Tensor,
    dims: impl Into<Option<&'a [i64]>>
) -> Tensor

pub fn linear<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>
) -> Tensor

pub fn linspace<S: Into<Scalar>>(
    start: S,
    end: S,
    steps: impl Into<Option<i64>>,
    options: (Kind, Device)
) -> Tensor

pub fn linspace_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S,
    steps: impl Into<Option<i64>>
) -> Tensor

pub fn log(&self) -> Tensor

pub fn log10(&self) -> Tensor

pub fn log10_(&mut self) -> Tensor

pub fn log10_out(&self, out: &Tensor) -> Tensor

pub fn log1p(&self) -> Tensor

pub fn log1p_(&mut self) -> Tensor

pub fn log1p_out(&self, out: &Tensor) -> Tensor

pub fn log2(&self) -> Tensor

pub fn log2_(&mut self) -> Tensor

pub fn log2_out(&self, out: &Tensor) -> Tensor

pub fn log_(&mut self) -> Tensor

pub fn log_normal_(&mut self, mean: f64, std: f64) -> Tensor

pub fn log_out(&self, out: &Tensor) -> Tensor

pub fn log_sigmoid(&self) -> Tensor

pub fn log_sigmoid_backward(
    &self,
    grad_output: &Tensor,
    buffer: &Tensor
) -> Tensor

pub fn log_sigmoid_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    buffer: &Tensor
) -> Tensor

pub fn log_sigmoid_out(&self, out: &Tensor) -> Tensor

pub fn log_softmax(&self, dim: i64, dtype: Kind) -> Tensor

pub fn logaddexp(&self, other: &Tensor) -> Tensor

pub fn logaddexp2(&self, other: &Tensor) -> Tensor

pub fn logaddexp2_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logaddexp_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logcumsumexp(&self, dim: i64) -> Tensor

pub fn logcumsumexp_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn logdet(&self) -> Tensor

pub fn logical_and(&self, other: &Tensor) -> Tensor

pub fn logical_and_(&mut self, other: &Tensor) -> Tensor

pub fn logical_and_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logical_not(&self) -> Tensor

pub fn logical_not_(&mut self) -> Tensor

pub fn logical_not_out(&self, out: &Tensor) -> Tensor

pub fn logical_or(&self, other: &Tensor) -> Tensor

pub fn logical_or_(&mut self, other: &Tensor) -> Tensor

pub fn logical_or_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logical_xor(&self, other: &Tensor) -> Tensor

pub fn logical_xor_(&mut self, other: &Tensor) -> Tensor

pub fn logical_xor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logit(&self, eps: impl Into<Option<f64>>) -> Tensor

pub fn logit_(&mut self, eps: impl Into<Option<f64>>) -> Tensor

pub fn logit_backward(
    &self,
    grad_output: &Tensor,
    eps: impl Into<Option<f64>>
) -> Tensor

pub fn logit_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    eps: impl Into<Option<f64>>
) -> Tensor

pub fn logit_out(&self, out: &Tensor, eps: impl Into<Option<f64>>) -> Tensor

pub fn logspace<S: Into<Scalar>>(
    start: S,
    end: S,
    steps: impl Into<Option<i64>>,
    base: f64,
    options: (Kind, Device)
) -> Tensor

pub fn logspace_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S,
    steps: impl Into<Option<i64>>,
    base: f64
) -> Tensor

pub fn logsumexp(&self, dim: &[i64], keepdim: bool) -> Tensor

pub fn logsumexp_out(&self, out: &Tensor, dim: &[i64], keepdim: bool) -> Tensor

pub fn lstm<T: Borrow<Tensor>>(
    &self,
    hx: &[T],
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_first: bool
) -> (Tensor, Tensor, Tensor)

pub fn lstm_cell<T: Borrow<Tensor>>(
    &self,
    hx: &[T],
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: Option<T>,
    b_hh: Option<T>
) -> (Tensor, Tensor)

pub fn lstm_data<T: Borrow<Tensor>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    hx: &[T],
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool
) -> (Tensor, Tensor, Tensor)

pub fn lstsq(&self, a: &Tensor) -> (Tensor, Tensor)

pub fn lstsq_x(&self, x: &Tensor, qr: &Tensor, a: &Tensor) -> (Tensor, Tensor)

pub fn lt<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn lt_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn lt_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn lt_tensor(&self, other: &Tensor) -> Tensor

pub fn lt_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn lt_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn lu_solve(&self, lu_data: &Tensor, lu_pivots: &Tensor) -> Tensor

pub fn lu_solve_out(
    &self,
    out: &Tensor,
    lu_data: &Tensor,
    lu_pivots: &Tensor
) -> Tensor

pub fn lu_unpack(
    lu_data: &Tensor,
    lu_pivots: &Tensor,
    unpack_data: bool,
    unpack_pivots: bool
) -> (Tensor, Tensor, Tensor)

pub fn lu_unpack_out(
    p: &Tensor,
    l: &Tensor,
    u: &Tensor,
    lu_data: &Tensor,
    lu_pivots: &Tensor,
    unpack_data: bool,
    unpack_pivots: bool
) -> (Tensor, Tensor, Tensor)

pub fn margin_ranking_loss(
    input1: &Tensor,
    input2: &Tensor,
    target: &Tensor,
    margin: f64,
    reduction: Reduction
) -> Tensor

pub fn masked_fill<S: Into<Scalar>>(&self, mask: &Tensor, value: S) -> Tensor

pub fn masked_fill_<S: Into<Scalar>>(
    &mut self,
    mask: &Tensor,
    value: S
) -> Tensor

pub fn masked_fill_tensor(&self, mask: &Tensor, value: &Tensor) -> Tensor

pub fn masked_fill_tensor_(&mut self, mask: &Tensor, value: &Tensor) -> Tensor

pub fn masked_scatter(&self, mask: &Tensor, source: &Tensor) -> Tensor

pub fn masked_scatter_(&mut self, mask: &Tensor, source: &Tensor) -> Tensor

pub fn masked_select(&self, mask: &Tensor) -> Tensor

pub fn masked_select_backward(&self, grad: &Tensor, mask: &Tensor) -> Tensor

pub fn masked_select_out(&self, out: &Tensor, mask: &Tensor) -> Tensor

pub fn matmul(&self, other: &Tensor) -> Tensor

pub fn matmul_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn matrix_exp(&self) -> Tensor

pub fn matrix_exp_backward(&self, grad: &Tensor) -> Tensor

pub fn matrix_power(&self, n: i64) -> Tensor

pub fn matrix_power_out(&self, out: &Tensor, n: i64) -> Tensor

pub fn matrix_rank(&self, symmetric: bool) -> Tensor

pub fn matrix_rank_tol(&self, tol: f64, symmetric: bool) -> Tensor

pub fn max(&self) -> Tensor

pub fn max_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn max_dim_max(
    &self,
    max: &Tensor,
    max_values: &Tensor,
    dim: i64,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn max_other(&self, other: &Tensor) -> Tensor

pub fn max_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn max_pool1d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Tensor

pub fn max_pool1d_with_indices(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> (Tensor, Tensor)

pub fn max_pool2d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Tensor

pub fn max_pool2d_with_indices(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> (Tensor, Tensor)

pub fn max_pool2d_with_indices_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool,
    indices: &Tensor
) -> Tensor

pub fn max_pool2d_with_indices_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool,
    indices: &Tensor
) -> Tensor

pub fn max_pool2d_with_indices_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> (Tensor, Tensor)

pub fn max_pool3d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Tensor

pub fn max_pool3d_with_indices(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> (Tensor, Tensor)

pub fn max_pool3d_with_indices_backward(
    &self,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool,
    indices: &Tensor
) -> Tensor

pub fn max_pool3d_with_indices_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool,
    indices: &Tensor
) -> Tensor

pub fn max_pool3d_with_indices_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> (Tensor, Tensor)

pub fn max_unpool2d(&self, indices: &Tensor, output_size: &[i64]) -> Tensor

pub fn max_unpool2d_backward(
    &self,
    grad_output: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> Tensor

pub fn max_unpool2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> Tensor

pub fn max_unpool2d_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    output_size: &[i64]
) -> Tensor

pub fn max_unpool3d(
    &self,
    indices: &Tensor,
    output_size: &[i64],
    stride: &[i64],
    padding: &[i64]
) -> Tensor

pub fn max_unpool3d_backward(
    &self,
    grad_output: &Tensor,
    indices: &Tensor,
    output_size: &[i64],
    stride: &[i64],
    padding: &[i64]
) -> Tensor

pub fn max_unpool3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    indices: &Tensor,
    output_size: &[i64],
    stride: &[i64],
    padding: &[i64]
) -> Tensor

pub fn max_unpool3d_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    output_size: &[i64],
    stride: &[i64],
    padding: &[i64]
) -> Tensor

pub fn maximum(&self, other: &Tensor) -> Tensor

pub fn maximum_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn mean(&self, dtype: Kind) -> Tensor

pub fn mean_dim(&self, dim: &[i64], keepdim: bool, dtype: Kind) -> Tensor

pub fn mean_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn median(&self) -> Tensor

pub fn median_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn median_dim_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn meshgrid<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn min(&self) -> Tensor

pub fn min_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn min_dim_min(
    &self,
    min: &Tensor,
    min_indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn min_other(&self, other: &Tensor) -> Tensor

pub fn min_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn minimum(&self, other: &Tensor) -> Tensor

pub fn minimum_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn miopen_batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    exponential_average_factor: f64,
    epsilon: f64
) -> (Tensor, Tensor, Tensor)

pub fn miopen_batch_norm_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    weight: &Tensor,
    running_mean: Option<T>,
    running_var: Option<T>,
    save_mean: Option<T>,
    save_var: Option<T>,
    epsilon: f64
) -> (Tensor, Tensor, Tensor)

pub fn miopen_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn miopen_convolution_backward_bias(grad_output: &Tensor) -> Tensor

pub fn miopen_convolution_backward_input(
    self_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn miopen_convolution_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn miopen_convolution_transpose<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    output_padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn miopen_convolution_transpose_backward_input(
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn miopen_convolution_transpose_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn miopen_depthwise_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn miopen_depthwise_convolution_backward_input(
    self_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn miopen_depthwise_convolution_backward_weight(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn miopen_rnn<T: Borrow<Tensor>>(
    &self,
    weight: &[T],
    weight_stride0: i64,
    hx: &Tensor,
    cx: Option<T>,
    mode: i64,
    hidden_size: i64,
    num_layers: i64,
    batch_first: bool,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_sizes: &[i64],
    dropout_state: Option<T>
) -> (Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn mish(&self) -> Tensor

pub fn mish_(&mut self) -> Tensor

pub fn mish_backward(&self, grad_output: &Tensor) -> Tensor

pub fn mish_out(&self, out: &Tensor) -> Tensor

pub fn mkldnn_adaptive_avg_pool2d(&self, output_size: &[i64]) -> Tensor

pub fn mkldnn_adaptive_avg_pool2d_backward(
    &self,
    grad_output: &Tensor
) -> Tensor

pub fn mkldnn_convolution<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn mkldnn_convolution_backward_input(
    self_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    bias_defined: bool
) -> Tensor

pub fn mkldnn_convolution_backward_weights(
    &self,
    weight_size: &[i64],
    grad_output: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    bias_defined: bool
) -> (Tensor, Tensor)

pub fn mkldnn_linear<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>
) -> Tensor

pub fn mkldnn_linear_backward_input(
    input_size: &[i64],
    grad_output: &Tensor,
    weight: &Tensor
) -> Tensor

pub fn mkldnn_linear_backward_weights(
    &self,
    grad_output: &Tensor,
    weight: &Tensor,
    bias_defined: bool
) -> (Tensor, Tensor)

pub fn mkldnn_max_pool2d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Tensor

pub fn mkldnn_max_pool2d_backward(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Tensor

pub fn mkldnn_max_pool3d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Tensor

pub fn mkldnn_max_pool3d_backward(
    &self,
    grad_output: &Tensor,
    output: &Tensor,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Tensor

pub fn mkldnn_reorder_conv2d_weight(
    &self,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn mkldnn_reorder_conv3d_weight(
    &self,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64
) -> Tensor

pub fn mm(&self, mat2: &Tensor) -> Tensor

pub fn mm_out(&self, out: &Tensor, mat2: &Tensor) -> Tensor

pub fn mode(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn mode_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn moveaxis(&self, source: &[i64], destination: &[i64]) -> Tensor

pub fn moveaxis_int(&self, source: i64, destination: i64) -> Tensor

pub fn movedim(&self, source: &[i64], destination: &[i64]) -> Tensor

pub fn movedim_int(&self, source: i64, destination: i64) -> Tensor

pub fn mse_loss(&self, target: &Tensor, reduction: Reduction) -> Tensor

pub fn mse_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn mse_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn mse_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn msort(&self) -> Tensor

pub fn msort_out(&self, out: &Tensor) -> Tensor

pub fn g_mul(&self, other: &Tensor) -> Tensor

pub fn g_mul_(&mut self, other: &Tensor) -> Tensor

pub fn mul_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn g_mul_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_mul_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn multi_margin_loss_backward<T: Borrow<Tensor>, S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    p: S,
    margin: S,
    weight: Option<T>,
    reduction: Reduction
) -> Tensor

pub fn multi_margin_loss_backward_grad_input<T: Borrow<Tensor>, S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    p: S,
    margin: S,
    weight: Option<T>,
    reduction: Reduction
) -> Tensor

pub fn multilabel_margin_loss(
    &self,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn multilabel_margin_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    is_target: &Tensor
) -> Tensor

pub fn multilabel_margin_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    is_target: &Tensor
) -> Tensor

pub fn multilabel_margin_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn multinomial(&self, num_samples: i64, replacement: bool) -> Tensor

pub fn multinomial_out(
    &self,
    out: &Tensor,
    num_samples: i64,
    replacement: bool
) -> Tensor

pub fn multiply(&self, other: &Tensor) -> Tensor

pub fn multiply_(&mut self, other: &Tensor) -> Tensor

pub fn multiply_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn multiply_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn multiply_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn mv(&self, vec: &Tensor) -> Tensor

pub fn mv_out(&self, out: &Tensor, vec: &Tensor) -> Tensor

pub fn mvlgamma(&self, p: i64) -> Tensor

pub fn mvlgamma_(&mut self, p: i64) -> Tensor

pub fn nan_to_num(
    &self,
    nan: impl Into<Option<f64>>,
    posinf: impl Into<Option<f64>>,
    neginf: impl Into<Option<f64>>
) -> Tensor

pub fn nan_to_num_(
    &mut self,
    nan: impl Into<Option<f64>>,
    posinf: impl Into<Option<f64>>,
    neginf: impl Into<Option<f64>>
) -> Tensor

pub fn nan_to_num_out(
    &self,
    out: &Tensor,
    nan: impl Into<Option<f64>>,
    posinf: impl Into<Option<f64>>,
    neginf: impl Into<Option<f64>>
) -> Tensor

pub fn nanmedian(&self) -> Tensor

pub fn nanmedian_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn nanmedian_dim_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn nanquantile(
    &self,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn nanquantile_new(
    &self,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Tensor

pub fn nanquantile_new_out(
    &self,
    out: &Tensor,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Tensor

pub fn nanquantile_new_scalar(
    &self,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Tensor

pub fn nanquantile_new_scalar_out(
    &self,
    out: &Tensor,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Tensor

pub fn nanquantile_out(
    &self,
    out: &Tensor,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn nanquantile_scalar(
    &self,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn nanquantile_scalar_out(
    &self,
    out: &Tensor,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn nansum(&self, dtype: Kind) -> Tensor

pub fn nansum_dim_intlist(
    &self,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn nansum_intlist_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn narrow(&self, dim: i64, start: i64, length: i64) -> Tensor

pub fn narrow_copy(&self, dim: i64, start: i64, length: i64) -> Tensor

pub fn narrow_copy_out(
    &self,
    out: &Tensor,
    dim: i64,
    start: i64,
    length: i64
) -> Tensor

pub fn narrow_tensor(&self, dim: i64, start: &Tensor, length: i64) -> Tensor

pub fn native_batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    momentum: f64,
    eps: f64
) -> (Tensor, Tensor, Tensor)

pub fn native_batch_norm_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    save_mean: &Tensor,
    save_invstd: &Tensor,
    weight: Option<T>,
    bias: Option<T>,
    running_mean: Option<T>,
    running_var: Option<T>,
    training: bool,
    momentum: f64,
    eps: f64
) -> (Tensor, Tensor, Tensor)

pub fn native_group_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    n: i64,
    c: i64,
    hxw: i64,
    group: i64,
    eps: f64
) -> (Tensor, Tensor, Tensor)

pub fn native_layer_norm<T: Borrow<Tensor>>(
    &self,
    normalized_shape: &[i64],
    weight: Option<T>,
    bias: Option<T>,
    eps: f64
) -> (Tensor, Tensor, Tensor)

pub fn native_norm(&self) -> Tensor

pub fn native_norm_scalaropt_dim_dtype<S: Into<Scalar>>(
    &self,
    p: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn ne<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn ne_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn ne_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn ne_tensor(&self, other: &Tensor) -> Tensor

pub fn ne_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn ne_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn neg(&self) -> Tensor

pub fn neg_(&mut self) -> Tensor

pub fn neg_out(&self, out: &Tensor) -> Tensor

pub fn negative(&self) -> Tensor

pub fn negative_(&mut self) -> Tensor

pub fn negative_out(&self, out: &Tensor) -> Tensor

pub fn new_empty(&self, size: &[i64], options: (Kind, Device)) -> Tensor

pub fn new_empty_strided(
    &self,
    size: &[i64],
    stride: &[i64],
    options: (Kind, Device)
) -> Tensor

pub fn new_full<S: Into<Scalar>>(
    &self,
    size: &[i64],
    fill_value: S,
    options: (Kind, Device)
) -> Tensor

pub fn new_zeros(&self, size: &[i64], options: (Kind, Device)) -> Tensor

pub fn nextafter(&self, other: &Tensor) -> Tensor

pub fn nextafter_(&mut self, other: &Tensor) -> Tensor

pub fn nextafter_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn g_nll_loss<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Tensor

pub fn nll_loss2d<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Tensor

pub fn nll_loss2d_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64,
    total_weight: &Tensor
) -> Tensor

pub fn nll_loss2d_backward_grad_input<T: Borrow<Tensor>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64,
    total_weight: &Tensor
) -> Tensor

pub fn nll_loss2d_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Tensor

pub fn nll_loss_backward<T: Borrow<Tensor>>(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64,
    total_weight: &Tensor
) -> Tensor

pub fn nll_loss_backward_grad_input<T: Borrow<Tensor>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64,
    total_weight: &Tensor
) -> Tensor

pub fn nll_loss_nd<T: Borrow<Tensor>>(
    &self,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Tensor

pub fn nll_loss_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    target: &Tensor,
    weight: Option<T>,
    reduction: Reduction,
    ignore_index: i64
) -> Tensor

pub fn nonzero(&self) -> Tensor

pub fn nonzero_numpy(&self) -> Vec<Tensor>

pub fn nonzero_out(&self, out: &Tensor) -> Tensor

pub fn norm(&self) -> Tensor

pub fn norm_dtype_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    p: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn norm_except_dim(v: &Tensor, pow: i64, dim: i64) -> Tensor

pub fn norm_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    p: S,
    dim: &[i64],
    keepdim: bool
) -> Tensor

pub fn norm_scalaropt_dim<S: Into<Scalar>>(
    &self,
    p: S,
    dim: &[i64],
    keepdim: bool
) -> Tensor

pub fn norm_scalaropt_dim_dtype<S: Into<Scalar>>(
    &self,
    p: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn norm_scalaropt_dtype<S: Into<Scalar>>(&self, p: S, dtype: Kind) -> Tensor

pub fn normal(out: &Tensor, mean: &Tensor, std: f64) -> Tensor

pub fn normal_(&mut self, mean: f64, std: f64) -> Tensor

pub fn normal_float_float_out(
    out: &Tensor,
    mean: f64,
    std: f64,
    size: &[i64]
) -> Tensor

pub fn normal_float_tensor_out(out: &Tensor, mean: f64, std: &Tensor) -> Tensor

pub fn normal_tensor_tensor_out(
    out: &Tensor,
    mean: &Tensor,
    std: &Tensor
) -> Tensor

pub fn not_equal<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn not_equal_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn not_equal_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn not_equal_tensor(&self, other: &Tensor) -> Tensor

pub fn not_equal_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn not_equal_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn nuclear_norm(&self, keepdim: bool) -> Tensor

pub fn nuclear_norm_dim(&self, dim: &[i64], keepdim: bool) -> Tensor

pub fn nuclear_norm_dim_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool
) -> Tensor

pub fn nuclear_norm_out(&self, out: &Tensor, keepdim: bool) -> Tensor

pub fn numpy_t(&self) -> Tensor

pub fn one_hot(&self, num_classes: i64) -> Tensor

pub fn ones(size: &[i64], options: (Kind, Device)) -> Tensor

pub fn ones_like(&self) -> Tensor

pub fn ones_out(out: &Tensor, size: &[i64]) -> Tensor

pub fn orgqr(&self, input2: &Tensor) -> Tensor

pub fn orgqr_out(&self, out: &Tensor, input2: &Tensor) -> Tensor

pub fn ormqr(
    &self,
    input2: &Tensor,
    input3: &Tensor,
    left: bool,
    transpose: bool
) -> Tensor

pub fn ormqr_out(
    &self,
    out: &Tensor,
    input2: &Tensor,
    input3: &Tensor,
    left: bool,
    transpose: bool
) -> Tensor

pub fn outer(&self, vec2: &Tensor) -> Tensor

pub fn outer_out(&self, out: &Tensor, vec2: &Tensor) -> Tensor

pub fn output_nr(&self) -> i64

pub fn pad_sequence<T: Borrow<Tensor>>(
    sequences: &[T],
    batch_first: bool,
    padding_value: f64
) -> Tensor

pub fn pairwise_distance(
    x1: &Tensor,
    x2: &Tensor,
    p: f64,
    eps: f64,
    keepdim: bool
) -> Tensor

pub fn pdist(&self, p: f64) -> Tensor

pub fn permute(&self, dims: &[i64]) -> Tensor

pub fn pin_memory(&self) -> Tensor

pub fn pinverse(&self, rcond: f64) -> Tensor

pub fn pixel_shuffle(&self, upscale_factor: i64) -> Tensor

pub fn pixel_unshuffle(&self, downscale_factor: i64) -> Tensor

pub fn poisson(&self) -> Tensor

pub fn poisson_nll_loss(
    &self,
    target: &Tensor,
    log_input: bool,
    full: bool,
    eps: f64,
    reduction: Reduction
) -> Tensor

pub fn polar(abs: &Tensor, angle: &Tensor) -> Tensor

pub fn polar_out(out: &Tensor, abs: &Tensor, angle: &Tensor) -> Tensor

pub fn polygamma(&self, n: i64) -> Tensor

pub fn polygamma_(&mut self, n: i64) -> Tensor

pub fn polygamma_out(&self, out: &Tensor, n: i64) -> Tensor

pub fn positive(&self) -> Tensor

pub fn pow<S: Into<Scalar>>(&self, exponent: S) -> Tensor

pub fn pow_<S: Into<Scalar>>(&mut self, exponent: S) -> Tensor

pub fn pow_scalar<S: Into<Scalar>>(self_scalar: S, exponent: &Tensor) -> Tensor

pub fn pow_scalar_out<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    exponent: &Tensor
) -> Tensor

pub fn pow_tensor_(&mut self, exponent: &Tensor) -> Tensor

pub fn pow_tensor_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    exponent: S
) -> Tensor

pub fn pow_tensor_tensor(&self, exponent: &Tensor) -> Tensor

pub fn pow_tensor_tensor_out(&self, out: &Tensor, exponent: &Tensor) -> Tensor

pub fn prelu(&self, weight: &Tensor) -> Tensor

pub fn prelu_backward(
    &self,
    grad_output: &Tensor,
    weight: &Tensor
) -> (Tensor, Tensor)

pub fn prod(&self, dtype: Kind) -> Tensor

pub fn prod_dim_int(&self, dim: i64, keepdim: bool, dtype: Kind) -> Tensor

pub fn prod_int_out(
    &self,
    out: &Tensor,
    dim: i64,
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn put(&self, index: &Tensor, source: &Tensor, accumulate: bool) -> Tensor

pub fn put_(
    &mut self,
    index: &Tensor,
    source: &Tensor,
    accumulate: bool
) -> Tensor

pub fn q_per_channel_axis(&self) -> i64

pub fn q_per_channel_scales(&self) -> Tensor

pub fn q_per_channel_zero_points(&self) -> Tensor

pub fn q_scale(&self) -> f64

pub fn q_zero_point(&self) -> i64

pub fn qr(&self, some: bool) -> (Tensor, Tensor)

pub fn qr_q(&self, q: &Tensor, r: &Tensor, some: bool) -> (Tensor, Tensor)

pub fn quantile(
    &self,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn quantile_new(
    &self,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Tensor

pub fn quantile_new_out(
    &self,
    out: &Tensor,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Tensor

pub fn quantile_new_scalar(
    &self,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Tensor

pub fn quantile_new_scalar_out(
    &self,
    out: &Tensor,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool,
    interpolation: &str
) -> Tensor

pub fn quantile_out(
    &self,
    out: &Tensor,
    q: &Tensor,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn quantile_scalar(
    &self,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn quantile_scalar_out(
    &self,
    out: &Tensor,
    q: f64,
    dim: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn quantize_per_channel(
    &self,
    scales: &Tensor,
    zero_points: &Tensor,
    axis: i64,
    dtype: Kind
) -> Tensor

pub fn quantize_per_tensor(
    &self,
    scale: f64,
    zero_point: i64,
    dtype: Kind
) -> Tensor

pub fn quantize_per_tensor_tensors<T: Borrow<Tensor>>(
    tensors: &[T],
    scales: &Tensor,
    zero_points: &Tensor,
    dtype: Kind
) -> Vec<Tensor>

pub fn quantized_batch_norm<T: Borrow<Tensor>>(
    &self,
    weight: Option<T>,
    bias: Option<T>,
    mean: &Tensor,
    var: &Tensor,
    eps: f64,
    output_scale: f64,
    output_zero_point: i64
) -> Tensor

pub fn quantized_gru_cell<S: Into<Scalar>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: &Tensor,
    b_hh: &Tensor,
    packed_ih: &Tensor,
    packed_hh: &Tensor,
    col_offsets_ih: &Tensor,
    col_offsets_hh: &Tensor,
    scale_ih: S,
    scale_hh: S,
    zero_point_ih: S,
    zero_point_hh: S
) -> Tensor

pub fn quantized_lstm_cell<T: Borrow<Tensor>, S: Into<Scalar>>(
    &self,
    hx: &[T],
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: &Tensor,
    b_hh: &Tensor,
    packed_ih: &Tensor,
    packed_hh: &Tensor,
    col_offsets_ih: &Tensor,
    col_offsets_hh: &Tensor,
    scale_ih: S,
    scale_hh: S,
    zero_point_ih: S,
    zero_point_hh: S
) -> (Tensor, Tensor)

pub fn quantized_max_pool1d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Tensor

pub fn quantized_max_pool2d(
    &self,
    kernel_size: &[i64],
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64],
    ceil_mode: bool
) -> Tensor

pub fn quantized_rnn_relu_cell<S: Into<Scalar>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: &Tensor,
    b_hh: &Tensor,
    packed_ih: &Tensor,
    packed_hh: &Tensor,
    col_offsets_ih: &Tensor,
    col_offsets_hh: &Tensor,
    scale_ih: S,
    scale_hh: S,
    zero_point_ih: S,
    zero_point_hh: S
) -> Tensor

pub fn quantized_rnn_tanh_cell<S: Into<Scalar>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: &Tensor,
    b_hh: &Tensor,
    packed_ih: &Tensor,
    packed_hh: &Tensor,
    col_offsets_ih: &Tensor,
    col_offsets_hh: &Tensor,
    scale_ih: S,
    scale_hh: S,
    zero_point_ih: S,
    zero_point_hh: S
) -> Tensor

pub fn rad2deg(&self) -> Tensor

pub fn rad2deg_(&mut self) -> Tensor

pub fn rad2deg_out(&self, out: &Tensor) -> Tensor

pub fn rand(size: &[i64], options: (Kind, Device)) -> Tensor

pub fn rand_like(&self) -> Tensor

pub fn rand_out(out: &Tensor, size: &[i64]) -> Tensor

pub fn randint(high: i64, size: &[i64], options: (Kind, Device)) -> Tensor

pub fn randint_like(&self, high: i64) -> Tensor

pub fn randint_like_low_dtype(&self, low: i64, high: i64) -> Tensor

pub fn randint_low(
    low: i64,
    high: i64,
    size: &[i64],
    options: (Kind, Device)
) -> Tensor

pub fn randint_low_out(
    out: &Tensor,
    low: i64,
    high: i64,
    size: &[i64]
) -> Tensor

pub fn randint_out(out: &Tensor, high: i64, size: &[i64]) -> Tensor

pub fn randn(size: &[i64], options: (Kind, Device)) -> Tensor

pub fn randn_like(&self) -> Tensor

pub fn randn_out(out: &Tensor, size: &[i64]) -> Tensor

pub fn random_(&mut self) -> Tensor

pub fn random_from_(&mut self, from: i64, to: impl Into<Option<i64>>) -> Tensor

pub fn random_to_(&mut self, to: i64) -> Tensor

pub fn randperm(n: i64, options: (Kind, Device)) -> Tensor

pub fn randperm_out(out: &Tensor, n: i64) -> Tensor

pub fn range<S: Into<Scalar>>(
    start: S,
    end: S,
    options: (Kind, Device)
) -> Tensor

pub fn range_out<S: Into<Scalar>>(out: &Tensor, start: S, end: S) -> Tensor

pub fn range_step<S: Into<Scalar>>(
    start: S,
    end: S,
    options: (Kind, Device)
) -> Tensor

pub fn ravel(&self) -> Tensor

pub fn real(&self) -> Tensor

pub fn reciprocal(&self) -> Tensor

pub fn reciprocal_(&mut self) -> Tensor

pub fn reciprocal_out(&self, out: &Tensor) -> Tensor

pub fn reflection_pad1d(&self, padding: &[i64]) -> Tensor

pub fn reflection_pad1d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn reflection_pad1d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn reflection_pad1d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor

pub fn reflection_pad2d(&self, padding: &[i64]) -> Tensor

pub fn reflection_pad2d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn reflection_pad2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn reflection_pad2d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor

pub fn relu(&self) -> Tensor

pub fn relu6(&self) -> Tensor

pub fn relu6_(&mut self) -> Tensor

pub fn relu_(&mut self) -> Tensor

pub fn remainder<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn remainder_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn remainder_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn remainder_tensor(&self, other: &Tensor) -> Tensor

pub fn remainder_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn remainder_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn renorm<S: Into<Scalar>>(&self, p: S, dim: i64, maxnorm: S) -> Tensor

pub fn renorm_<S: Into<Scalar>>(&mut self, p: S, dim: i64, maxnorm: S) -> Tensor

pub fn renorm_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    p: S,
    dim: i64,
    maxnorm: S
) -> Tensor

pub fn repeat(&self, repeats: &[i64]) -> Tensor

pub fn repeat_interleave(repeats: &Tensor) -> Tensor

pub fn repeat_interleave_self_int(
    &self,
    repeats: i64,
    dim: impl Into<Option<i64>>
) -> Tensor

pub fn repeat_interleave_self_tensor(
    &self,
    repeats: &Tensor,
    dim: impl Into<Option<i64>>
) -> Tensor

pub fn replication_pad1d(&self, padding: &[i64]) -> Tensor

pub fn replication_pad1d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn replication_pad1d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn replication_pad1d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor

pub fn replication_pad2d(&self, padding: &[i64]) -> Tensor

pub fn replication_pad2d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn replication_pad2d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn replication_pad2d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor

pub fn replication_pad3d(&self, padding: &[i64]) -> Tensor

pub fn replication_pad3d_backward(
    &self,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn replication_pad3d_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    padding: &[i64]
) -> Tensor

pub fn replication_pad3d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor

pub fn requires_grad_(&mut self, requires_grad: bool) -> Tensor

pub fn reshape(&self, shape: &[i64]) -> Tensor

pub fn reshape_as(&self, other: &Tensor) -> Tensor

pub fn resize_(&mut self, size: &[i64]) -> Tensor

pub fn resize_as_(&mut self, the_template: &Tensor) -> Tensor

pub fn resize_as_sparse_(&mut self, the_template: &Tensor) -> Tensor

pub fn rnn_relu<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_first: bool
) -> (Tensor, Tensor)

pub fn rnn_relu_cell<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: Option<T>,
    b_hh: Option<T>
) -> Tensor

pub fn rnn_relu_data<T: Borrow<Tensor>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool
) -> (Tensor, Tensor)

pub fn rnn_tanh<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool,
    batch_first: bool
) -> (Tensor, Tensor)

pub fn rnn_tanh_cell<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: Option<T>,
    b_hh: Option<T>
) -> Tensor

pub fn rnn_tanh_data<T: Borrow<Tensor>>(
    data: &Tensor,
    batch_sizes: &Tensor,
    hx: &Tensor,
    params: &[T],
    has_biases: bool,
    num_layers: i64,
    dropout: f64,
    train: bool,
    bidirectional: bool
) -> (Tensor, Tensor)

pub fn roll(&self, shifts: &[i64], dims: &[i64]) -> Tensor

pub fn rot90(&self, k: i64, dims: &[i64]) -> Tensor

pub fn round(&self) -> Tensor

pub fn round_(&mut self) -> Tensor

pub fn round_out(&self, out: &Tensor) -> Tensor

pub fn row_stack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn row_stack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor

pub fn rrelu(&self, training: bool) -> Tensor

pub fn rrelu_(&mut self, training: bool) -> Tensor

pub fn rrelu_with_noise(&self, noise: &Tensor, training: bool) -> Tensor

pub fn rrelu_with_noise_(&mut self, noise: &Tensor, training: bool) -> Tensor

pub fn rrelu_with_noise_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    noise: &Tensor,
    lower: S,
    upper: S,
    training: bool,
    self_is_result: bool
) -> Tensor

pub fn rrelu_with_noise_out(
    &self,
    out: &Tensor,
    noise: &Tensor,
    training: bool
) -> Tensor

pub fn rsqrt(&self) -> Tensor

pub fn rsqrt_(&mut self) -> Tensor

pub fn rsqrt_out(&self, out: &Tensor) -> Tensor

pub fn rsub(&self, other: &Tensor) -> Tensor

pub fn rsub_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn scalar_tensor<S: Into<Scalar>>(s: S, options: (Kind, Device)) -> Tensor

pub fn scatter(&self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor

pub fn scatter_(&mut self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor

pub fn scatter_add(&self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor

pub fn scatter_add_(&mut self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor

pub fn scatter_reduce_(
    &mut self,
    dim: i64,
    index: &Tensor,
    src: &Tensor,
    reduce: &str
) -> Tensor

pub fn scatter_value<S: Into<Scalar>>(
    &self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Tensor

pub fn scatter_value_<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Tensor

pub fn scatter_value_reduce_<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S,
    reduce: &str
) -> Tensor

pub fn searchsorted(
    &self,
    sorted_sequence: &Tensor,
    out_int32: bool,
    right: bool
) -> Tensor

pub fn searchsorted_scalar<S: Into<Scalar>>(
    sorted_sequence: &Tensor,
    self_scalar: S,
    out_int32: bool,
    right: bool
) -> Tensor

pub fn searchsorted_tensor_out(
    &self,
    out: &Tensor,
    sorted_sequence: &Tensor,
    out_int32: bool,
    right: bool
) -> Tensor

pub fn segment_reduce<T: Borrow<Tensor>, S: Into<Scalar>>(
    data: &Tensor,
    reduce: &str,
    lengths: Option<T>,
    indices: Option<T>,
    axis: i64,
    unsafe_: bool,
    initial: S
) -> Tensor

pub fn segment_reduce_backward<T: Borrow<Tensor>>(
    grad: &Tensor,
    output: &Tensor,
    data: &Tensor,
    lengths: Option<T>
) -> Tensor

pub fn select(&self, dim: i64, index: i64) -> Tensor

pub fn select_backward(
    grad: &Tensor,
    input_sizes: &[i64],
    dim: i64,
    index: i64
) -> Tensor

pub fn selu(&self) -> Tensor

pub fn selu_(&mut self) -> Tensor

pub fn set_(&mut self) -> Tensor

pub fn set_requires_grad(&self, r: bool) -> Tensor

pub fn set_source_tensor_(&mut self, source: &Tensor) -> Tensor

pub fn sgn(&self) -> Tensor

pub fn sgn_(&mut self) -> Tensor

pub fn sgn_out(&self, out: &Tensor) -> Tensor

pub fn sigmoid(&self) -> Tensor

pub fn sigmoid_(&mut self) -> Tensor

pub fn sigmoid_backward(grad_output: &Tensor, output: &Tensor) -> Tensor

pub fn sigmoid_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output: &Tensor
) -> Tensor

pub fn sigmoid_out(&self, out: &Tensor) -> Tensor

pub fn sign(&self) -> Tensor

pub fn sign_(&mut self) -> Tensor

pub fn sign_out(&self, out: &Tensor) -> Tensor

pub fn signbit(&self) -> Tensor

pub fn signbit_out(&self, out: &Tensor) -> Tensor

pub fn silu(&self) -> Tensor

pub fn silu_(&mut self) -> Tensor

pub fn silu_backward(&self, grad_output: &Tensor) -> Tensor

pub fn silu_out(&self, out: &Tensor) -> Tensor

pub fn sin(&self) -> Tensor

pub fn sin_(&mut self) -> Tensor

pub fn sin_out(&self, out: &Tensor) -> Tensor

pub fn sinc(&self) -> Tensor

pub fn sinc_(&mut self) -> Tensor

pub fn sinc_out(&self, out: &Tensor) -> Tensor

pub fn sinh(&self) -> Tensor

pub fn sinh_(&mut self) -> Tensor

pub fn sinh_out(&self, out: &Tensor) -> Tensor

pub fn slice(
    &self,
    dim: i64,
    start: impl Into<Option<i64>>,
    end: impl Into<Option<i64>>,
    step: i64
) -> Tensor

pub fn slice_backward(
    grad: &Tensor,
    input_sizes: &[i64],
    dim: i64,
    start: i64,
    end: i64,
    step: i64
) -> Tensor

pub fn slogdet(&self) -> (Tensor, Tensor)

pub fn slow_conv3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64]
) -> Tensor

pub fn slow_conv3d_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64]
) -> Tensor

pub fn slow_conv_dilated2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64]
) -> Tensor

pub fn slow_conv_dilated3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    dilation: &[i64]
) -> Tensor

pub fn slow_conv_transpose2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    dilation: &[i64]
) -> Tensor

pub fn slow_conv_transpose2d_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    dilation: &[i64]
) -> Tensor

pub fn slow_conv_transpose3d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    dilation: &[i64]
) -> Tensor

pub fn slow_conv_transpose3d_out<T: Borrow<Tensor>>(
    &self,
    out: &Tensor,
    weight: &Tensor,
    kernel_size: &[i64],
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    output_padding: &[i64],
    dilation: &[i64]
) -> Tensor

pub fn smm(&self, mat2: &Tensor) -> Tensor

pub fn smooth_l1_loss(
    &self,
    target: &Tensor,
    reduction: Reduction,
    beta: f64
) -> Tensor

pub fn smooth_l1_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    beta: f64
) -> Tensor

pub fn smooth_l1_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    beta: f64
) -> Tensor

pub fn smooth_l1_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction,
    beta: f64
) -> Tensor

pub fn soft_margin_loss(&self, target: &Tensor, reduction: Reduction) -> Tensor

pub fn soft_margin_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn soft_margin_loss_backward_grad_input(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn soft_margin_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn softmax(&self, dim: i64, dtype: Kind) -> Tensor

pub fn softplus(&self) -> Tensor

pub fn softplus_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    beta: S,
    threshold: S,
    output: &Tensor
) -> Tensor

pub fn softplus_backward_grad_input<S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    beta: S,
    threshold: S,
    output: &Tensor
) -> Tensor

pub fn softplus_out(&self, out: &Tensor) -> Tensor

pub fn softshrink(&self) -> Tensor

pub fn softshrink_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    lambd: S
) -> Tensor

pub fn softshrink_backward_grad_input<S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    lambd: S
) -> Tensor

pub fn softshrink_out(&self, out: &Tensor) -> Tensor

pub fn solve(&self, a: &Tensor) -> (Tensor, Tensor)

pub fn solve_solution(
    &self,
    solution: &Tensor,
    lu: &Tensor,
    a: &Tensor
) -> (Tensor, Tensor)

pub fn sort(&self, dim: i64, descending: bool) -> (Tensor, Tensor)

pub fn sort_stable(
    &self,
    stable: bool,
    dim: i64,
    descending: bool
) -> (Tensor, Tensor)

pub fn sort_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    descending: bool
) -> (Tensor, Tensor)

pub fn sort_values_stable(
    &self,
    values: &Tensor,
    indices: &Tensor,
    stable: bool,
    dim: i64,
    descending: bool
) -> (Tensor, Tensor)

pub fn sparse_coo_tensor(size: &[i64], options: (Kind, Device)) -> Tensor

pub fn sparse_coo_tensor_indices(
    indices: &Tensor,
    values: &Tensor,
    options: (Kind, Device)
) -> Tensor

pub fn sparse_coo_tensor_indices_size(
    indices: &Tensor,
    values: &Tensor,
    size: &[i64],
    options: (Kind, Device)
) -> Tensor

pub fn sparse_dim(&self) -> i64

pub fn sparse_mask(&self, mask: &Tensor) -> Tensor

pub fn sparse_resize_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Tensor

pub fn sparse_resize_and_clear_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Tensor

pub fn special_entr(&self) -> Tensor

pub fn special_entr_out(&self, out: &Tensor) -> Tensor

pub fn special_erf(&self) -> Tensor

pub fn special_erf_out(&self, out: &Tensor) -> Tensor

pub fn special_erfc(&self) -> Tensor

pub fn special_erfc_out(&self, out: &Tensor) -> Tensor

pub fn special_erfinv(&self) -> Tensor

pub fn special_erfinv_out(&self, out: &Tensor) -> Tensor

pub fn special_exp2(&self) -> Tensor

pub fn special_exp2_out(&self, out: &Tensor) -> Tensor

pub fn special_expit(&self) -> Tensor

pub fn special_expit_out(&self, out: &Tensor) -> Tensor

pub fn special_expm1(&self) -> Tensor

pub fn special_expm1_out(&self, out: &Tensor) -> Tensor

pub fn special_gammaln(&self) -> Tensor

pub fn special_gammaln_out(&self, out: &Tensor) -> Tensor

pub fn special_i0e(&self) -> Tensor

pub fn special_i0e_out(&self, out: &Tensor) -> Tensor

pub fn special_logit(&self, eps: impl Into<Option<f64>>) -> Tensor

pub fn special_logit_out(
    &self,
    out: &Tensor,
    eps: impl Into<Option<f64>>
) -> Tensor

pub fn special_xlog1py(&self, other: &Tensor) -> Tensor

pub fn special_xlog1py_other_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn special_xlog1py_other_scalar_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn special_xlog1py_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn special_xlog1py_self_scalar<S: Into<Scalar>>(
    self_scalar: S,
    other: &Tensor
) -> Tensor

pub fn special_xlog1py_self_scalar_out<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    other: &Tensor
) -> Tensor

pub fn split(&self, split_size: i64, dim: i64) -> Vec<Tensor>

pub fn split_with_sizes(&self, split_sizes: &[i64], dim: i64) -> Vec<Tensor>

pub fn sqrt(&self) -> Tensor

pub fn sqrt_(&mut self) -> Tensor

pub fn sqrt_out(&self, out: &Tensor) -> Tensor

pub fn square(&self) -> Tensor

pub fn square_(&mut self) -> Tensor

pub fn square_out(&self, out: &Tensor) -> Tensor

pub fn squeeze(&self) -> Tensor

pub fn squeeze_(&mut self) -> Tensor

pub fn squeeze_dim(&self, dim: i64) -> Tensor

pub fn squeeze_dim_(&mut self, dim: i64) -> Tensor

pub fn sspaddmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn sspaddmm_out(&self, out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn stack<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor

pub fn stack_out<T: Borrow<Tensor>>(
    out: &Tensor,
    tensors: &[T],
    dim: i64
) -> Tensor

pub fn std(&self, unbiased: bool) -> Tensor

pub fn std_correction<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn std_correction_out<'a>(
    &self,
    out: &Tensor,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn std_dim(&self, dim: &[i64], unbiased: bool, keepdim: bool) -> Tensor

pub fn std_mean(&self, unbiased: bool) -> (Tensor, Tensor)

pub fn std_mean_correction<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn std_mean_dim(
    &self,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn std_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> Tensor

pub fn stft<T: Borrow<Tensor>>(
    &self,
    n_fft: i64,
    hop_length: impl Into<Option<i64>>,
    win_length: impl Into<Option<i64>>,
    window: Option<T>,
    normalized: bool,
    onesided: bool,
    return_complex: bool
) -> Tensor

pub fn g_sub(&self, other: &Tensor) -> Tensor

pub fn g_sub_(&mut self, other: &Tensor) -> Tensor

pub fn sub_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn g_sub_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_sub_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn subtract(&self, other: &Tensor) -> Tensor

pub fn subtract_(&mut self, other: &Tensor) -> Tensor

pub fn subtract_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn subtract_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn subtract_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn sum(&self, dtype: Kind) -> Tensor

pub fn sum_dim_intlist(&self, dim: &[i64], keepdim: bool, dtype: Kind) -> Tensor

pub fn sum_intlist_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn sum_to_size(&self, size: &[i64]) -> Tensor

pub fn svd(&self, some: bool, compute_uv: bool) -> (Tensor, Tensor, Tensor)

pub fn svd_u(
    &self,
    u: &Tensor,
    s: &Tensor,
    v: &Tensor,
    some: bool,
    compute_uv: bool
) -> (Tensor, Tensor, Tensor)

pub fn swapaxes(&self, axis0: i64, axis1: i64) -> Tensor

pub fn swapaxes_(&mut self, axis0: i64, axis1: i64) -> Tensor

pub fn swapdims(&self, dim0: i64, dim1: i64) -> Tensor

pub fn swapdims_(&mut self, dim0: i64, dim1: i64) -> Tensor

pub fn symeig(&self, eigenvectors: bool, upper: bool) -> (Tensor, Tensor)

pub fn symeig_e(
    &self,
    e: &Tensor,
    v: &Tensor,
    eigenvectors: bool,
    upper: bool
) -> (Tensor, Tensor)

pub fn tr(&self) -> Tensor

pub fn t_(&mut self) -> Tensor

pub fn take(&self, index: &Tensor) -> Tensor

pub fn take_along_dim(
    &self,
    indices: &Tensor,
    dim: impl Into<Option<i64>>
) -> Tensor

pub fn take_along_dim_out(
    &self,
    out: &Tensor,
    indices: &Tensor,
    dim: impl Into<Option<i64>>
) -> Tensor

pub fn take_out(&self, out: &Tensor, index: &Tensor) -> Tensor

pub fn tan(&self) -> Tensor

pub fn tan_(&mut self) -> Tensor

pub fn tan_out(&self, out: &Tensor) -> Tensor

pub fn tanh(&self) -> Tensor

pub fn tanh_(&mut self) -> Tensor

pub fn tanh_backward(grad_output: &Tensor, output: &Tensor) -> Tensor

pub fn tanh_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output: &Tensor
) -> Tensor

pub fn tanh_out(&self, out: &Tensor) -> Tensor

pub fn tensor_split(&self, sections: i64, dim: i64) -> Vec<Tensor>

pub fn tensor_split_indices(&self, indices: &[i64], dim: i64) -> Vec<Tensor>

pub fn tensor_split_tensor_indices_or_sections(
    &self,
    tensor_indices_or_sections: &Tensor,
    dim: i64
) -> Vec<Tensor>

pub fn tensordot(
    &self,
    other: &Tensor,
    dims_self: &[i64],
    dims_other: &[i64]
) -> Tensor

pub fn tensordot_out(
    &self,
    out: &Tensor,
    other: &Tensor,
    dims_self: &[i64],
    dims_other: &[i64]
) -> Tensor

pub fn threshold<S: Into<Scalar>>(&self, threshold: S, value: S) -> Tensor

pub fn threshold_<S: Into<Scalar>>(&mut self, threshold: S, value: S) -> Tensor

pub fn threshold_backward<S: Into<Scalar>>(
    &self,
    grad_output: &Tensor,
    threshold: S
) -> Tensor

pub fn threshold_backward_grad_input<S: Into<Scalar>>(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    threshold: S
) -> Tensor

pub fn threshold_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    threshold: S,
    value: S
) -> Tensor

pub fn tile(&self, dims: &[i64]) -> Tensor

pub fn to(&self, device: Device) -> Tensor

pub fn to_dense(&self, dtype: Kind) -> Tensor

pub fn to_dense_backward(&self, grad: &Tensor) -> Tensor

pub fn to_device_(
    &self,
    device: Device,
    dtype: Kind,
    non_blocking: bool,
    copy: bool
) -> Tensor

pub fn to_dtype(&self, dtype: Kind, non_blocking: bool, copy: bool) -> Tensor

pub fn to_dtype_layout(
    &self,
    options: (Kind, Device),
    non_blocking: bool,
    copy: bool
) -> Tensor

pub fn g_to_mkldnn(&self, dtype: Kind) -> Tensor

pub fn to_mkldnn_backward(&self, grad: &Tensor) -> Tensor

pub fn to_other(&self, other: &Tensor, non_blocking: bool, copy: bool) -> Tensor

pub fn to_sparse(&self) -> Tensor

pub fn to_sparse_sparse_dim(&self, sparse_dim: i64) -> Tensor

pub fn topk(
    &self,
    k: i64,
    dim: i64,
    largest: bool,
    sorted: bool
) -> (Tensor, Tensor)

pub fn topk_values(
    &self,
    values: &Tensor,
    indices: &Tensor,
    k: i64,
    dim: i64,
    largest: bool,
    sorted: bool
) -> (Tensor, Tensor)

pub fn totype(&self, scalar_type: Kind) -> Tensor

pub fn trace(&self) -> Tensor

pub fn trace_backward(grad: &Tensor, sizes: &[i64]) -> Tensor

pub fn transpose(&self, dim0: i64, dim1: i64) -> Tensor

pub fn transpose_(&mut self, dim0: i64, dim1: i64) -> Tensor

pub fn trapz(y: &Tensor, x: &Tensor, dim: i64) -> Tensor

pub fn trapz_dx(y: &Tensor, dx: f64, dim: i64) -> Tensor

pub fn triangular_solve(
    &self,
    a: &Tensor,
    upper: bool,
    transpose: bool,
    unitriangular: bool
) -> (Tensor, Tensor)

pub fn triangular_solve_x(
    &self,
    x: &Tensor,
    m: &Tensor,
    a: &Tensor,
    upper: bool,
    transpose: bool,
    unitriangular: bool
) -> (Tensor, Tensor)

pub fn tril(&self, diagonal: i64) -> Tensor

pub fn tril_(&mut self, diagonal: i64) -> Tensor

pub fn tril_indices(
    row: i64,
    col: i64,
    offset: i64,
    options: (Kind, Device)
) -> Tensor

pub fn tril_out(&self, out: &Tensor, diagonal: i64) -> Tensor

pub fn triplet_margin_loss(
    anchor: &Tensor,
    positive: &Tensor,
    negative: &Tensor,
    margin: f64,
    p: f64,
    eps: f64,
    swap: bool,
    reduction: Reduction
) -> Tensor

pub fn triu(&self, diagonal: i64) -> Tensor

pub fn triu_(&mut self, diagonal: i64) -> Tensor

pub fn triu_indices(
    row: i64,
    col: i64,
    offset: i64,
    options: (Kind, Device)
) -> Tensor

pub fn triu_out(&self, out: &Tensor, diagonal: i64) -> Tensor

pub fn true_divide(&self, other: &Tensor) -> Tensor

pub fn true_divide_(&mut self, other: &Tensor) -> Tensor

pub fn true_divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn true_divide_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn true_divide_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn trunc(&self) -> Tensor

pub fn trunc_(&mut self) -> Tensor

pub fn trunc_out(&self, out: &Tensor) -> Tensor

pub fn type_as(&self, other: &Tensor) -> Tensor

pub fn unbind(&self, dim: i64) -> Vec<Tensor>

pub fn unflatten(&self, dim: i64, sizes: &[i64]) -> Tensor

pub fn unflatten_dense_tensors<T: Borrow<Tensor>>(
    flat: &Tensor,
    tensors: &[T]
) -> Vec<Tensor>

pub fn unfold(&self, dimension: i64, size: i64, step: i64) -> Tensor

pub fn unfold_backward(
    grad_in: &Tensor,
    input_sizes: &[i64],
    dim: i64,
    size: i64,
    step: i64
) -> Tensor

pub fn uniform_(&mut self, from: f64, to: f64) -> Tensor

pub fn unique_consecutive(
    &self,
    return_inverse: bool,
    return_counts: bool,
    dim: impl Into<Option<i64>>
) -> (Tensor, Tensor, Tensor)

pub fn unique_dim(
    &self,
    dim: i64,
    sorted: bool,
    return_inverse: bool,
    return_counts: bool
) -> (Tensor, Tensor, Tensor)

pub fn unique_dim_consecutive(
    &self,
    dim: i64,
    return_inverse: bool,
    return_counts: bool
) -> (Tensor, Tensor, Tensor)

pub fn unsafe_chunk(&self, chunks: i64, dim: i64) -> Vec<Tensor>

pub fn unsafe_split(&self, split_size: i64, dim: i64) -> Vec<Tensor>

pub fn unsafe_split_with_sizes(
    &self,
    split_sizes: &[i64],
    dim: i64
) -> Vec<Tensor>

pub fn unsqueeze(&self, dim: i64) -> Tensor

pub fn unsqueeze_(&mut self, dim: i64) -> Tensor

pub fn upsample_bicubic2d(
    &self,
    output_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_bicubic2d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_bicubic2d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_bicubic2d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    align_corners: bool,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_bicubic2d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_bicubic2d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    align_corners: bool,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_bilinear2d(
    &self,
    output_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_bilinear2d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_bilinear2d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_bilinear2d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    align_corners: bool,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_bilinear2d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_bilinear2d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    align_corners: bool,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_linear1d(
    &self,
    output_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_linear1d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_linear1d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_linear1d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    align_corners: bool,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_linear1d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_linear1d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    align_corners: bool,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_nearest1d(
    &self,
    output_size: &[i64],
    scales: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest1d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest1d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest1d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_nearest1d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    scales: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest1d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_nearest2d(
    &self,
    output_size: &[i64],
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest2d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest2d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest2d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_nearest2d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest2d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_nearest3d(
    &self,
    output_size: &[i64],
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest3d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest3d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest3d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_nearest3d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest3d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_trilinear3d(
    &self,
    output_size: &[i64],
    align_corners: bool,
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_trilinear3d_backward(
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_trilinear3d_backward_grad_input(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    align_corners: bool,
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_trilinear3d_backward_vec<'a>(
    grad_output: &Tensor,
    output_size: impl Into<Option<&'a [i64]>>,
    input_size: &[i64],
    align_corners: bool,
    scale_factors: &[f64]
) -> Tensor

pub fn upsample_trilinear3d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales_d: impl Into<Option<f64>>,
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_trilinear3d_vec<'a>(
    &self,
    output_size: impl Into<Option<&'a [i64]>>,
    align_corners: bool,
    scale_factors: &[f64]
) -> Tensor

pub fn value_selecting_reduction_backward(
    grad: &Tensor,
    dim: i64,
    indices: &Tensor,
    sizes: &[i64],
    keepdim: bool
) -> Tensor

pub fn values(&self) -> Tensor

pub fn vander(x: &Tensor, n: impl Into<Option<i64>>, increasing: bool) -> Tensor

pub fn var(&self, unbiased: bool) -> Tensor

pub fn var_correction<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn var_correction_out<'a>(
    &self,
    out: &Tensor,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> Tensor

pub fn var_dim(&self, dim: &[i64], unbiased: bool, keepdim: bool) -> Tensor

pub fn var_mean(&self, unbiased: bool) -> (Tensor, Tensor)

pub fn var_mean_correction<'a>(
    &self,
    dim: impl Into<Option<&'a [i64]>>,
    correction: impl Into<Option<i64>>,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn var_mean_dim(
    &self,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn var_out(
    &self,
    out: &Tensor,
    dim: &[i64],
    unbiased: bool,
    keepdim: bool
) -> Tensor

pub fn vdot(&self, other: &Tensor) -> Tensor

pub fn vdot_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn view_(&self, size: &[i64]) -> Tensor

pub fn view_as(&self, other: &Tensor) -> Tensor

pub fn view_as_complex(&self) -> Tensor

pub fn view_as_real(&self) -> Tensor

pub fn view_dtype(&self, dtype: Kind) -> Tensor

pub fn vsplit(&self, sections: i64) -> Vec<Tensor>

pub fn vsplit_array(&self, indices: &[i64]) -> Vec<Tensor>

pub fn vstack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn vstack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor

pub fn where_(condition: &Tensor) -> Vec<Tensor>

pub fn where_scalar<S: Into<Scalar>>(
    condition: &Tensor,
    self_scalar: S,
    other: S
) -> Tensor

pub fn where_scalarother<S: Into<Scalar>>(
    &self,
    condition: &Tensor,
    other: S
) -> Tensor

pub fn where_scalarself<S: Into<Scalar>>(
    condition: &Tensor,
    self_scalar: S,
    other: &Tensor
) -> Tensor

pub fn where_self(&self, condition: &Tensor, other: &Tensor) -> Tensor

pub fn xlogy(&self, other: &Tensor) -> Tensor

pub fn xlogy_(&mut self, other: &Tensor) -> Tensor

pub fn xlogy_outscalar_other<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> Tensor

pub fn xlogy_outscalar_self<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    other: &Tensor
) -> Tensor

pub fn xlogy_outtensor(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn xlogy_scalar_other<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn xlogy_scalar_other_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn xlogy_scalar_self<S: Into<Scalar>>(
    self_scalar: S,
    other: &Tensor
) -> Tensor

pub fn zero_(&mut self) -> Tensor

pub fn zeros(size: &[i64], options: (Kind, Device)) -> Tensor

pub fn zeros_like(&self) -> Tensor

pub fn zeros_out(out: &Tensor, size: &[i64]) -> Tensor

impl Tensor

pub fn iter<T>(&self) -> Result<Iter<T>, TchError>

impl Tensor

pub fn read_npy<T: AsRef<Path>>(path: T) -> Result<Tensor, TchError>

Reads a npy file and return the stored tensor.

pub fn read_npz<T: AsRef<Path>>(
    path: T
) -> Result<Vec<(String, Tensor)>, TchError>

Reads a npz file and returns some named tensors.

pub fn write_npy<T: AsRef<Path>>(&self, path: T) -> Result<(), TchError>

Writes a tensor in the npy format so that it can be read using python.

pub fn write_npz<S: AsRef<str>, T: AsRef<Tensor>, P: AsRef<Path>>(
    ts: &[(S, T)],
    path: P
) -> Result<(), TchError>

impl Tensor

pub fn f_view<T: Shape>(&self, s: T) -> Result<Tensor, TchError>

pub fn view<T: Shape>(&self, s: T) -> Tensor

pub fn f_zero_pad1d(&self, left: i64, right: i64) -> Result<Tensor, TchError>

pub fn zero_pad1d(&self, left: i64, right: i64) -> Tensor

pub fn f_zero_pad2d(
    &self,
    left: i64,
    right: i64,
    top: i64,
    bottom: i64
) -> Result<Tensor, TchError>

pub fn zero_pad2d(&self, left: i64, right: i64, top: i64, bottom: i64) -> Tensor

impl Tensor

pub fn to_kind(&self, kind: Kind) -> Tensor

Casts a tensor to a specified kind.

pub fn f_to_kind(&self, kind: Kind) -> Result<Tensor, TchError>

pub fn nll_loss(&self, targets: &Tensor) -> Tensor

impl Tensor

pub fn cross_entropy_for_logits(&self, targets: &Tensor) -> Tensor

Computes the cross-entropy loss based on some logits and targets.

pub fn accuracy_for_logits(&self, targets: &Tensor) -> Tensor

Returns the average accuracy for some given logits assuming that targets represent ground-truth.

pub fn random_batch(&self, batch_size: i64) -> Tensor

pub fn random_batch2(
    t1: &Tensor,
    t2: &Tensor,
    batch_size: i64
) -> (Tensor, Tensor)

pub fn to_device(&self, device: Device) -> Tensor

Moves a tensor to a specified device.

pub fn f_to_device(&self, device: Device) -> Result<Tensor, TchError>

pub fn avg_pool2d_default(&self, ksize: i64) -> Tensor

pub fn max_pool2d_default(&self, ksize: i64) -> Tensor

pub fn flat_view(&self) -> Tensor

Flattens a tensor.

This returns a flattened version of the given tensor. The first dimension is preserved as it is assumed to be the mini-batch dimension.

pub fn onehot(&self, labels: i64) -> Tensor

Converts a tensor to a one-hot encoded version.

If the input has a size [N1, N2, …, Nk], the returned tensor has a size [N1, …, Nk, labels]. The returned tensor uses float values. Elements of the input vector are expected to be between 0 and labels-1.

pub fn copy(&self) -> Tensor

Copies a tensor to a newly allocated tensor using the same shape and device.

pub fn of_slice2<T, U>(v: &[U]) -> Tensor where
    T: Element,
    U: AsRef<[T]>, 

pub fn to_mkldnn(&self) -> Tensor

impl Tensor

pub fn init(&mut self, i: Init)

Re-initializes the tensor using the specified initialization.

impl Tensor

pub fn apply<M: Module>(&self, m: &M) -> Tensor

pub fn apply_t<M: ModuleT>(&self, m: &M, train: bool) -> Tensor

pub fn apply_opt<M: Module>(&self, m: &Option<M>) -> Tensor

pub fn apply_opt_t<M: ModuleT>(&self, m: &Option<M>, train: bool) -> Tensor

Trait Implementations

impl Add<&'_ Tensor> for Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Self::Output

Performs the + operation.

impl<'a> Add<&'_ Tensor> for &'a Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Self::Output

Performs the + operation.

impl Add<&'_ Tensor> for i32

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Self::Output

Performs the + operation.

impl Add<&'_ Tensor> for i64

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Self::Output

Performs the + operation.

impl Add<&'_ Tensor> for f32

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Self::Output

Performs the + operation.

impl Add<&'_ Tensor> for f64

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Self::Output

Performs the + operation.

impl<S> Add<S> for &Tensor where
    S: Into<Scalar>, 

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: S) -> Self::Output

Performs the + operation.

impl<S> Add<S> for Tensor where
    S: Into<Scalar>, 

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: S) -> Self::Output

Performs the + operation.

impl Add<Tensor> for Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: Tensor) -> Self::Output

Performs the + operation.

impl Add<Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: Tensor) -> Self::Output

Performs the + operation.

impl Add<Tensor> for i32

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: Tensor) -> Self::Output

Performs the + operation.

impl Add<Tensor> for i64

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: Tensor) -> Self::Output

Performs the + operation.

impl Add<Tensor> for f32

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: Tensor) -> Self::Output

Performs the + operation.

impl Add<Tensor> for f64

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: Tensor) -> Self::Output

Performs the + operation.

impl AddAssign<&'_ Tensor> for Tensor

fn add_assign(&mut self, rhs: &Tensor)

Performs the += operation.

impl AddAssign<Tensor> for Tensor

fn add_assign(&mut self, rhs: Tensor)

Performs the += operation.

impl AddAssign<f32> for Tensor

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl AddAssign<f64> for Tensor

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

impl AddAssign<i32> for Tensor

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<i64> for Tensor

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl AsRef<Tensor> for Tensor

fn as_ref(&self) -> &Self

Performs the conversion.

impl Debug for Tensor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Tensor

fn default() -> Self

Returns the “default value” for a type.

impl Div<&'_ Tensor> for Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Self::Output

Performs the / operation.

impl<'a> Div<&'_ Tensor> for &'a Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Self::Output

Performs the / operation.

impl Div<&'_ Tensor> for i32

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Self::Output

Performs the / operation.

impl Div<&'_ Tensor> for i64

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Self::Output

Performs the / operation.

impl Div<&'_ Tensor> for f32

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Self::Output

Performs the / operation.

impl Div<&'_ Tensor> for f64

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Self::Output

Performs the / operation.

impl<S> Div<S> for &Tensor where
    S: Into<Scalar>, 

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: S) -> Self::Output

Performs the / operation.

impl<S> Div<S> for Tensor where
    S: Into<Scalar>, 

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: S) -> Self::Output

Performs the / operation.

impl Div<Tensor> for Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: Tensor) -> Self::Output

Performs the / operation.

impl Div<Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: Tensor) -> Self::Output

Performs the / operation.

impl Div<Tensor> for i32

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: Tensor) -> Self::Output

Performs the / operation.

impl Div<Tensor> for i64

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: Tensor) -> Self::Output

Performs the / operation.

impl Div<Tensor> for f32

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: Tensor) -> Self::Output

Performs the / operation.

impl Div<Tensor> for f64

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: Tensor) -> Self::Output

Performs the / operation.

impl DivAssign<&'_ Tensor> for Tensor

fn div_assign(&mut self, rhs: &Tensor)

Performs the /= operation.

impl DivAssign<Tensor> for Tensor

fn div_assign(&mut self, rhs: Tensor)

Performs the /= operation.

impl DivAssign<f32> for Tensor

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl DivAssign<f64> for Tensor

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl DivAssign<i32> for Tensor

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<i64> for Tensor

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl Drop for Tensor

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Element> From<&'_ [T]> for Tensor

fn from(v: &[T]) -> Tensor

Performs the conversion.

impl<T: Element> From<&'_ Tensor> for Vec<T>

fn from(tensor: &Tensor) -> Vec<T>

Performs the conversion.

impl<T: Element> From<&'_ Tensor> for Vec<Vec<T>>

fn from(tensor: &Tensor) -> Vec<Vec<T>>

Performs the conversion.

impl From<&'_ Tensor> for bool

fn from(tensor: &Tensor) -> bool

Performs the conversion.

impl From<&'_ Tensor> for TensorIndexer

fn from(tensor: &Tensor) -> Self

Performs the conversion.

impl<T: Element> From<&'_ Tensor> for Vec<Vec<Vec<T>>>

fn from(tensor: &Tensor) -> Vec<Vec<Vec<T>>>

Performs the conversion.

impl From<&'_ Tensor> for f64

fn from(tensor: &Tensor) -> f64

Performs the conversion.

impl From<&'_ Tensor> for f32

fn from(tensor: &Tensor) -> f32

Performs the conversion.

impl From<&'_ Tensor> for f16

fn from(tensor: &Tensor) -> f16

Performs the conversion.

impl From<&'_ Tensor> for i64

fn from(tensor: &Tensor) -> i64

Performs the conversion.

impl From<&'_ Tensor> for i32

fn from(tensor: &Tensor) -> i32

Performs the conversion.

impl From<&'_ Tensor> for i8

fn from(tensor: &Tensor) -> i8

Performs the conversion.

impl From<&'_ Tensor> for u8

fn from(tensor: &Tensor) -> u8

Performs the conversion.

impl<T: Element> From<T> for Tensor

fn from(v: T) -> Tensor

Performs the conversion.

impl From<Tensor> for IValue

fn from(v: Tensor) -> Self

Performs the conversion.

impl<T: Element> From<Tensor> for Vec<T>

fn from(tensor: Tensor) -> Vec<T>

Performs the conversion.

impl From<Tensor> for u8

fn from(tensor: Tensor) -> u8

Performs the conversion.

impl From<Tensor> for bool

fn from(tensor: Tensor) -> bool

Performs the conversion.

impl<T: Element> From<Tensor> for Vec<Vec<T>>

fn from(tensor: Tensor) -> Vec<Vec<T>>

Performs the conversion.

impl<T: Element> From<Tensor> for Vec<Vec<Vec<T>>>

fn from(tensor: Tensor) -> Vec<Vec<Vec<T>>>

Performs the conversion.

impl From<Tensor> for f64

fn from(tensor: Tensor) -> f64

Performs the conversion.

impl From<Tensor> for f32

fn from(tensor: Tensor) -> f32

Performs the conversion.

impl From<Tensor> for f16

fn from(tensor: Tensor) -> f16

Performs the conversion.

impl From<Tensor> for i64

fn from(tensor: Tensor) -> i64

Performs the conversion.

impl From<Tensor> for i32

fn from(tensor: Tensor) -> i32

Performs the conversion.

impl From<Tensor> for i8

fn from(tensor: Tensor) -> i8

Performs the conversion.

impl<A, B, C, D, E, F, G> IndexOp<(A, B, C, D, E, F, G)> for Tensor where
    A: Into<TensorIndexer>,
    B: Into<TensorIndexer>,
    C: Into<TensorIndexer>,
    D: Into<TensorIndexer>,
    E: Into<TensorIndexer>,
    F: Into<TensorIndexer>,
    G: Into<TensorIndexer>, 

fn i(&self, index: (A, B, C, D, E, F, G)) -> Tensor

impl<A, B, C, D, E, F> IndexOp<(A, B, C, D, E, F)> for Tensor where
    A: Into<TensorIndexer>,
    B: Into<TensorIndexer>,
    C: Into<TensorIndexer>,
    D: Into<TensorIndexer>,
    E: Into<TensorIndexer>,
    F: Into<TensorIndexer>, 

fn i(&self, index: (A, B, C, D, E, F)) -> Tensor

impl<A, B, C, D, E> IndexOp<(A, B, C, D, E)> for Tensor where
    A: Into<TensorIndexer>,
    B: Into<TensorIndexer>,
    C: Into<TensorIndexer>,
    D: Into<TensorIndexer>,
    E: Into<TensorIndexer>, 

fn i(&self, index: (A, B, C, D, E)) -> Tensor

impl<A, B, C, D> IndexOp<(A, B, C, D)> for Tensor where
    A: Into<TensorIndexer>,
    B: Into<TensorIndexer>,
    C: Into<TensorIndexer>,
    D: Into<TensorIndexer>, 

fn i(&self, index: (A, B, C, D)) -> Tensor

impl<A, B, C> IndexOp<(A, B, C)> for Tensor where
    A: Into<TensorIndexer>,
    B: Into<TensorIndexer>,
    C: Into<TensorIndexer>, 

fn i(&self, index: (A, B, C)) -> Tensor

impl<A, B> IndexOp<(A, B)> for Tensor where
    A: Into<TensorIndexer>,
    B: Into<TensorIndexer>, 

fn i(&self, index: (A, B)) -> Tensor

impl<A> IndexOp<(A,)> for Tensor where
    A: Into<TensorIndexer>, 

fn i(&self, index: (A,)) -> Tensor

impl<A> IndexOp<A> for Tensor where
    A: Into<TensorIndexer>, 

fn i(&self, index: A) -> Tensor

impl Mul<&'_ Tensor> for Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'_ Tensor> for &'a Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Self::Output

Performs the * operation.

impl Mul<&'_ Tensor> for i32

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Self::Output

Performs the * operation.

impl Mul<&'_ Tensor> for i64

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Self::Output

Performs the * operation.

impl Mul<&'_ Tensor> for f32

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Self::Output

Performs the * operation.

impl Mul<&'_ Tensor> for f64

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Self::Output

Performs the * operation.

impl<S> Mul<S> for &Tensor where
    S: Into<Scalar>, 

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: S) -> Self::Output

Performs the * operation.

impl<S> Mul<S> for Tensor where
    S: Into<Scalar>, 

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: S) -> Self::Output

Performs the * operation.

impl Mul<Tensor> for Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor) -> Self::Output

Performs the * operation.

impl Mul<Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor) -> Self::Output

Performs the * operation.

impl Mul<Tensor> for i32

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor) -> Self::Output

Performs the * operation.

impl Mul<Tensor> for i64

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor) -> Self::Output

Performs the * operation.

impl Mul<Tensor> for f32

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor) -> Self::Output

Performs the * operation.

impl Mul<Tensor> for f64

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor) -> Self::Output

Performs the * operation.

impl MulAssign<&'_ Tensor> for Tensor

fn mul_assign(&mut self, rhs: &Tensor)

Performs the *= operation.

impl MulAssign<Tensor> for Tensor

fn mul_assign(&mut self, rhs: Tensor)

Performs the *= operation.

impl MulAssign<f32> for Tensor

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign<f64> for Tensor

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl MulAssign<i32> for Tensor

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i64> for Tensor

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl Neg for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn neg(self) -> Tensor

Performs the unary - operation.

impl Neg for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn neg(self) -> Tensor

Performs the unary - operation.

impl PartialEq<Tensor> for Tensor

fn eq(&self, other: &Tensor) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Sub<&'_ Tensor> for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'_ Tensor> for &'a Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Self::Output

Performs the - operation.

impl Sub<&'_ Tensor> for i32

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Self::Output

Performs the - operation.

impl Sub<&'_ Tensor> for i64

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Self::Output

Performs the - operation.

impl Sub<&'_ Tensor> for f32

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Self::Output

Performs the - operation.

impl Sub<&'_ Tensor> for f64

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Self::Output

Performs the - operation.

impl<S> Sub<S> for &Tensor where
    S: Into<Scalar>, 

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: S) -> Self::Output

Performs the - operation.

impl<S> Sub<S> for Tensor where
    S: Into<Scalar>, 

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: S) -> Self::Output

Performs the - operation.

impl Sub<Tensor> for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor) -> Self::Output

Performs the - operation.

impl Sub<Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor) -> Self::Output

Performs the - operation.

impl Sub<Tensor> for i32

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor) -> Self::Output

Performs the - operation.

impl Sub<Tensor> for i64

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor) -> Self::Output

Performs the - operation.

impl Sub<Tensor> for f32

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor) -> Self::Output

Performs the - operation.

impl Sub<Tensor> for f64

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor) -> Self::Output

Performs the - operation.

impl SubAssign<&'_ Tensor> for Tensor

fn sub_assign(&mut self, rhs: &Tensor)

Performs the -= operation.

impl SubAssign<Tensor> for Tensor

fn sub_assign(&mut self, rhs: Tensor)

Performs the -= operation.

impl SubAssign<f32> for Tensor

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl SubAssign<f64> for Tensor

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl SubAssign<i32> for Tensor

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for Tensor

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<'a> Sum<&'a Tensor> for Tensor

fn sum<I: Iterator<Item = &'a Tensor>>(iter: I) -> Tensor

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum<Tensor> for Tensor

fn sum<I: Iterator<Item = Tensor>>(iter: I) -> Tensor

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, D> TryFrom<&'_ ArrayBase<T, D>> for Tensor where
    T: Data,
    T::Elem: Element,
    D: Dimension, 

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: &ArrayBase<T, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element> TryFrom<&'_ Vec<T, Global>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: &Vec<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, D> TryFrom<ArrayBase<T, D>> for Tensor where
    T: Data,
    T::Elem: Element,
    D: Dimension, 

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: ArrayBase<T, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<IValue> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: IValue) -> Result<Tensor, TchError>

Performs the conversion.

impl<T: Element> TryFrom<Vec<T, Global>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Vec<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element> TryInto<ArrayBase<OwnedRepr<T>, Dim<IxDynImpl>>> for &Tensor

type Error = ShapeError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ArrayD<T>, Self::Error>

Performs the conversion.

impl Send for Tensor