Struct tch::Tensor

#[must_use]pub struct Tensor { /* fields omitted */ }

A tensor object.

Implementations

impl Tensor

pub fn new() -> Tensor

Creates a new tensor.

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 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 is the tensor is defined.

pub fn is_sparse(&self) -> bool

Returns true is the tensor is spare.

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 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 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_1(&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_1(&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_1(
    &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_1(&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_1(
    &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_1(&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_1(
    &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_1(&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_1(
    &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_1(&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_addmv_impl_(
    &mut self,
    self2: &Tensor,
    mat: &Tensor,
    vec: &Tensor
) -> Result<Tensor, TchError>

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

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

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

pub fn f_internal_amp_update_scale(
    growth_tracker: &Tensor,
    current_scale: &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_helper(
    &self,
    upper: bool
) -> Result<Tensor, TchError>

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

pub fn f_internal_coalesced_(
    &mut self,
    coalesced: bool
) -> 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
) -> 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,
    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,
    num_layers: i64,
    batch_first: bool,
    bidirectional: bool
) -> Result<Tensor, 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_dim_arange(
    like: &Tensor,
    dim: i64
) -> Result<Tensor, 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
) -> 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>
) -> Result<Tensor, TchError>

pub fn f_internal_embedding_bag_dense_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,
    per_sample_weights: Option<T>
) -> Result<Tensor, TchError>

pub fn f_internal_embedding_bag_per_sample_weights_backward(
    grad: &Tensor,
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    offset2bag: &Tensor,
    mode: 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>
) -> 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_fft_with_size(
    &self,
    signal_ndim: i64,
    complex_input: bool,
    complex_output: bool,
    inverse: bool,
    checked_signal_sizes: &[i64],
    normalized: bool,
    onesided: bool,
    output_sizes: &[i64]
) -> Result<Tensor, TchError>

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

pub fn f_internal_gather_sparse_backward(
    &self,
    dim: i64,
    index: &Tensor,
    grad: &Tensor
) -> Result<Tensor, 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: &[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_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_solve_helper(
    &self,
    lu_data: &Tensor,
    lu_pivots: &Tensor
) -> 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_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_mode(
    &self,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

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

pub fn f_internal_multinomial_alias_draw(
    j: &Tensor,
    q: &Tensor,
    num_samples: i64
) -> Result<Tensor, TchError>

pub fn f_internal_multinomial_alias_setup(
    probs: &Tensor
) -> Result<(Tensor, Tensor), 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_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_qr_helper(
    &self,
    some: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_reshape_from_tensor(
    &self,
    shape: &Tensor
) -> Result<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_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_log_softmax(
    &self,
    dim: i64,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_internal_sparse_log_softmax1(
    &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_mm(
    sparse: &Tensor,
    dense: &Tensor
) -> Result<Tensor, TchError>

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

pub fn f_internal_sparse_softmax1(
    &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_sum(&self) -> Result<Tensor, TchError>

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

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

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

pub fn f_internal_sparse_sum_backward(
    &self,
    grad: &Tensor,
    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_serialization_subcmul(
    &self,
    other: &Tensor
) -> Result<Tensor, TchError>

pub fn f_internal_triangular_solve_helper(
    &self,
    a: &Tensor,
    upper: bool,
    transpose: bool,
    unitriangular: bool
) -> Result<(Tensor, 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_unsafe_view(&self, size: &[i64]) -> Result<Tensor, TchError>

pub fn f_internal_values(&self) -> Result<Tensor, 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_output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool3d_backward_out(
    &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_out(
    &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_out(
    &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_add1<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

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

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

pub fn f_add_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> 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_all1(&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_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_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_any1(&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_arange1<S: Into<Scalar>>(
    start: S,
    end: S,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_arange2<S: Into<Scalar>>(
    start: S,
    end: S,
    step: 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_out1<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S
) -> Result<Tensor, TchError>

pub fn f_argmax(
    &self,
    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_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_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_out(
    &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_out(
    &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_window1(
    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
) -> 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_bernoulli1(&self, p: f64) -> Result<Tensor, TchError>

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

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

pub fn f_bernoulli_out(&self, out: &Tensor) -> 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_out<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_and1(&self, other: &Tensor) -> Result<Tensor, TchError>

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

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

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

pub fn f_bitwise_and_out1<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> 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_or1(&self, other: &Tensor) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

pub fn f_blackman_window1(
    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_bucketize(
    &self,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Result<Tensor, TchError>

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

pub fn f_bucketize_out(
    &self,
    out: &Tensor,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Result<Tensor, 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_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_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_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_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    min: S,
    max: S
) -> 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_out(
    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_combinations(
    &self,
    r: i64,
    with_replacement: bool
) -> 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_conv2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    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_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_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_cross(
    &self,
    other: &Tensor,
    dim: impl Into<Option<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_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_loss1(
    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
) -> Result<Tensor, TchError>

pub fn f_cudnn_convolution1<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_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_cudnn_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_cudnn_convolution_transpose(
    &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_convolution_transpose1<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_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_cudnn_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_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_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_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_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_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_dequantize(&self) -> Result<Tensor, TchError>

pub fn f_dequantize1<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_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_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_div1<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

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

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

pub fn f_div_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> 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_eig(&self, eigenvectors: bool) -> Result<(Tensor, Tensor), TchError>

pub fn f_eig_out(
    &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,
    output: &Tensor
) -> Result<Tensor, TchError>

pub fn f_elu_backward_out<S: Into<Scalar>>(
    grad_input: &Tensor,
    grad_output: &Tensor,
    alpha: S,
    scale: S,
    input_scale: S,
    output: &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_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_meta(
    size: &[i64],
    options: (Kind, Device)
) -> 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_eq1(&self, other: &Tensor) -> Result<Tensor, TchError>

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

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

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

pub fn f_eq_out1(
    &self,
    out: &Tensor,
    other: &Tensor
) -> Result<Tensor, 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_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_eye1(
    n: i64,
    m: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

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

pub fn f_eye_out1(out: &Tensor, n: i64, m: 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_backward(
    &self,
    grad: &Tensor,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64
) -> 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_backward(
    &self,
    grad: &Tensor,
    scale: f64,
    zero_point: i64,
    quant_min: i64,
    quant_max: i64
) -> 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_matrix1(
    &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(
    &self,
    signal_ndim: i64,
    normalized: bool
) -> Result<Tensor, TchError>

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

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

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

pub fn f_flatten(
    &self,
    start_dim: i64,
    end_dim: i64
) -> 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_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_divide1<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

pub fn f_fmod_out1(
    &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_out(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Result<Tensor, TchError>

pub fn f_fractional_max_pool2d_out(
    &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_out(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Result<Tensor, TchError>

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

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

pub fn f_frobenius_norm1(
    &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_out(
    &self,
    out: &Tensor,
    dim: i64,
    index: &Tensor,
    sparse_grad: bool
) -> Result<Tensor, TchError>

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

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

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

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

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

pub fn f_ge_out1(
    &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_out(
    &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_out(
    &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_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_gru1<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_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_gt<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

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

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

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

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

pub fn f_gt_out1(
    &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_window1(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

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

pub fn f_hamming_window3(
    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_window1(
    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_out<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_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_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_ifft(
    &self,
    signal_ndim: i64,
    normalized: bool
) -> 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_out(
    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: &[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_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_fill1(
    &self,
    dim: i64,
    index: &Tensor,
    value: &Tensor
) -> 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_1(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: &Tensor
) -> Result<Tensor, TchError>

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

pub fn f_index_put_<T: Borrow<Tensor>>(
    &mut self,
    indices: &[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_out(
    &self,
    out: &Tensor,
    dim: i64,
    index: &Tensor
) -> Result<Tensor, TchError>

pub fn f_indices(&self) -> 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_irfft(
    &self,
    signal_ndim: i64,
    normalized: bool,
    onesided: bool,
    signal_sizes: &[i64]
) -> Result<Tensor, 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_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>>
) -> 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_kthvalue(
    &self,
    k: i64,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_kthvalue_out(
    &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_out(
    &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_le<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

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

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

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

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

pub fn f_le_out1(
    &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_lerp1(&self, end: &Tensor, weight: &Tensor) -> Result<Tensor, TchError>

pub fn f_lerp_<S: Into<Scalar>>(
    &mut self,
    end: &Tensor,
    weight: S
) -> Result<Tensor, TchError>

pub fn f_lerp_1(
    &mut self,
    end: &Tensor,
    weight: &Tensor
) -> Result<Tensor, TchError>

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

pub fn f_lerp_out1(
    &self,
    out: &Tensor,
    end: &Tensor,
    weight: &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_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: i64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_linspace_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S,
    steps: 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_out(
    &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_logspace<S: Into<Scalar>>(
    start: S,
    end: S,
    steps: i64,
    base: f64,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_logspace_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S,
    steps: 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_lstm1<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_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_lstsq(&self, a: &Tensor) -> Result<(Tensor, Tensor), TchError>

pub fn f_lstsq_out(
    &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_lt1(&self, other: &Tensor) -> Result<Tensor, TchError>

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

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

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

pub fn f_lt_out1(
    &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_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_fill1(
    &self,
    mask: &Tensor,
    value: &Tensor
) -> 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_1(
    &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_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_power(&self, n: i64) -> Result<Tensor, TchError>

pub fn f_matrix_rank(&self, symmetric: bool) -> Result<Tensor, TchError>

pub fn f_matrix_rank1(
    &self,
    tol: f64,
    symmetric: bool
) -> Result<Tensor, TchError>

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

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

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

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

pub fn f_max_out1(
    &self,
    max: &Tensor,
    max_values: &Tensor,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, 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_out(
    &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_out(
    &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_out(
    &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_out(
    &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_max_values(
    &self,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

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

pub fn f_mean1(
    &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_median1(
    &self,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, Tensor), TchError>

pub fn f_median_out(
    &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_min1(&self, other: &Tensor) -> Result<Tensor, TchError>

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

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

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

pub fn f_min_values(
    &self,
    dim: &[i64],
    keepdim: bool
) -> 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_mkldnn_adaptive_avg_pool2d(
    &self,
    output_size: &[i64]
) -> 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_max_pool2d(
    &self,
    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_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_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> Result<(Tensor, 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_out(
    &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_mul(&self, other: &Tensor) -> Result<Tensor, TchError>

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

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

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

pub fn f_mul_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> 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_out<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_out(
    &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_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_narrow(
    &self,
    dim: i64,
    start: i64,
    length: i64
) -> Result<Tensor, TchError>

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

pub fn f_narrow_copy(
    &self,
    dim: i64,
    start: i64,
    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,
    weight: Option<T>,
    bias: Option<T>,
    m: i64,
    n: i64,
    eps: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>

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

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

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

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

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

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

pub fn f_ne_out1(
    &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_new_empty(
    &self,
    size: &[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_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_out<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_out<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_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_norm1<S: Into<Scalar>>(
    &self,
    p: S,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_norm2<S: Into<Scalar>>(
    &self,
    p: S,
    dim: &[i64],
    keepdim: bool
) -> Result<Tensor, TchError>

pub fn f_norm3<S: Into<Scalar>>(
    &self,
    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_out1<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    p: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

pub fn f_normal_(&mut self, mean: f64, std: f64) -> Result<Tensor, TchError>

pub fn f_normal_out(
    out: &Tensor,
    mean: &Tensor,
    std: f64
) -> Result<Tensor, TchError>

pub fn f_normal_out1(
    out: &Tensor,
    mean: f64,
    std: &Tensor
) -> Result<Tensor, TchError>

pub fn f_normal_out2(
    out: &Tensor,
    mean: &Tensor,
    std: &Tensor
) -> Result<Tensor, TchError>

pub fn f_normal_out3(
    out: &Tensor,
    mean: f64,
    std: f64,
    size: &[i64]
) -> Result<Tensor, TchError>

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

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

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

pub fn f_nuclear_norm_out1(
    &self,
    out: &Tensor,
    dim: &[i64],
    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_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_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_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_pow<S: Into<Scalar>>(&self, exponent: S) -> Result<Tensor, TchError>

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

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

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

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

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

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

pub fn f_pow_out2<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    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_prod1(
    &self,
    dim: i64,
    keepdim: bool,
    dtype: Kind
) -> Result<Tensor, TchError>

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

pub fn f_put_(
    &mut self,
    index: &Tensor,
    source: &Tensor,
    accumulate: bool
) -> Result<Tensor, 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_qr(&self, some: bool) -> Result<(Tensor, Tensor), TchError>

pub fn f_qr_out(
    &self,
    q: &Tensor,
    r: &Tensor,
    some: bool
) -> Result<(Tensor, 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_tensor1<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_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_randint1(
    low: i64,
    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_like1(&self, low: i64, high: i64) -> Result<Tensor, TchError>

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

pub fn f_randint_out1(
    out: &Tensor,
    low: i64,
    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_1(&mut self, to: i64) -> Result<Tensor, TchError>

pub fn f_random_2(
    &mut self,
    from: i64,
    to: impl Into<Option<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_range1<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_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_out(
    &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_out(
    &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_relu_(&mut self) -> Result<Tensor, TchError>

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

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

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

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

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

pub fn f_remainder_out1(
    &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_interleave1(
    &self,
    repeats: &Tensor,
    dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

pub fn f_repeat_interleave2(
    &self,
    repeats: i64,
    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_out(
    &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_out(
    &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_out(
    &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_rfft(
    &self,
    signal_ndim: i64,
    normalized: bool,
    onesided: bool
) -> 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_relu1<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_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_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_tanh1<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_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_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_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_rsub1<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_scatter1<S: Into<Scalar>>(
    &self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Result<Tensor, TchError>

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

pub fn f_scatter_1<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> 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_searchsorted(
    &self,
    sorted_sequence: &Tensor,
    out_int32: bool,
    right: bool
) -> Result<Tensor, TchError>

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

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

pub fn f_select(&self, 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_1(&mut self, source: &Tensor) -> Result<Tensor, TchError>

pub fn f_set_requires_grad(&self, r: bool) -> 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_out(
    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_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_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: 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
) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss_backward_out(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> 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_out(
    &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_out<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_out<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_out(
    &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_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    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_tensor1(
    indices: &Tensor,
    values: &Tensor,
    options: (Kind, Device)
) -> Result<Tensor, TchError>

pub fn f_sparse_coo_tensor2(
    indices: &Tensor,
    values: &Tensor,
    size: &[i64],
    options: (Kind, Device)
) -> Result<Tensor, 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_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_squeeze(&self) -> Result<Tensor, TchError>

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

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

pub fn f_squeeze_1(&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_std1(
    &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_mean1(
    &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
) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

pub fn f_sum_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_out(
    &self,
    u: &Tensor,
    s: &Tensor,
    v: &Tensor,
    some: bool,
    compute_uv: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>

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

pub fn f_symeig_out(
    &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_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_out(
    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_tensordot(
    &self,
    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_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    threshold: S,
    value: S
) -> Result<Tensor, TchError>

pub fn f_to(&self, device: Device) -> Result<Tensor, TchError>

pub fn f_to1(
    &self,
    options: (Kind, Device),
    non_blocking: bool,
    copy: bool
) -> Result<Tensor, TchError>

pub fn f_to2(
    &self,
    dtype: Kind,
    non_blocking: bool,
    copy: bool
) -> Result<Tensor, TchError>

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

pub fn f_to4(
    &self,
    device: Device,
    dtype: Kind,
    non_blocking: bool,
    copy: bool
) -> Result<Tensor, TchError>

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

pub fn f_to_dense_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>

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

pub fn f_to_mkldnn_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>

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

pub fn f_to_sparse1(&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_out(
    &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_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_trapz1(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_out(
    &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_divide1<S: Into<Scalar>>(
    &self,
    other: S
) -> Result<Tensor, TchError>

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

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

pub fn f_true_divide_out(
    &self,
    out: &Tensor,
    other: &Tensor
) -> 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_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_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_out(
    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_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(
    &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_out(
    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_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_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_out(
    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_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<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_out(
    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_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    scales: impl Into<Option<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_out(
    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_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_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_out(
    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_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_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_out(
    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_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_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_var1(
    &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_mean1(
    &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_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_where_(condition: &Tensor) -> Result<Vec<Tensor>, TchError>

pub fn f_where1(
    &self,
    condition: &Tensor,
    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_1(&mut self, other: &Tensor) -> Tensor

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

pub fn internal_iand_1(&mut self, other: &Tensor) -> Tensor

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

pub fn internal_ilshift_1(&mut self, other: &Tensor) -> Tensor

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

pub fn internal_ior_1(&mut self, other: &Tensor) -> Tensor

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

pub fn internal_irshift_1(&mut self, other: &Tensor) -> Tensor

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

pub fn internal_ixor_1(&mut self, other: &Tensor) -> Tensor

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

pub fn internal_lshift_1(&mut self, other: &Tensor) -> Tensor

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

pub fn internal_or_1(&mut self, other: &Tensor) -> Tensor

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

pub fn internal_rshift_1(&mut self, other: &Tensor) -> Tensor

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

pub fn internal_xor_1(&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_addmv_impl_(
    &mut self,
    self2: &Tensor,
    mat: &Tensor,
    vec: &Tensor
) -> Tensor

pub fn internal_addr(&self, vec1: &Tensor, vec2: &Tensor) -> Tensor

pub fn internal_addr_(&mut self, vec1: &Tensor, vec2: &Tensor) -> Tensor

pub fn internal_addr_out(
    &self,
    out: &Tensor,
    vec1: &Tensor,
    vec2: &Tensor
) -> Tensor

pub fn internal_amp_update_scale(
    growth_tracker: &Tensor,
    current_scale: &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_helper(&self, upper: bool) -> Tensor

pub fn internal_cholesky_solve_helper(&self, a: &Tensor, upper: bool) -> Tensor

pub fn internal_coalesced_(&mut self, coalesced: bool) -> 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
) -> 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,
    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,
    num_layers: i64,
    batch_first: bool,
    bidirectional: bool
) -> Tensor

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_dim_arange(like: &Tensor, dim: i64) -> Tensor

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
) -> (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>
) -> Tensor

pub fn internal_embedding_bag_dense_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,
    per_sample_weights: Option<T>
) -> Tensor

pub fn internal_embedding_bag_per_sample_weights_backward(
    grad: &Tensor,
    weight: &Tensor,
    indices: &Tensor,
    offsets: &Tensor,
    offset2bag: &Tensor,
    mode: 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>
) -> 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_fft_with_size(
    &self,
    signal_ndim: i64,
    complex_input: bool,
    complex_output: bool,
    inverse: bool,
    checked_signal_sizes: &[i64],
    normalized: bool,
    onesided: bool,
    output_sizes: &[i64]
) -> Tensor

pub fn internal_fused_dropout(&self, p: f64) -> (Tensor, Tensor)

pub fn internal_gather_sparse_backward(
    &self,
    dim: i64,
    index: &Tensor,
    grad: &Tensor
) -> Tensor

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: &[T],
    values: &Tensor,
    accumulate: bool,
    unsafe_: bool
) -> Tensor

pub fn internal_indices(&self) -> Tensor

pub fn internal_inverse_helper(&self) -> 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_solve_helper(
    &self,
    lu_data: &Tensor,
    lu_pivots: &Tensor
) -> Tensor

pub fn internal_lu_with_info(
    &self,
    pivot: bool,
    check_errors: bool
) -> (Tensor, Tensor, 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_mode(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn internal_mode_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn internal_multinomial_alias_draw(
    j: &Tensor,
    q: &Tensor,
    num_samples: i64
) -> Tensor

pub fn internal_multinomial_alias_setup(probs: &Tensor) -> (Tensor, Tensor)

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_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_qr_helper(&self, some: bool) -> (Tensor, Tensor)

pub fn internal_reshape_from_tensor(&self, shape: &Tensor) -> Tensor

pub fn internal_s_where(&self, condition: &Tensor, other: &Tensor) -> Tensor

pub fn internal_sample_dirichlet(&self) -> 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_log_softmax(&self, dim: i64, dtype: Kind) -> Tensor

pub fn internal_sparse_log_softmax1(
    &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_mm(sparse: &Tensor, dense: &Tensor) -> Tensor

pub fn internal_sparse_softmax(&self, dim: i64, dtype: Kind) -> Tensor

pub fn internal_sparse_softmax1(&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_sum(&self) -> Tensor

pub fn internal_sparse_sum1(&self, dtype: Kind) -> Tensor

pub fn internal_sparse_sum2(&self, dim: &[i64]) -> Tensor

pub fn internal_sparse_sum3(&self, dim: &[i64], dtype: Kind) -> Tensor

pub fn internal_sparse_sum_backward(&self, grad: &Tensor, 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_serialization_subcmul(&self, other: &Tensor) -> Tensor

pub fn internal_triangular_solve_helper(
    &self,
    a: &Tensor,
    upper: bool,
    transpose: bool,
    unitriangular: bool
) -> (Tensor, 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_unsafe_view(&self, size: &[i64]) -> Tensor

pub fn internal_values(&self) -> Tensor

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_output: &Tensor) -> Tensor

pub fn adaptive_avg_pool3d_backward_out(
    &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_out(
    &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_out(
    &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_add1<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_add_(&mut self, other: &Tensor) -> Tensor

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

pub fn add_out(&self, out: &Tensor, other: &Tensor) -> 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 all1(&self, dim: i64, keepdim: bool) -> Tensor

pub fn all_out(&self, out: &Tensor, dim: i64, keepdim: bool) -> Tensor

pub fn alpha_dropout(&self, p: f64, train: bool) -> Tensor

pub fn alpha_dropout_(&mut self, p: f64, train: bool) -> Tensor

pub fn angle(&self) -> Tensor

pub fn angle_out(&self, out: &Tensor) -> Tensor

pub fn any(&self) -> Tensor

pub fn any1(&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 arange1<S: Into<Scalar>>(
    start: S,
    end: S,
    options: (Kind, Device)
) -> Tensor

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

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

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

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

pub fn argmin(&self, 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 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_out(
    &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_out(
    &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_window1(
    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
) -> 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 bernoulli1(&self, p: f64) -> Tensor

pub fn bernoulli_(&mut self, p: &Tensor) -> Tensor

pub fn bernoulli_1(&mut self, p: f64) -> Tensor

pub fn bernoulli_out(&self, out: &Tensor) -> 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_out<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_and1(&self, other: &Tensor) -> Tensor

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

pub fn bitwise_and_1(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_and_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn bitwise_and_out1<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    other: S
) -> 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_or1(&self, other: &Tensor) -> Tensor

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

pub fn bitwise_or_1(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_or_out(&self, out: &Tensor, other: &Tensor) -> Tensor

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

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

pub fn bitwise_xor1(&self, other: &Tensor) -> Tensor

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

pub fn bitwise_xor_1(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_xor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

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

pub fn blackman_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn blackman_window1(
    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 bucketize(
    &self,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Tensor

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

pub fn bucketize_out(
    &self,
    out: &Tensor,
    boundaries: &Tensor,
    out_int32: bool,
    right: bool
) -> Tensor

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 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 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_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_out<S: Into<Scalar>>(&self, out: &Tensor, min: S, max: S) -> 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_out(
    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 combinations(&self, r: i64, with_replacement: bool) -> 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 conv2d<T: Borrow<Tensor>>(
    &self,
    weight: &Tensor,
    bias: Option<T>,
    stride: &[i64],
    padding: &[i64],
    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 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 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 cross(&self, other: &Tensor, dim: impl Into<Option<i64>>) -> Tensor

pub fn cross_out(
    &self,
    out: &Tensor,
    other: &Tensor,
    dim: impl Into<Option<i64>>
) -> 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_loss1(
    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
) -> Tensor

pub fn cudnn_convolution1<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_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 cudnn_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 cudnn_convolution_transpose(
    &self,
    weight: &Tensor,
    padding: &[i64],
    output_padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: bool
) -> Tensor

pub fn cudnn_convolution_transpose1<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_backward_input(
    grad_output: &Tensor,
    weight: &Tensor,
    padding: &[i64],
    stride: &[i64],
    dilation: &[i64],
    groups: i64,
    benchmark: bool,
    deterministic: 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
) -> 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 cummax(&self, dim: i64) -> (Tensor, Tensor)

pub fn cummax_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64
) -> (Tensor, 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_out(&self, out: &Tensor, dim: i64, dtype: Kind) -> Tensor

pub fn cumsum(&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 dequantize(&self) -> Tensor

pub fn dequantize1<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_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 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_div1<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_div_(&mut self, other: &Tensor) -> Tensor

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

pub fn div_out(&self, out: &Tensor, other: &Tensor) -> 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 eig(&self, eigenvectors: bool) -> (Tensor, Tensor)

pub fn eig_out(
    &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,
    output: &Tensor
) -> Tensor

pub fn elu_backward_out<S: Into<Scalar>>(
    grad_input: &Tensor,
    grad_output: &Tensor,
    alpha: S,
    scale: S,
    input_scale: S,
    output: &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_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_meta(size: &[i64], options: (Kind, Device)) -> 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 eq1(&self, other: &Tensor) -> Tensor

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

pub fn eq_1(&mut self, other: &Tensor) -> Tensor

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

pub fn eq_out1(&self, out: &Tensor, other: &Tensor) -> Tensor

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 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 eye1(n: i64, m: i64, options: (Kind, Device)) -> Tensor

pub fn eye_out(out: &Tensor, n: i64) -> Tensor

pub fn eye_out1(out: &Tensor, n: i64, m: 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_backward(
    &self,
    grad: &Tensor,
    scale: &Tensor,
    zero_point: &Tensor,
    axis: i64,
    quant_min: i64,
    quant_max: i64
) -> 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_backward(
    &self,
    grad: &Tensor,
    scale: f64,
    zero_point: i64,
    quant_min: i64,
    quant_max: i64
) -> 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_matrix1(&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(&self, signal_ndim: i64, normalized: bool) -> Tensor

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

pub fn fill_1(&mut self, value: &Tensor) -> Tensor

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

pub fn flatten(&self, start_dim: i64, end_dim: i64) -> Tensor

pub fn flip(&self, dims: &[i64]) -> Tensor

pub fn fliplr(&self) -> Tensor

pub fn flipud(&self) -> Tensor

pub fn floor(&self) -> Tensor

pub fn floor_(&mut self) -> Tensor

pub fn floor_divide(&self, other: &Tensor) -> Tensor

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

pub fn floor_divide_(&mut self, other: &Tensor) -> Tensor

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

pub fn floor_divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn floor_out(&self, out: &Tensor) -> Tensor

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

pub fn fmod1(&self, other: &Tensor) -> Tensor

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

pub fn fmod_1(&mut self, other: &Tensor) -> Tensor

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

pub fn fmod_out1(&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_out(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Tensor

pub fn fractional_max_pool2d_out(
    &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_out(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    indices: &Tensor
) -> Tensor

pub fn fractional_max_pool3d_out(
    &self,
    output: &Tensor,
    indices: &Tensor,
    kernel_size: &[i64],
    output_size: &[i64],
    random_samples: &Tensor
) -> (Tensor, Tensor)

pub fn frobenius_norm(&self) -> Tensor

pub fn frobenius_norm1(&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_out(
    &self,
    out: &Tensor,
    dim: i64,
    index: &Tensor,
    sparse_grad: bool
) -> Tensor

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

pub fn ge1(&self, other: &Tensor) -> Tensor

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

pub fn ge_1(&mut self, other: &Tensor) -> Tensor

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

pub fn ge_out1(&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_out(&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_out(
    &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 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 gru1<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 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 gt<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn gt1(&self, other: &Tensor) -> Tensor

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

pub fn gt_1(&mut self, other: &Tensor) -> Tensor

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

pub fn gt_out1(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn hamming_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn hamming_window1(
    window_length: i64,
    periodic: bool,
    options: (Kind, Device)
) -> Tensor

pub fn hamming_window2(
    window_length: i64,
    periodic: bool,
    alpha: f64,
    options: (Kind, Device)
) -> Tensor

pub fn hamming_window3(
    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_window1(
    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_out<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 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 hspmm(mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn hspmm_out(out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn ifft(&self, signal_ndim: i64, normalized: bool) -> 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_out(
    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: &[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_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_fill1(&self, dim: i64, index: &Tensor, value: &Tensor) -> Tensor

pub fn index_fill_<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Tensor

pub fn index_fill_1(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: &Tensor
) -> Tensor

pub fn index_put<T: Borrow<Tensor>>(
    &self,
    indices: &[T],
    values: &Tensor,
    accumulate: bool
) -> Tensor

pub fn index_put_<T: Borrow<Tensor>>(
    &mut self,
    indices: &[T],
    values: &Tensor,
    accumulate: bool
) -> Tensor

pub fn index_select(&self, 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 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 irfft(
    &self,
    signal_ndim: i64,
    normalized: bool,
    onesided: bool,
    signal_sizes: &[i64]
) -> Tensor

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 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>>
) -> 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 kthvalue(&self, k: i64, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn kthvalue_out(
    &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_out(
    &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 le<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn le1(&self, other: &Tensor) -> Tensor

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

pub fn le_1(&mut self, other: &Tensor) -> Tensor

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

pub fn le_out1(&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 lerp1(&self, end: &Tensor, weight: &Tensor) -> Tensor

pub fn lerp_<S: Into<Scalar>>(&mut self, end: &Tensor, weight: S) -> Tensor

pub fn lerp_1(&mut self, end: &Tensor, weight: &Tensor) -> Tensor

pub fn lerp_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    end: &Tensor,
    weight: S
) -> Tensor

pub fn lerp_out1(&self, out: &Tensor, end: &Tensor, weight: &Tensor) -> Tensor

pub fn lgamma(&self) -> Tensor

pub fn lgamma_(&mut self) -> Tensor

pub fn lgamma_out(&self, out: &Tensor) -> 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: i64,
    options: (Kind, Device)
) -> Tensor

pub fn linspace_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S,
    steps: 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_out(
    &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 logspace<S: Into<Scalar>>(
    start: S,
    end: S,
    steps: i64,
    base: f64,
    options: (Kind, Device)
) -> Tensor

pub fn logspace_out<S: Into<Scalar>>(
    out: &Tensor,
    start: S,
    end: S,
    steps: 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 lstm1<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 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 lstsq(&self, a: &Tensor) -> (Tensor, Tensor)

pub fn lstsq_out(&self, x: &Tensor, qr: &Tensor, a: &Tensor) -> (Tensor, Tensor)

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

pub fn lt1(&self, other: &Tensor) -> Tensor

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

pub fn lt_1(&mut self, other: &Tensor) -> Tensor

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

pub fn lt_out1(&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 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_fill1(&self, mask: &Tensor, value: &Tensor) -> Tensor

pub fn masked_fill_<S: Into<Scalar>>(
    &mut self,
    mask: &Tensor,
    value: S
) -> Tensor

pub fn masked_fill_1(&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_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_power(&self, n: i64) -> Tensor

pub fn matrix_rank(&self, symmetric: bool) -> Tensor

pub fn matrix_rank1(&self, tol: f64, symmetric: bool) -> Tensor

pub fn max(&self) -> Tensor

pub fn max1(&self, other: &Tensor) -> Tensor

pub fn max2(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn max_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn max_out1(
    &self,
    max: &Tensor,
    max_values: &Tensor,
    dim: i64,
    keepdim: bool
) -> (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_out(
    &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_out(
    &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_out(
    &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_out(
    &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 max_values(&self, dim: &[i64], keepdim: bool) -> Tensor

pub fn mean(&self, dtype: Kind) -> Tensor

pub fn mean1(&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 median1(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn median_out(
    &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 min1(&self, other: &Tensor) -> Tensor

pub fn min2(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn min_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn min_out1(
    &self,
    min: &Tensor,
    min_indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> (Tensor, Tensor)

pub fn min_values(&self, dim: &[i64], keepdim: bool) -> 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 mkldnn_adaptive_avg_pool2d(&self, output_size: &[i64]) -> 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_max_pool2d(
    &self,
    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 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_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    keepdim: bool
) -> (Tensor, 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_out(
    &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 g_mul(&self, other: &Tensor) -> Tensor

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

pub fn g_mul_(&mut self, other: &Tensor) -> Tensor

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

pub fn mul_out(&self, out: &Tensor, other: &Tensor) -> 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_out<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_out(
    &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 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 narrow(&self, dim: i64, start: i64, length: i64) -> Tensor

pub fn narrow1(&self, dim: i64, start: &Tensor, length: i64) -> Tensor

pub fn narrow_copy(&self, dim: i64, start: i64, 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,
    weight: Option<T>,
    bias: Option<T>,
    m: i64,
    n: i64,
    eps: f64
) -> (Tensor, Tensor, Tensor)

pub fn native_norm(&self) -> Tensor

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

pub fn ne1(&self, other: &Tensor) -> Tensor

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

pub fn ne_1(&mut self, other: &Tensor) -> Tensor

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

pub fn ne_out1(&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 new_empty(&self, size: &[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 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_out<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_out<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_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 norm1<S: Into<Scalar>>(&self, p: S, dtype: Kind) -> Tensor

pub fn norm2<S: Into<Scalar>>(&self, p: S, dim: &[i64], keepdim: bool) -> Tensor

pub fn norm3<S: Into<Scalar>>(
    &self,
    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_out1<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    p: S,
    dim: &[i64],
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn normal_(&mut self, mean: f64, std: f64) -> Tensor

pub fn normal_out(out: &Tensor, mean: &Tensor, std: f64) -> Tensor

pub fn normal_out1(out: &Tensor, mean: f64, std: &Tensor) -> Tensor

pub fn normal_out2(out: &Tensor, mean: &Tensor, std: &Tensor) -> Tensor

pub fn normal_out3(out: &Tensor, mean: f64, std: f64, size: &[i64]) -> Tensor

pub fn nuclear_norm(&self, keepdim: bool) -> Tensor

pub fn nuclear_norm1(&self, dim: &[i64], keepdim: bool) -> Tensor

pub fn nuclear_norm_out(&self, out: &Tensor, keepdim: bool) -> Tensor

pub fn nuclear_norm_out1(
    &self,
    out: &Tensor,
    dim: &[i64],
    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 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 poisson(&self) -> Tensor

pub fn poisson_nll_loss(
    &self,
    target: &Tensor,
    log_input: bool,
    full: bool,
    eps: f64,
    reduction: Reduction
) -> 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 pow<S: Into<Scalar>>(&self, exponent: S) -> Tensor

pub fn pow1(&self, exponent: &Tensor) -> Tensor

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

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

pub fn pow_1(&mut self, exponent: &Tensor) -> Tensor

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

pub fn pow_out1(&self, out: &Tensor, exponent: &Tensor) -> Tensor

pub fn pow_out2<S: Into<Scalar>>(
    out: &Tensor,
    self_scalar: S,
    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 prod1(&self, dim: i64, keepdim: bool, dtype: Kind) -> Tensor

pub fn prod_out(
    &self,
    out: &Tensor,
    dim: i64,
    keepdim: bool,
    dtype: Kind
) -> Tensor

pub fn put_(
    &mut self,
    index: &Tensor,
    source: &Tensor,
    accumulate: bool
) -> Tensor

pub fn q_per_channel_scales(&self) -> Tensor

pub fn q_per_channel_zero_points(&self) -> Tensor

pub fn qr(&self, some: bool) -> (Tensor, Tensor)

pub fn qr_out(&self, q: &Tensor, r: &Tensor, some: bool) -> (Tensor, 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_tensor1<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_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 randint1(
    low: i64,
    high: i64,
    size: &[i64],
    options: (Kind, Device)
) -> Tensor

pub fn randint_like(&self, high: i64) -> Tensor

pub fn randint_like1(&self, low: i64, high: i64) -> Tensor

pub fn randint_out(out: &Tensor, high: i64, size: &[i64]) -> Tensor

pub fn randint_out1(out: &Tensor, low: i64, 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_1(&mut self, to: i64) -> Tensor

pub fn random_2(&mut self, from: i64, to: impl Into<Option<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 range1<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 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_out(
    &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_out(
    &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 relu_(&mut self) -> Tensor

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

pub fn remainder1(&self, other: &Tensor) -> Tensor

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

pub fn remainder_1(&mut self, other: &Tensor) -> Tensor

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

pub fn remainder_out1(&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_interleave1(
    &self,
    repeats: &Tensor,
    dim: impl Into<Option<i64>>
) -> Tensor

pub fn repeat_interleave2(
    &self,
    repeats: i64,
    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_out(
    &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_out(
    &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_out(
    &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 rfft(&self, signal_ndim: i64, normalized: bool, onesided: bool) -> 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_relu1<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_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_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_tanh1<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_cell<T: Borrow<Tensor>>(
    &self,
    hx: &Tensor,
    w_ih: &Tensor,
    w_hh: &Tensor,
    b_ih: Option<T>,
    b_hh: Option<T>
) -> 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 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 rsub1<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 scatter1<S: Into<Scalar>>(
    &self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Tensor

pub fn scatter_(&mut self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor

pub fn scatter_1<S: Into<Scalar>>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> 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 searchsorted(
    &self,
    sorted_sequence: &Tensor,
    out_int32: bool,
    right: bool
) -> Tensor

pub fn searchsorted1<S: Into<Scalar>>(
    sorted_sequence: &Tensor,
    self_scalar: S,
    out_int32: bool,
    right: bool
) -> Tensor

pub fn searchsorted_out(
    &self,
    out: &Tensor,
    sorted_sequence: &Tensor,
    out_int32: bool,
    right: bool
) -> Tensor

pub fn select(&self, 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_1(&mut self, source: &Tensor) -> Tensor

pub fn set_requires_grad(&self, r: bool) -> 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_out(
    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 sin(&self) -> Tensor

pub fn sin_(&mut self) -> Tensor

pub fn sin_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: 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) -> Tensor

pub fn smooth_l1_loss_backward(
    &self,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn smooth_l1_loss_backward_out(
    &self,
    grad_input: &Tensor,
    grad_output: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> Tensor

pub fn smooth_l1_loss_out(
    &self,
    out: &Tensor,
    target: &Tensor,
    reduction: Reduction
) -> 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_out(
    &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_out<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_out<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_out(
    &self,
    solution: &Tensor,
    lu: &Tensor,
    a: &Tensor
) -> (Tensor, Tensor)

pub fn sort(&self, dim: i64, descending: bool) -> (Tensor, Tensor)

pub fn sort_out(
    &self,
    values: &Tensor,
    indices: &Tensor,
    dim: i64,
    descending: bool
) -> (Tensor, Tensor)

pub fn sparse_coo_tensor(size: &[i64], options: (Kind, Device)) -> Tensor

pub fn sparse_coo_tensor1(
    indices: &Tensor,
    values: &Tensor,
    options: (Kind, Device)
) -> Tensor

pub fn sparse_coo_tensor2(
    indices: &Tensor,
    values: &Tensor,
    size: &[i64],
    options: (Kind, Device)
) -> Tensor

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 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 squeeze(&self) -> Tensor

pub fn squeeze1(&self, dim: i64) -> Tensor

pub fn squeeze_(&mut self) -> Tensor

pub fn squeeze_1(&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 std1(&self, dim: &[i64], unbiased: bool, keepdim: bool) -> Tensor

pub fn std_mean(&self, unbiased: bool) -> (Tensor, Tensor)

pub fn std_mean1(
    &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
) -> Tensor

pub fn g_sub(&self, other: &Tensor) -> Tensor

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

pub fn g_sub_(&mut self, other: &Tensor) -> Tensor

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

pub fn sub_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn sum(&self, dtype: Kind) -> Tensor

pub fn sum1(&self, dim: &[i64], keepdim: bool, dtype: Kind) -> Tensor

pub fn sum_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_out(
    &self,
    u: &Tensor,
    s: &Tensor,
    v: &Tensor,
    some: bool,
    compute_uv: bool
) -> (Tensor, Tensor, Tensor)

pub fn symeig(&self, eigenvectors: bool, upper: bool) -> (Tensor, Tensor)

pub fn symeig_out(
    &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_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_out(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output: &Tensor
) -> Tensor

pub fn tanh_out(&self, out: &Tensor) -> Tensor

pub fn tensordot(
    &self,
    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_out<S: Into<Scalar>>(
    &self,
    out: &Tensor,
    threshold: S,
    value: S
) -> Tensor

pub fn to(&self, device: Device) -> Tensor

pub fn to1(
    &self,
    options: (Kind, Device),
    non_blocking: bool,
    copy: bool
) -> Tensor

pub fn to2(&self, dtype: Kind, non_blocking: bool, copy: bool) -> Tensor

pub fn to3(&self, other: &Tensor, non_blocking: bool, copy: bool) -> Tensor

pub fn to4(
    &self,
    device: Device,
    dtype: Kind,
    non_blocking: bool,
    copy: bool
) -> Tensor

pub fn to_dense(&self) -> Tensor

pub fn to_dense_backward(&self, grad: &Tensor) -> Tensor

pub fn to_mkldnn(&self) -> Tensor

pub fn to_mkldnn_backward(&self, grad: &Tensor) -> Tensor

pub fn to_sparse(&self) -> Tensor

pub fn to_sparse1(&self, sparse_dim: i64) -> Tensor

pub fn topk(
    &self,
    k: i64,
    dim: i64,
    largest: bool,
    sorted: bool
) -> (Tensor, Tensor)

pub fn topk_out(
    &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 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 trapz1(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_out(
    &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_divide1<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn true_divide_(&mut self, other: &Tensor) -> Tensor

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

pub fn true_divide_out(&self, out: &Tensor, other: &Tensor) -> 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 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 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_out(
    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_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(
    &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_out(
    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_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_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_out(
    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_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    align_corners: bool,
    scales: impl Into<Option<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_out(
    grad_input: &Tensor,
    grad_output: &Tensor,
    output_size: &[i64],
    input_size: &[i64],
    scales: impl Into<Option<f64>>
) -> Tensor

pub fn upsample_nearest1d_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    scales: impl Into<Option<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_out(
    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_out(
    &self,
    out: &Tensor,
    output_size: &[i64],
    scales_h: impl Into<Option<f64>>,
    scales_w: impl Into<Option<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_out(
    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_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_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_out(
    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_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 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 var1(&self, dim: &[i64], unbiased: bool, keepdim: bool) -> Tensor

pub fn var_mean(&self, unbiased: bool) -> (Tensor, Tensor)

pub fn var_mean1(
    &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 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 where_(condition: &Tensor) -> Vec<Tensor>

pub fn where1(&self, condition: &Tensor, 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.

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<'_> From<&'_ Tensor> for TensorIndexer

fn from(tensor: &Tensor) -> Self

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<f64>

fn from(tensor: &Tensor) -> Vec<f64>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<f16>>

fn from(tensor: &Tensor) -> Vec<Vec<f16>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<f16>>>

fn from(tensor: &Tensor) -> Vec<Vec<Vec<f16>>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for f16

fn from(tensor: &Tensor) -> f16

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<i64>

fn from(tensor: &Tensor) -> Vec<i64>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<i64>>

fn from(tensor: &Tensor) -> Vec<Vec<i64>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<i64>>>

fn from(tensor: &Tensor) -> Vec<Vec<Vec<i64>>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for i64

fn from(tensor: &Tensor) -> i64

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<i32>

fn from(tensor: &Tensor) -> Vec<i32>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<i32>>

fn from(tensor: &Tensor) -> Vec<Vec<i32>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<i32>>>

fn from(tensor: &Tensor) -> Vec<Vec<Vec<i32>>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<f64>>

fn from(tensor: &Tensor) -> Vec<Vec<f64>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for i32

fn from(tensor: &Tensor) -> i32

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<i8>

fn from(tensor: &Tensor) -> Vec<i8>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<i8>>

fn from(tensor: &Tensor) -> Vec<Vec<i8>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<i8>>>

fn from(tensor: &Tensor) -> Vec<Vec<Vec<i8>>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for i8

fn from(tensor: &Tensor) -> i8

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<u8>

fn from(tensor: &Tensor) -> Vec<u8>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<u8>>

fn from(tensor: &Tensor) -> Vec<Vec<u8>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<u8>>>

fn from(tensor: &Tensor) -> Vec<Vec<Vec<u8>>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for u8

fn from(tensor: &Tensor) -> u8

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<bool>

fn from(tensor: &Tensor) -> Vec<bool>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<f64>>>

fn from(tensor: &Tensor) -> Vec<Vec<Vec<f64>>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<bool>>

fn from(tensor: &Tensor) -> Vec<Vec<bool>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<bool>>>

fn from(tensor: &Tensor) -> Vec<Vec<Vec<bool>>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for bool

fn from(tensor: &Tensor) -> bool

Performs the conversion.

impl<'_> From<&'_ Tensor> for f64

fn from(tensor: &Tensor) -> f64

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<f32>

fn from(tensor: &Tensor) -> Vec<f32>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<f32>>

fn from(tensor: &Tensor) -> Vec<Vec<f32>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<f32>>>

fn from(tensor: &Tensor) -> Vec<Vec<Vec<f32>>>

Performs the conversion.

impl<'_> From<&'_ Tensor> for f32

fn from(tensor: &Tensor) -> f32

Performs the conversion.

impl<'_> From<&'_ Tensor> for Vec<f16>

fn from(tensor: &Tensor) -> Vec<f16>

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 From<Tensor> for Vec<f64>

fn from(tensor: Tensor) -> Vec<f64>

Performs the conversion.

impl From<Tensor> for Vec<Vec<f16>>

fn from(tensor: Tensor) -> Vec<Vec<f16>>

Performs the conversion.

impl From<Tensor> for Vec<Vec<Vec<f16>>>

fn from(tensor: Tensor) -> Vec<Vec<Vec<f16>>>

Performs the conversion.

impl From<Tensor> for f16

fn from(tensor: Tensor) -> f16

Performs the conversion.

impl From<Tensor> for Vec<i64>

fn from(tensor: Tensor) -> Vec<i64>

Performs the conversion.

impl From<Tensor> for Vec<Vec<i64>>

fn from(tensor: Tensor) -> Vec<Vec<i64>>

Performs the conversion.

impl From<Tensor> for Vec<Vec<Vec<i64>>>

fn from(tensor: Tensor) -> Vec<Vec<Vec<i64>>>

Performs the conversion.

impl From<Tensor> for i64

fn from(tensor: Tensor) -> i64

Performs the conversion.

impl From<Tensor> for Vec<i32>

fn from(tensor: Tensor) -> Vec<i32>

Performs the conversion.

impl From<Tensor> for Vec<Vec<i32>>

fn from(tensor: Tensor) -> Vec<Vec<i32>>

Performs the conversion.

impl From<Tensor> for Vec<Vec<Vec<i32>>>

fn from(tensor: Tensor) -> Vec<Vec<Vec<i32>>>

Performs the conversion.

impl From<Tensor> for Vec<Vec<f64>>

fn from(tensor: Tensor) -> Vec<Vec<f64>>

Performs the conversion.

impl From<Tensor> for i32

fn from(tensor: Tensor) -> i32

Performs the conversion.

impl From<Tensor> for Vec<i8>

fn from(tensor: Tensor) -> Vec<i8>

Performs the conversion.

impl From<Tensor> for Vec<Vec<i8>>

fn from(tensor: Tensor) -> Vec<Vec<i8>>

Performs the conversion.

impl From<Tensor> for Vec<Vec<Vec<i8>>>

fn from(tensor: Tensor) -> Vec<Vec<Vec<i8>>>

Performs the conversion.

impl From<Tensor> for i8

fn from(tensor: Tensor) -> i8

Performs the conversion.

impl From<Tensor> for Vec<u8>

fn from(tensor: Tensor) -> Vec<u8>

Performs the conversion.

impl From<Tensor> for Vec<Vec<u8>>

fn from(tensor: Tensor) -> Vec<Vec<u8>>

Performs the conversion.

impl From<Tensor> for Vec<Vec<Vec<u8>>>

fn from(tensor: Tensor) -> Vec<Vec<Vec<u8>>>

Performs the conversion.

impl From<Tensor> for u8

fn from(tensor: Tensor) -> u8

Performs the conversion.

impl From<Tensor> for Vec<bool>

fn from(tensor: Tensor) -> Vec<bool>

Performs the conversion.

impl From<Tensor> for Vec<Vec<Vec<f64>>>

fn from(tensor: Tensor) -> Vec<Vec<Vec<f64>>>

Performs the conversion.

impl From<Tensor> for Vec<Vec<bool>>

fn from(tensor: Tensor) -> Vec<Vec<bool>>

Performs the conversion.

impl From<Tensor> for Vec<Vec<Vec<bool>>>

fn from(tensor: Tensor) -> Vec<Vec<Vec<bool>>>

Performs the conversion.

impl From<Tensor> for bool

fn from(tensor: Tensor) -> bool

Performs the conversion.

impl From<Tensor> for f64

fn from(tensor: Tensor) -> f64

Performs the conversion.

impl From<Tensor> for Vec<f32>

fn from(tensor: Tensor) -> Vec<f32>

Performs the conversion.

impl From<Tensor> for Vec<Vec<f32>>

fn from(tensor: Tensor) -> Vec<Vec<f32>>

Performs the conversion.

impl From<Tensor> for Vec<Vec<Vec<f32>>>

fn from(tensor: Tensor) -> Vec<Vec<Vec<f32>>>

Performs the conversion.

impl From<Tensor> for f32

fn from(tensor: Tensor) -> f32

Performs the conversion.

impl From<Tensor> for Vec<f16>

fn from(tensor: Tensor) -> Vec<f16>

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 ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Send for Tensor

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<D> TryFrom<ArrayBase<OwnedRepr<bool>, D>> for Tensor where
    D: Dimension, 

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Array<bool, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl<D> TryFrom<ArrayBase<OwnedRepr<f16>, D>> for Tensor where
    D: Dimension, 

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Array<f16, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl<D> TryFrom<ArrayBase<OwnedRepr<f32>, D>> for Tensor where
    D: Dimension, 

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Array<f32, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl<D> TryFrom<ArrayBase<OwnedRepr<f64>, D>> for Tensor where
    D: Dimension, 

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Array<f64, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl<D> TryFrom<ArrayBase<OwnedRepr<i32>, D>> for Tensor where
    D: Dimension, 

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Array<i32, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl<D> TryFrom<ArrayBase<OwnedRepr<i64>, D>> for Tensor where
    D: Dimension, 

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Array<i64, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Vec<bool>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Vec<bool>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Vec<f16>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Vec<f16>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Vec<f32>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Vec<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Vec<f64>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Vec<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Vec<i32>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Vec<i32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Vec<i64>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Vec<i64>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'_> TryInto<ArrayBase<OwnedRepr<bool>, Dim<IxDynImpl>>> for &'_ Tensor

type Error = ShapeError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ArrayD<bool>, Self::Error>

Performs the conversion.

impl<'_> TryInto<ArrayBase<OwnedRepr<f16>, Dim<IxDynImpl>>> for &'_ Tensor

type Error = ShapeError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ArrayD<f16>, Self::Error>

Performs the conversion.

impl<'_> TryInto<ArrayBase<OwnedRepr<f32>, Dim<IxDynImpl>>> for &'_ Tensor

type Error = ShapeError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ArrayD<f32>, Self::Error>

Performs the conversion.

impl<'_> TryInto<ArrayBase<OwnedRepr<f64>, Dim<IxDynImpl>>> for &'_ Tensor

type Error = ShapeError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ArrayD<f64>, Self::Error>

Performs the conversion.

impl<'_> TryInto<ArrayBase<OwnedRepr<i32>, Dim<IxDynImpl>>> for &'_ Tensor

type Error = ShapeError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ArrayD<i32>, Self::Error>

Performs the conversion.

impl<'_> TryInto<ArrayBase<OwnedRepr<i64>, Dim<IxDynImpl>>> for &'_ Tensor

type Error = ShapeError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ArrayD<i64>, Self::Error>

Performs the conversion.