Struct tch::Tensor

pub struct Tensor { /* private fields */ }

A tensor object.

Implementations

impl Tensor

pub fn new() -> Tensor

Creates a new tensor.

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

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

Safety

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

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

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

Safety

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

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

Returns a pointer to the underlying C++ tensor.

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

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

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

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

pub fn dim(&self) -> usize

Returns the number of dimension of the tensor.

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

Returns the shape of the input tensor.

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

Returns the tensor size for single dimension tensors.

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

Returns the tensor sizes for two dimension tensors.

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

Returns the tensor sizes for three dimension tensors.

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

Returns the tensor sizes for four dimension tensors.

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

Returns the tensor sizes for five dimension tensors.

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

Returns the tensor sizes for six dimension tensors.

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

Returns the stride of the input tensor.

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

Returns the tensor strides for single dimension tensors.

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

Returns the tensor strides for two dimension tensors.

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

Returns the tensor strides for three dimension tensors.

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

Returns the tensor strides for four dimension tensors.

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

Returns the tensor strides for five dimension tensors.

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

Returns the tensor strides for six dimension tensors.

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

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

pub fn kind(&self) -> Kind

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

pub fn device(&self) -> Device

Returns the device on which the input tensor is located.

pub fn print(&self)

Prints the input tensor.

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

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

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

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

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

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

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

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

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

pub fn requires_grad(&self) -> bool

Returns true if gradient are currently tracked for this tensor.

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

Returns the address of the first element of this tensor.

pub fn defined(&self) -> bool

Returns true if the tensor is defined.

pub fn is_mkldnn(&self) -> bool

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

pub fn is_sparse(&self) -> bool

Returns true if the tensor is sparse.

pub fn is_contiguous(&self) -> bool

pub fn zero_grad(&mut self)

Zeroes the gradient tensor attached to this tensor if defined.

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

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

Gradients tracking can be turned on via set_requires_grad.

pub fn backward(&self)

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

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

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

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

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

Copies numel elements from self to dst.

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

Unscale tensor while checking for infinities.

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

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

Unscale tensor while checking for infinities.

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

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

Copies numel elements from self to dst.

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

Copies numel elements from self to dst.

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

Copies numel elements from self to dst.

pub fn numel(&self) -> usize

Returns the total number of elements stored in a tensor.

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

Converts a slice to a tensor.

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

Converts a slice to a tensor.

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

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

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

Creates a tensor from data that is assumed to be initialized. Resize operations are not allowed on this tensor without copying the data first. An empty strides slice will result in using the default strides.

Safety

Behavior is undefined if data points to invalid data.

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

Creates a tensor from data that is assumed to be initialized. Resize operations are not allowed on this tensor without copying the data first. An empty strides slice will result in using the default strides.

Safety

Behavior is undefined if data points to invalid data.

pub fn from_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 load_from_stream<T: Read + Seek>(stream: T) -> Result<Tensor, TchError>

Loads a tensor from a stream.

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_to_stream<W: Write>(&self, stream: W) -> Result<(), TchError>

Saves a tensor to a stream.

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 save_multi_to_stream<S: AsRef<str>, T: AsRef<Tensor>, W: Write>( named_tensors: &[(S, T)], stream: W ) -> Result<(), TchError>

Saves some named tensors to a stream

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 for modules in the PyTorch C++ API. It commonly uses the .ot extension.

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 for modules in the PyTorch C++ API. It commonly uses the .ot extension.

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

Loads some named tensors from a zip file

The expected file format is a zip archive containing a data.pkl file describing the embedded tensors. These are commonly used with the .bin extension to export PyTorch models and weights using the Python api.

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

Loads some named tensors from a zip file to a given device

The expected file format is a zip archive containing a data.pkl file describing the embedded tensors. These are commonly used with the .bin extension to export PyTorch models and weights using the Python api.

pub fn load_multi_from_stream<T: Read + Seek>( stream: T ) -> Result<Vec<(String, Tensor)>, TchError>

Loads some named tensors from a stream

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

pub fn load_multi_from_stream_with_device<T: Read + Seek>( stream: T, device: Device ) -> Result<Vec<(String, Tensor)>, TchError>

Loads some named tensors from a stream to a given device

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

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

Returns a string representation for the tensor.

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

impl Tensor

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_internal_adaptive_avg_pool2d( &self, output_size: impl IntList ) -> Result<Tensor, TchError>

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

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

pub fn f_internal_adaptive_avg_pool2d_out( &self, out: &Tensor, output_size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_adaptive_avg_pool3d( &self, output_size: impl IntList ) -> Result<Tensor, TchError>

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

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

pub fn f_internal_adaptive_avg_pool3d_out( &self, out: &Tensor, output_size: impl IntList ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_internal_aminmax_out( &self, out0: &Tensor, out1: &Tensor ) -> Result<(Tensor, Tensor), TchError>

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

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

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

pub fn f_internal_assert_tensor_metadata( a: &Tensor, size: impl IntListOption, stride: impl IntListOption, dtype: impl Into<Option<Kind>> ) -> Result<(), TchError>

pub fn f_internal_autocast_to_full_precision( &self, cuda_enabled: bool, cpu_enabled: bool ) -> Result<Tensor, TchError>

pub fn f_internal_autocast_to_reduced_precision( &self, cuda_enabled: bool, cpu_enabled: bool, cuda_dtype: Kind, cpu_dtype: Kind ) -> 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_cdist_backward( grad: &Tensor, x1: &Tensor, x2: &Tensor, p: f64, cdist: &Tensor ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_internal_conv_depthwise2d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_conv_depthwise2d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_convert_indices_from_coo_to_csr( &self, size: i64, out_int32: bool ) -> Result<Tensor, TchError>

pub fn f_internal_convert_indices_from_coo_to_csr_out( &self, out: &Tensor, size: i64, out_int32: bool ) -> Result<Tensor, TchError>

pub fn f_internal_convert_indices_from_csr_to_coo( crow_indices: &Tensor, col_indices: &Tensor, out_int32: bool, transpose: bool ) -> Result<Tensor, TchError>

pub fn f_internal_convert_indices_from_csr_to_coo_out( out: &Tensor, crow_indices: &Tensor, col_indices: &Tensor, out_int32: bool, transpose: bool ) -> Result<Tensor, TchError>

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

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

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

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

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

pub fn f_internal_copy_from_and_resize( &self, dst: &Tensor ) -> Result<Tensor, TchError>

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

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

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

pub fn f_internal_cslt_sparse_mm<T: Borrow<Tensor>>( compressed_a: &Tensor, dense_b: &Tensor, bias: Option<T>, transpose_result: bool ) -> Result<Tensor, TchError>

pub fn f_internal_ctc_loss( log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, 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: impl IntList, target_lengths: impl IntList, neg_log_likelihood: &Tensor, log_alpha: &Tensor, blank: i64, zero_infinity: bool ) -> Result<Tensor, TchError>

pub fn f_internal_ctc_loss_backward_out( out: &Tensor, grad: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, neg_log_likelihood: &Tensor, log_alpha: &Tensor, blank: i64, zero_infinity: bool ) -> Result<Tensor, TchError>

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

pub fn f_internal_ctc_loss_out( out0: &Tensor, out1: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, blank: i64, zero_infinity: bool ) -> Result<(Tensor, Tensor), TchError>

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

pub fn f_internal_ctc_loss_tensor_out( out0: &Tensor, out1: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: &Tensor, target_lengths: &Tensor, blank: i64, zero_infinity: bool ) -> Result<(Tensor, Tensor), TchError>

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

pub fn f_internal_cudnn_ctc_loss_out( out0: &Tensor, out1: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, blank: i64, deterministic: bool, zero_infinity: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_cudnn_ctc_loss_tensor( log_probs: &Tensor, targets: &Tensor, input_lengths: &Tensor, target_lengths: &Tensor, 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_init_dropout_state_out( out: &Tensor, dropout: f64, train: bool, dropout_seed: i64 ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

pub fn f_internal_efficient_attention_backward<T: Borrow<Tensor>>( grad_out_: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, bias: Option<T>, out: &Tensor, cu_seqlens_q: Option<T>, cu_seqlens_k: Option<T>, max_seqlen_k: i64, max_seqlen_q: i64, logsumexp: &Tensor, dropout_p: f64, philox_seed: &Tensor, philox_offset: &Tensor, custom_mask_type: i64, bias_requires_grad: bool, scale: impl Into<Option<f64>>, num_splits_key: impl Into<Option<i64>> ) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_efficientzerotensor( size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_internal_efficientzerotensor_out( out: &Tensor, size: impl IntList ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

pub fn f_internal_empty_affine_quantized_out( out: &Tensor, size: impl IntList, scale: f64, zero_point: i64 ) -> Result<Tensor, TchError>

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

pub fn f_internal_empty_per_channel_affine_quantized_out( out: &Tensor, size: impl IntList, scales: &Tensor, zero_points: &Tensor, axis: i64 ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

pub fn f_internal_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out( &self, out0: &Tensor, out1: &Tensor, scale: &Tensor, zero_point: &Tensor, fake_quant_enabled: &Tensor, quant_min: i64, quant_max: i64 ) -> Result<(Tensor, Tensor), TchError>

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

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

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

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

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

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

pub fn f_internal_fill_mem_eff_dropout_mask_( &mut self, dropout_p: f64, seed: i64, offset: i64 ) -> Result<Tensor, TchError>

pub fn f_internal_flash_attention_backward( grad_out: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, out: &Tensor, logsumexp: &Tensor, cum_seq_q: &Tensor, cum_seq_k: &Tensor, max_q: i64, max_k: i64, dropout_p: f64, is_causal: bool, philox_seed: &Tensor, philox_offset: &Tensor, scale: impl Into<Option<f64>> ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_foobar( &self, arg1: bool, arg2: bool, arg3: bool ) -> Result<Tensor, TchError>

pub fn f_internal_foobar_out( &self, out: &Tensor, arg1: bool, arg2: bool, arg3: bool ) -> Result<Tensor, TchError>

pub fn f_internal_functional_assert_async( &self, assert_msg: &str, dep_token: &Tensor ) -> Result<Tensor, TchError>

pub fn f_internal_functional_sym_constrain_range<S: Into<Scalar>>( size: S, min: impl Into<Option<i64>>, max: impl Into<Option<i64>>, dep_token: &Tensor ) -> Result<Tensor, TchError>

pub fn f_internal_functional_sym_constrain_range_for_size<S: Into<Scalar>>( size: S, min: impl Into<Option<i64>>, max: impl Into<Option<i64>>, dep_token: &Tensor ) -> Result<Tensor, TchError>

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

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

pub fn f_internal_fused_moving_avg_obs_fq_helper( &self, observer_on: &Tensor, fake_quant_on: &Tensor, running_min: &Tensor, running_max: &Tensor, scale: &Tensor, zero_point: &Tensor, averaging_const: f64, quant_min: i64, quant_max: i64, ch_axis: i64, per_row_fake_quant: bool, symmetric_quant: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_fused_moving_avg_obs_fq_helper_functional( &self, observer_on: &Tensor, fake_quant_on: &Tensor, running_min: &Tensor, running_max: &Tensor, scale: &Tensor, zero_point: &Tensor, averaging_const: f64, quant_min: i64, quant_max: i64, ch_axis: i64, per_row_fake_quant: bool, symmetric_quant: bool ) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_fused_moving_avg_obs_fq_helper_out( &self, out0: &Tensor, out1: &Tensor, observer_on: &Tensor, fake_quant_on: &Tensor, running_min: &Tensor, running_max: &Tensor, scale: &Tensor, zero_point: &Tensor, averaging_const: f64, quant_min: i64, quant_max: i64, ch_axis: i64, per_row_fake_quant: bool, symmetric_quant: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_fused_sdp_choice<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, attn_mask: Option<T>, dropout_p: f64, is_causal: bool, scale: impl Into<Option<f64>> ) -> Result<i64, TchError>

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

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

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

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

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

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

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

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

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

pub fn f_internal_histogramdd_bin_edges<T: Borrow<Tensor>>( &self, bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool ) -> Result<Vec<Tensor>, TchError>

pub fn f_internal_histogramdd_bin_edges_out<T: Borrow<Tensor>>( &self, out: &[T], bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool ) -> Result<(), TchError>

pub fn f_internal_histogramdd_from_bin_cts<T: Borrow<Tensor>>( &self, bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool ) -> Result<Tensor, TchError>

pub fn f_internal_histogramdd_from_bin_cts_out<T: Borrow<Tensor>>( &self, out: &Tensor, bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool ) -> Result<Tensor, TchError>

pub fn f_internal_histogramdd_from_bin_tensors<T: Borrow<Tensor>>( &self, bins: &[T], weight: Option<T>, density: bool ) -> Result<Tensor, TchError>

pub fn f_internal_histogramdd_from_bin_tensors_out<T: Borrow<Tensor>>( &self, out: &Tensor, bins: &[T], weight: Option<T>, density: bool ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

pub fn f_internal_linalg_check_errors( info: &Tensor, api_name: &str, is_matrix: bool ) -> Result<(), TchError>

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

pub fn f_internal_linalg_det_result( result: &Tensor, lu: &Tensor, pivots: &Tensor, a: &Tensor ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_linalg_eigh( a: &Tensor, uplo: &str, compute_v: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_linalg_eigh_eigenvalues( eigenvalues: &Tensor, eigenvectors: &Tensor, a: &Tensor, uplo: &str, compute_v: bool ) -> Result<(Tensor, Tensor), TchError>

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

pub fn f_internal_linalg_slogdet_sign( sign: &Tensor, logabsdet: &Tensor, lu: &Tensor, pivots: &Tensor, a: &Tensor ) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_linalg_solve_ex( a: &Tensor, b: &Tensor, left: bool, check_errors: bool ) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_linalg_solve_ex_result( result: &Tensor, lu: &Tensor, pivots: &Tensor, info: &Tensor, a: &Tensor, b: &Tensor, left: bool, check_errors: bool ) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_linalg_svd( a: &Tensor, full_matrices: bool, compute_uv: bool, driver: &str ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_linalg_svd_u( u: &Tensor, s: &Tensor, vh: &Tensor, a: &Tensor, full_matrices: bool, compute_uv: bool, driver: &str ) -> Result<(Tensor, Tensor, 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( grad_output: &Tensor, output: &Tensor, dim: i64, input_dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_internal_log_softmax_backward_data_out( out: &Tensor, grad_output: &Tensor, output: &Tensor, dim: i64, input_dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_internal_log_softmax_out( &self, out: &Tensor, dim: i64, half_to_float: bool ) -> 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_lstm_mps<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, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_lstm_mps_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, out4: &Tensor, out5: &Tensor, hx: &[T], params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor, 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_dep_token( options: (Kind, Device) ) -> Result<Tensor, TchError>

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

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

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

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

pub fn f_internal_make_per_channel_quantized_tensor_out( &self, out: &Tensor, 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_make_per_tensor_quantized_tensor_out( &self, out: &Tensor, 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_masked_scale_out( &self, out: &Tensor, mask: &Tensor, scale: f64 ) -> Result<Tensor, TchError>

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

pub fn f_internal_masked_softmax_backward( grad_output: &Tensor, output: &Tensor, mask: &Tensor, dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_internal_masked_softmax_backward_out( out: &Tensor, grad_output: &Tensor, output: &Tensor, mask: &Tensor, dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

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

pub fn f_internal_mkldnn_reshape( &self, shape: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_mkldnn_reshape_out( &self, out: &Tensor, shape: impl IntList ) -> 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_mkldnn_transpose_out( &self, out: &Tensor, dim0: i64, dim1: i64 ) -> Result<Tensor, TchError>

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

pub fn f_internal_mps_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

pub fn f_internal_mps_convolution_transpose( &self, weight: &Tensor, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

pub fn f_internal_mps_convolution_transpose_out( &self, out: &Tensor, weight: &Tensor, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

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

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

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

pub fn f_internal_native_batch_norm_legit_no_stats_out<T: Borrow<Tensor>>( &self, out: &Tensor, save_mean: &Tensor, save_invstd: &Tensor, weight: Option<T>, bias: Option<T>, training: bool, momentum: f64, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

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

pub fn f_internal_native_batch_norm_legit_no_training_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, weight: Option<T>, bias: Option<T>, running_mean: &Tensor, running_var: &Tensor, momentum: f64, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

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

pub fn f_internal_native_multi_head_attention<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, embed_dim: i64, num_head: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, mask: Option<T>, need_weights: bool, average_attn_weights: bool, mask_type: impl Into<Option<i64>> ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_native_multi_head_attention_out<T: Borrow<Tensor>>( out0: &Tensor, out1: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, embed_dim: i64, num_head: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, mask: Option<T>, need_weights: bool, average_attn_weights: bool, mask_type: impl Into<Option<i64>> ) -> Result<(Tensor, Tensor), TchError>

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

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

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

pub fn f_internal_nested_from_padded( padded: &Tensor, cpu_nested_shape_example: &Tensor, fuse_transform_0213: bool ) -> Result<Tensor, TchError>

pub fn f_internal_nested_from_padded_and_nested_example( padded: &Tensor, nt_example: &Tensor ) -> Result<Tensor, TchError>

pub fn f_internal_nested_from_padded_and_nested_example_out( out: &Tensor, padded: &Tensor, nt_example: &Tensor ) -> Result<Tensor, TchError>

pub fn f_internal_nested_from_padded_out( out: &Tensor, padded: &Tensor, cpu_nested_shape_example: &Tensor, fuse_transform_0213: bool ) -> Result<Tensor, TchError>

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

pub fn f_internal_nested_sum_backward( &self, grad: &Tensor, dim: impl IntListOption, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_internal_nested_view_from_buffer( &self, nested_size: &Tensor, nested_strides: &Tensor, offsets: &Tensor ) -> Result<Tensor, TchError>

pub fn f_internal_nested_view_from_buffer_copy( &self, nested_size: &Tensor, nested_strides: &Tensor, offsets: &Tensor ) -> Result<Tensor, TchError>

pub fn f_internal_nested_view_from_buffer_copy_out( &self, out: &Tensor, nested_size: &Tensor, nested_strides: &Tensor, offsets: &Tensor ) -> Result<Tensor, TchError>

pub fn f_internal_new_zeros_with_same_feature_meta( &self, other: &Tensor, self_num_batch_dims: i64 ) -> Result<Tensor, TchError>

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

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

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

pub fn f_internal_nnpack_spatial_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>

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

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

pub fn f_internal_pack_padded_sequence_backward( grad: &Tensor, input_size: impl IntList, batch_sizes: &Tensor, batch_first: bool ) -> Result<Tensor, TchError>

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

pub fn f_internal_pad_circular( &self, pad: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_pad_enum( &self, pad: impl IntList, mode: i64, value: impl Into<Option<f64>> ) -> 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_pdist_backward_out( &self, out: &Tensor, grad: &Tensor, p: f64, pdist: &Tensor ) -> Result<Tensor, TchError>

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

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

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

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

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

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

pub fn f_internal_reshape_alias( &self, size: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_reshape_alias_copy( &self, size: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_reshape_alias_copy_out( &self, out: &Tensor, size: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_reshape_copy( &self, size: impl IntList ) -> Result<Tensor, TchError>

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

pub fn f_internal_resize_output( &self, size: impl IntList, device: Device ) -> Result<Tensor, TchError>

pub fn f_internal_resize_output_( &mut self, size: impl IntList, device: Device ) -> Result<Tensor, TchError>

pub fn f_internal_resize_output_out( &self, out: &Tensor, size: impl IntList, device: Device ) -> Result<Tensor, TchError>

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

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

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

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

pub fn f_internal_scaled_dot_product_attention_math<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, attn_mask: Option<T>, dropout_p: f64, is_causal: bool, dropout_mask: Option<T>, scale: impl Into<Option<f64>> ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_scaled_dot_product_efficient_attention<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, attn_bias: Option<T>, compute_log_sumexp: bool, dropout_p: f64, is_causal: bool, scale: impl Into<Option<f64>> ) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_internal_scaled_dot_product_flash_attention_backward( grad_out: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, out: &Tensor, logsumexp: &Tensor, cum_seq_q: &Tensor, cum_seq_k: &Tensor, max_q: i64, max_k: i64, dropout_p: f64, is_causal: bool, philox_seed: &Tensor, philox_offset: &Tensor, scale: impl Into<Option<f64>> ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_scaled_mm<T: Borrow<Tensor>>( &self, mat2: &Tensor, bias: Option<T>, out_dtype: impl Into<Option<Kind>>, scale_a: Option<T>, scale_b: Option<T>, scale_result: Option<T> ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_scaled_mm_out<T: Borrow<Tensor>>( &self, out: &Tensor, out_amax: &Tensor, mat2: &Tensor, bias: Option<T>, out_dtype: impl Into<Option<Kind>>, scale_a: Option<T>, scale_b: Option<T>, scale_result: Option<T> ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_scatter_reduce( &self, dim: i64, index: &Tensor, src: &Tensor, reduce: &str, include_self: bool ) -> Result<Tensor, TchError>

pub fn f_internal_scatter_reduce_( &mut self, dim: i64, index: &Tensor, src: &Tensor, reduce: &str, include_self: bool ) -> Result<Tensor, TchError>

pub fn f_internal_scatter_reduce_two_out( &self, out: &Tensor, dim: i64, index: &Tensor, src: &Tensor, reduce: &str, include_self: bool ) -> Result<Tensor, TchError>

pub fn f_internal_segment_reduce_backward<T: Borrow<Tensor>, S: Into<Scalar>>( grad: &Tensor, output: &Tensor, data: &Tensor, reduce: &str, lengths: Option<T>, offsets: Option<T>, axis: i64, initial: S ) -> Result<Tensor, TchError>

pub fn f_internal_segment_reduce_backward_out<T: Borrow<Tensor>, S: Into<Scalar>>( out: &Tensor, grad: &Tensor, output: &Tensor, data: &Tensor, reduce: &str, lengths: Option<T>, offsets: Option<T>, axis: i64, initial: S ) -> Result<Tensor, TchError>

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

pub fn f_internal_slow_conv2d_backward( &self, grad_input: &Tensor, grad_weight: &Tensor, grad_bias: &Tensor, grad_output: &Tensor, weight: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_sobol_engine_draw( quasi: &Tensor, n: i64, sobolstate: &Tensor, dimension: i64, num_generated: i64, dtype: impl Into<Option<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( grad_output: &Tensor, output: &Tensor, dim: i64, input_dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_internal_softmax_backward_data_out( grad_input: &Tensor, grad_output: &Tensor, output: &Tensor, dim: i64, input_dtype: Kind ) -> Result<Tensor, TchError>

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

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

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

pub fn f_internal_sparse_broadcast_to( &self, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_broadcast_to_copy( &self, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_broadcast_to_copy_out( &self, out: &Tensor, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_bsc_tensor_unsafe( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_bsr_tensor_unsafe( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_compressed_tensor_unsafe( compressed_indices: &Tensor, plain_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_coo_tensor_unsafe( indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device), is_coalesced: bool ) -> Result<Tensor, TchError>

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

pub fn f_internal_sparse_coo_tensor_with_dims_and_tensors( sparse_dim: i64, dense_dim: i64, size: impl IntList, indices: &Tensor, values: &Tensor, options: (Kind, Device), is_coalesced: bool ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_coo_tensor_with_dims_and_tensors_out( out: &Tensor, sparse_dim: i64, dense_dim: i64, size: impl IntList, indices: &Tensor, values: &Tensor, is_coalesced: bool ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_coo_tensor_with_dims_out( out: &Tensor, sparse_dim: i64, dense_dim: i64, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_csc_tensor_unsafe( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_csr_prod( &self, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_csr_prod_dim_dtype_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_csr_sum( &self, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_csr_sum_dim_dtype_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_csr_tensor_unsafe( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

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

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

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

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

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

pub fn f_internal_sparse_mask_projection( &self, mask: &Tensor, accumulate_matches: bool ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_mask_projection_out( &self, out: &Tensor, mask: &Tensor, accumulate_matches: bool ) -> Result<Tensor, TchError>

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

pub fn f_internal_sparse_mm_reduce( sparse: &Tensor, dense: &Tensor, reduce: &str ) -> Result<Tensor, TchError>

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

pub fn f_internal_sparse_semi_structured_linear<T: Borrow<Tensor>>( &self, weight: &Tensor, meta: &Tensor, bias: Option<T>, activation: &str ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

pub fn f_internal_sparse_sum_backward( &self, grad: &Tensor, dim: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sum_backward_out( &self, out: &Tensor, grad: &Tensor, dim: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sum_dim( &self, dim: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sum_dim_dtype( &self, dim: impl IntList, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_internal_sparse_sum_dim_out( &self, out: &Tensor, dim: impl IntList ) -> Result<Tensor, TchError>

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

pub fn f_internal_spdiags( diagonals: &Tensor, offsets: &Tensor, shape: impl IntList, layout: Option<Layout> ) -> Result<Tensor, TchError>

pub fn f_internal_spdiags_out( out: &Tensor, diagonals: &Tensor, offsets: &Tensor, shape: impl IntList, layout: Option<Layout> ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

pub fn f_internal_test_autograd_multiple_dispatch_ntonly( &self, b: bool ) -> Result<Tensor, TchError>

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

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

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

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

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

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

pub fn f_internal_test_optional_filled_intlist( values: &Tensor, addends: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_internal_test_optional_filled_intlist_out( out: &Tensor, values: &Tensor, addends: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_internal_test_optional_floatlist( values: &Tensor, addends: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_internal_test_optional_floatlist_out( out: &Tensor, values: &Tensor, addends: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_internal_test_optional_intlist( values: &Tensor, addends: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_internal_test_optional_intlist_out( out: &Tensor, values: &Tensor, addends: impl IntListOption ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

pub fn f_internal_to_dense( &self, dtype: impl Into<Option<Kind>>, masked_grad: bool ) -> Result<Tensor, TchError>

pub fn f_internal_to_dense_out( &self, out: &Tensor, dtype: impl Into<Option<Kind>>, masked_grad: bool ) -> Result<Tensor, TchError>

pub fn f_internal_to_sparse( &self, layout: Option<Layout>, blocksize: impl IntListOption, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_internal_to_sparse_bsc( &self, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_internal_to_sparse_bsc_out( &self, out: &Tensor, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_internal_to_sparse_bsr( &self, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_internal_to_sparse_bsr_out( &self, out: &Tensor, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

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

pub fn f_internal_to_sparse_csc_out( &self, out: &Tensor, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

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

pub fn f_internal_to_sparse_csr_out( &self, out: &Tensor, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_internal_to_sparse_out( &self, out: &Tensor, layout: Option<Layout>, blocksize: impl IntListOption, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

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

pub fn f_internal_to_sparse_sparse_dim( &self, sparse_dim: i64 ) -> Result<Tensor, TchError>

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

pub fn f_internal_transform_bias_rescale_qkv( qkv: &Tensor, qkv_bias: &Tensor, num_heads: i64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_transform_bias_rescale_qkv_out( out0: &Tensor, out1: &Tensor, out2: &Tensor, qkv: &Tensor, qkv_bias: &Tensor, num_heads: i64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_internal_transformer_encoder_layer_fwd<T: Borrow<Tensor>>( src: &Tensor, embed_dim: i64, num_heads: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, use_gelu: bool, norm_first: bool, eps: f64, norm_weight_1: &Tensor, norm_bias_1: &Tensor, norm_weight_2: &Tensor, norm_bias_2: &Tensor, ffn_weight_1: &Tensor, ffn_bias_1: &Tensor, ffn_weight_2: &Tensor, ffn_bias_2: &Tensor, mask: Option<T>, mask_type: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_internal_transformer_encoder_layer_fwd_out<T: Borrow<Tensor>>( out: &Tensor, src: &Tensor, embed_dim: i64, num_heads: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, use_gelu: bool, norm_first: bool, eps: f64, norm_weight_1: &Tensor, norm_bias_1: &Tensor, norm_weight_2: &Tensor, norm_bias_2: &Tensor, ffn_weight_1: &Tensor, ffn_bias_1: &Tensor, ffn_weight_2: &Tensor, ffn_bias_2: &Tensor, mask: Option<T>, mask_type: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

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

pub fn f_internal_trilinear_out( out: &Tensor, i1: &Tensor, i2: &Tensor, i3: &Tensor, expand1: impl IntList, expand2: impl IntList, expand3: impl IntList, sumdim: impl IntList, unroll_dim: i64 ) -> Result<Tensor, TchError>

pub fn f_internal_triton_multi_head_attention<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, embed_dim: i64, num_head: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, mask: Option<T> ) -> Result<Tensor, TchError>

pub fn f_internal_triton_multi_head_attention_out<T: Borrow<Tensor>>( out: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, embed_dim: i64, num_head: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, mask: Option<T> ) -> Result<Tensor, TchError>

pub fn f_internal_triton_scaled_dot_attention( q: &Tensor, k: &Tensor, v: &Tensor, dropout_p: f64 ) -> Result<Tensor, TchError>

pub fn f_internal_triton_scaled_dot_attention_out( out: &Tensor, q: &Tensor, k: &Tensor, v: &Tensor, dropout_p: f64 ) -> 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_unique2_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, sorted: bool, return_inverse: bool, return_counts: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

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

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

pub fn f_internal_unsafe_index<T: Borrow<Tensor>>( &self, indices: &[Option<T>] ) -> Result<Tensor, TchError>

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

pub fn f_internal_unsafe_view( &self, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_unsafe_view_out( &self, out: &Tensor, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bicubic2d_aa( &self, output_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bicubic2d_aa_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bicubic2d_aa_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bicubic2d_aa_out( &self, out: &Tensor, output_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bicubic2d_aa_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bilinear2d_aa( &self, output_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bilinear2d_aa_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bilinear2d_aa_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bilinear2d_aa_out( &self, out: &Tensor, output_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_bilinear2d_aa_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact1d( &self, output_size: impl IntList, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact1d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact1d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact1d_out( &self, out: &Tensor, output_size: impl IntList, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact1d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact2d( &self, output_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact2d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact2d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact2d_out( &self, out: &Tensor, output_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact2d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact3d( &self, output_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact3d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact3d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact3d_out( &self, out: &Tensor, output_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_internal_upsample_nearest_exact3d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

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

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

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

pub fn f_internal_validate_compressed_sparse_indices( is_crow: bool, compressed_idx: &Tensor, plain_idx: &Tensor, cdim: i64, dim: i64, nnz: i64 ) -> Result<(), TchError>

pub fn f_internal_validate_sparse_bsc_tensor_args( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList ) -> Result<(), TchError>

pub fn f_internal_validate_sparse_bsr_tensor_args( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList ) -> Result<(), TchError>

pub fn f_internal_validate_sparse_compressed_tensor_args( compressed_indices: &Tensor, plain_indices: &Tensor, values: &Tensor, size: impl IntList, layout: Layout ) -> Result<(), TchError>

pub fn f_internal_validate_sparse_csc_tensor_args( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList ) -> Result<(), TchError>

pub fn f_internal_validate_sparse_csr_tensor_args( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList ) -> Result<(), TchError>

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

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

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

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

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

pub fn f_internal_weight_norm_differentiable_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_interface( v: &Tensor, g: &Tensor, dim: i64 ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_weight_norm_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_interface_backward_out( out0: &Tensor, out1: &Tensor, grad_w: &Tensor, saved_v: &Tensor, saved_g: &Tensor, saved_norms: &Tensor, dim: i64 ) -> Result<(Tensor, Tensor), TchError>

pub fn f_internal_weight_norm_interface_out( out0: &Tensor, out1: &Tensor, v: &Tensor, g: &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: impl IntList ) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool2d( &self, output_size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool2d_out( &self, out: &Tensor, output_size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_adaptive_avg_pool3d( &self, output_size: impl IntList ) -> Result<Tensor, TchError>

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

pub fn f_adaptive_avg_pool3d_out( &self, out: &Tensor, output_size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_adaptive_max_pool1d( &self, output_size: impl IntList ) -> Result<(Tensor, Tensor), TchError>

pub fn f_adaptive_max_pool2d( &self, output_size: impl IntList ) -> Result<(Tensor, Tensor), TchError>

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

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

pub fn f_adaptive_max_pool2d_out( &self, out: &Tensor, indices: &Tensor, output_size: impl IntList ) -> Result<(Tensor, Tensor), TchError>

pub fn f_adaptive_max_pool3d( &self, output_size: impl IntList ) -> Result<(Tensor, Tensor), TchError>

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

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

pub fn f_adaptive_max_pool3d_out( &self, out: &Tensor, indices: &Tensor, output_size: impl IntList ) -> Result<(Tensor, Tensor), TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_affine_grid_generator( theta: &Tensor, size: impl IntList, align_corners: bool ) -> Result<Tensor, TchError>

pub fn f_affine_grid_generator_backward( grad: &Tensor, size: impl IntList, align_corners: bool ) -> Result<Tensor, TchError>

pub fn f_affine_grid_generator_out( out: &Tensor, theta: &Tensor, size: impl IntList, align_corners: bool ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_amax( &self, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_amax_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_amin( &self, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_amin_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_as_strided_copy_out( &self, out: &Tensor, size: impl IntList, stride: impl IntList, storage_offset: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_as_strided_scatter( &self, src: &Tensor, size: impl IntList, stride: impl IntList, storage_offset: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_as_strided_scatter_out( &self, out: &Tensor, src: &Tensor, size: impl IntList, stride: impl IntList, storage_offset: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_avg_pool2d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, 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: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_avg_pool2d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, 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: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_avg_pool3d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, 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: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_avg_pool3d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, 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: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_baddbmm<S: Into<Scalar>>( &self, batch1: &Tensor, batch2: &Tensor, beta: S, alpha: S ) -> Result<Tensor, TchError>

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

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

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

pub fn f_bartlett_window_out( out: &Tensor, window_length: i64 ) -> Result<Tensor, TchError>

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

pub fn f_bartlett_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> 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>, sum_dy: &Tensor, sum_dy_xmu: &Tensor, count: &Tensor ) -> Result<Tensor, TchError>

pub fn f_batch_norm_backward_elemt_out<T: Borrow<Tensor>>( &self, out: &Tensor, grad_out: &Tensor, mean: &Tensor, invstd: &Tensor, weight: Option<T>, sum_dy: &Tensor, sum_dy_xmu: &Tensor, count: &Tensor ) -> Result<Tensor, TchError>

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

pub fn f_batch_norm_backward_reduce_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, 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_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, 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_gather_stats_with_counts_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, 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_stats_out( &self, out0: &Tensor, out1: &Tensor, 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_batch_norm_update_stats_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, running_mean: Option<T>, running_var: Option<T>, momentum: f64 ) -> Result<(Tensor, Tensor), TchError>

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

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

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

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

pub fn f_bernoulli_tensor(&self, p: &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_grad_input<T: Borrow<Tensor>>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction ) -> Result<Tensor, TchError>

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

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

pub fn f_binary_cross_entropy_with_logits_out<T: Borrow<Tensor>>( &self, out: &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_bincount_out<T: Borrow<Tensor>>( &self, out: &Tensor, weights: Option<T>, minlength: i64 ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_bitwise_left_shift_tensor_scalar_out<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_or_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_bitwise_right_shift_tensor_scalar_out<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_xor_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

pub fn f_blackman_window_out( out: &Tensor, window_length: i64 ) -> Result<Tensor, TchError>

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

pub fn f_blackman_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> Result<Tensor, TchError>

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

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

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

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

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

pub fn f_broadcast_to(&self, size: impl IntList) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_ccol_indices_copy_out(&self, out: &Tensor) -> 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_celu_out(&self, out: &Tensor) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_constant_pad_nd(&self, pad: impl IntList) -> Result<Tensor, TchError>

pub fn f_constant_pad_nd_out( &self, out: &Tensor, pad: impl IntList ) -> 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: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

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

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

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

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

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

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

pub fn f_conv_depthwise3d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> 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_tbc_out( &self, out: &Tensor, weight: &Tensor, bias: &Tensor, pad: i64 ) -> Result<Tensor, TchError>

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

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

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

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

pub fn f_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, transposed: bool, output_padding: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

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

pub fn f_convolution_overrideable_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, transposed: bool, output_padding: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_count_nonzero_dim_intlist( &self, dim: impl IntList ) -> Result<Tensor, TchError>

pub fn f_count_nonzero_dim_intlist_out( &self, out: &Tensor, dim: impl IntList ) -> Result<Tensor, TchError>

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

pub fn f_cov<T: Borrow<Tensor>>( &self, correction: i64, fweights: Option<T>, aweights: Option<T> ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

pub fn f_cudnn_affine_grid_generator_out( out: &Tensor, theta: &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_batch_norm_backward_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, 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_batch_norm_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, 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_convolution( &self, weight: &Tensor, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool, allow_tf32: bool ) -> Result<Tensor, TchError>

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

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

pub fn f_cudnn_convolution_out( &self, out: &Tensor, weight: &Tensor, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool, allow_tf32: bool ) -> Result<Tensor, TchError>

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

pub fn f_cudnn_convolution_relu_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

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

pub fn f_cudnn_convolution_transpose_out( &self, out: &Tensor, weight: &Tensor, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool, allow_tf32: bool ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_cumulative_trapezoid(y: &Tensor, dim: i64) -> Result<Tensor, TchError>

pub fn f_cumulative_trapezoid_x( y: &Tensor, x: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

pub fn f_dequantize_tensors_out<T: Borrow<Tensor>>( out: &[T], tensors: &[T] ) -> Result<(), 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_detach_copy(&self) -> Result<Tensor, TchError>

pub fn f_detach_copy_out(&self, out: &Tensor) -> 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_embed_out( &self, out: &Tensor, offset: i64, dim1: i64, dim2: i64 ) -> Result<Tensor, TchError>

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

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

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

pub fn f_diagonal_backward( grad_output: &Tensor, input_sizes: impl IntList, offset: i64, dim1: i64, dim2: i64 ) -> Result<Tensor, TchError>

pub fn f_diagonal_backward_out( out: &Tensor, grad_output: &Tensor, input_sizes: impl IntList, offset: i64, dim1: i64, dim2: i64 ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_dsplit_array( &self, indices: impl IntList ) -> Result<Vec<Tensor>, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_embedding_renorm( &self, indices: &Tensor, max_norm: f64, norm_type: f64 ) -> 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_renorm_out( &self, out: &Tensor, 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: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

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

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

pub fn f_empty_out(out: &Tensor, size: impl IntList) -> Result<Tensor, TchError>

pub fn f_empty_permuted( size: impl IntList, physical_layout: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_empty_permuted_out( out: &Tensor, size: impl IntList, physical_layout: impl IntList ) -> Result<Tensor, TchError>

pub fn f_empty_quantized( size: impl IntList, qtensor: &Tensor, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_empty_quantized_out( out: &Tensor, size: impl IntList, qtensor: &Tensor ) -> Result<Tensor, TchError>

pub fn f_empty_strided( size: impl IntList, stride: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_empty_strided_out( out: &Tensor, size: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_expand( &self, size: impl IntList, implicit: bool ) -> Result<Tensor, TchError>

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

pub fn f_expand_copy( &self, size: impl IntList, implicit: bool ) -> Result<Tensor, TchError>

pub fn f_expand_copy_out( &self, out: &Tensor, size: impl IntList, implicit: bool ) -> 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(&self, lambd: f64) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_fake_quantize_per_tensor_affine_tensor_qparams( &self, scale: &Tensor, zero_point: &Tensor, 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_matrix_kn( &self, k: i64, n: i64 ) -> Result<Tensor, TchError>

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

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

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

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

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

pub fn f_fft_fft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_fft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

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

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

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

pub fn f_fft_fftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_fftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_fftshift( &self, dim: impl IntListOption ) -> Result<Tensor, TchError>

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

pub fn f_fft_hfft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_hfft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

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

pub fn f_fft_hfftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_hfftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

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

pub fn f_fft_ifft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_ifft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

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

pub fn f_fft_ifftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_ifftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_ifftshift( &self, dim: impl IntListOption ) -> Result<Tensor, TchError>

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

pub fn f_fft_ihfft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_ihfft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

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

pub fn f_fft_ihfftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_ihfftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

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

pub fn f_fft_irfft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_irfft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

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

pub fn f_fft_irfftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_irfftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

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

pub fn f_fft_rfft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_rfft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Result<Tensor, TchError>

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

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

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

pub fn f_fft_rfftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

pub fn f_fft_rfftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_flip(&self, dims: impl IntList) -> Result<Tensor, TchError>

pub fn f_flip_out( &self, out: &Tensor, dims: impl IntList ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_fractional_max_pool2d( &self, kernel_size: impl IntList, output_size: impl IntList, random_samples: &Tensor ) -> Result<(Tensor, Tensor), TchError>

pub fn f_fractional_max_pool2d_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, output_size: impl IntList, indices: &Tensor ) -> Result<Tensor, TchError>

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

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

pub fn f_fractional_max_pool3d( &self, kernel_size: impl IntList, output_size: impl IntList, random_samples: &Tensor ) -> Result<(Tensor, Tensor), TchError>

pub fn f_fractional_max_pool3d_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, output_size: impl IntList, indices: &Tensor ) -> Result<Tensor, TchError>

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

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

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

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

pub fn f_frobenius_norm( &self, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_frobenius_norm_out( &self, out: &Tensor, dim: impl IntList, 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_from_file_out( out: &Tensor, filename: &str, shared: bool, size: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_full<S: Into<Scalar>>( size: impl IntList, 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_like_out<S: Into<Scalar>>( &self, out: &Tensor, fill_value: S ) -> Result<Tensor, TchError>

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

pub fn f_fused_moving_avg_obs_fake_quant( &self, observer_on: &Tensor, fake_quant_on: &Tensor, running_min: &Tensor, running_max: &Tensor, scale: &Tensor, zero_point: &Tensor, averaging_const: f64, quant_min: i64, quant_max: i64, ch_axis: i64, per_row_fake_quant: bool, symmetric_quant: bool ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_gelu(&self, approximate: &str) -> Result<Tensor, TchError>

pub fn f_gelu_(&mut self, approximate: &str) -> Result<Tensor, TchError>

pub fn f_gelu_backward( &self, grad_output: &Tensor, approximate: &str ) -> Result<Tensor, TchError>

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

pub fn f_gelu_out( &self, out: &Tensor, approximate: &str ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

pub fn f_glu_backward_jvp( grad_x: &Tensor, grad_glu: &Tensor, x: &Tensor, dgrad_glu: &Tensor, dx: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_glu_backward_jvp_out( out: &Tensor, grad_x: &Tensor, grad_glu: &Tensor, x: &Tensor, dgrad_glu: &Tensor, dx: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_glu_jvp( glu: &Tensor, x: &Tensor, dx: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_glu_jvp_out( out: &Tensor, glu: &Tensor, x: &Tensor, dx: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn f_grid_sampler_2d_out( &self, out: &Tensor, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> Result<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_out( &self, out: &Tensor, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> Result<Tensor, TchError>

pub fn f_group_norm<T: Borrow<Tensor>>( &self, num_groups: i64, weight: Option<T>, bias: Option<T>, eps: f64, cudnn_enabled: bool ) -> Result<Tensor, TchError>

pub fn f_gru<T: Borrow<Tensor>>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_gru_cell<T: Borrow<Tensor>>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Result<Tensor, TchError>

pub fn f_gru_data<T: Borrow<Tensor>>( data: &Tensor, batch_sizes: &Tensor, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool ) -> Result<(Tensor, Tensor), TchError>

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

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

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

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

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

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

pub fn f_hamming_window( window_length: i64, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_hamming_window_out( out: &Tensor, window_length: i64 ) -> Result<Tensor, TchError>

pub fn f_hamming_window_periodic( window_length: i64, periodic: bool, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_hamming_window_periodic_alpha( window_length: i64, periodic: bool, alpha: f64, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_hamming_window_periodic_alpha_beta( window_length: i64, periodic: bool, alpha: f64, beta: f64, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_hamming_window_periodic_alpha_beta_out( out: &Tensor, window_length: i64, periodic: bool, alpha: f64, beta: f64 ) -> Result<Tensor, TchError>

pub fn f_hamming_window_periodic_alpha_out( out: &Tensor, window_length: i64, periodic: bool, alpha: f64 ) -> Result<Tensor, TchError>

pub fn f_hamming_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> Result<Tensor, TchError>

pub fn f_hann_window( window_length: i64, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_hann_window_out( out: &Tensor, window_length: i64 ) -> Result<Tensor, TchError>

pub fn f_hann_window_periodic( window_length: i64, periodic: bool, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_hann_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> 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_hardshrink_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_out: &Tensor, lambd: S ) -> Result<Tensor, TchError>

pub fn f_hardshrink_out(&self, out: &Tensor) -> 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_backward_grad_input( &self, grad_input: &Tensor, 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_backward_out( &self, out: &Tensor, grad_output: &Tensor ) -> Result<Tensor, TchError>

pub fn f_hardswish_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_hardtanh(&self) -> Result<Tensor, TchError>

pub fn f_hardtanh_(&mut self) -> Result<Tensor, TchError>

pub fn f_hardtanh_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, min_val: S, max_val: S ) -> Result<Tensor, TchError>

pub fn f_hardtanh_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, min_val: S, max_val: S ) -> Result<Tensor, TchError>

pub fn f_hardtanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_heaviside(&self, values: &Tensor) -> Result<Tensor, TchError>

pub fn f_heaviside_(&mut self, values: &Tensor) -> Result<Tensor, TchError>

pub fn f_heaviside_out( &self, out: &Tensor, values: &Tensor ) -> Result<Tensor, TchError>

pub fn f_hinge_embedding_loss( &self, target: &Tensor, margin: f64, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_histc(&self, bins: i64) -> Result<Tensor, TchError>

pub fn f_histc_out(&self, out: &Tensor, bins: i64) -> Result<Tensor, TchError>

pub fn f_histogram<T: Borrow<Tensor>>( &self, bins: &Tensor, weight: Option<T>, density: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_histogram_bin_ct<T: Borrow<Tensor>>( &self, bins: i64, range: impl DoubleList, weight: Option<T>, density: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_histogram_bin_ct_out<T: Borrow<Tensor>>( &self, hist: &Tensor, bin_edges: &Tensor, bins: i64, range: impl DoubleList, weight: Option<T>, density: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_histogram_bins_tensor_out<T: Borrow<Tensor>>( &self, hist: &Tensor, bin_edges: &Tensor, bins: &Tensor, weight: Option<T>, density: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_hsplit(&self, sections: i64) -> Result<Vec<Tensor>, TchError>

pub fn f_hsplit_array( &self, indices: impl IntList ) -> Result<Vec<Tensor>, TchError>

pub fn f_hspmm(mat1: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_hspmm_out( out: &Tensor, mat1: &Tensor, mat2: &Tensor ) -> Result<Tensor, TchError>

pub fn f_hstack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>

pub fn f_hstack_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T] ) -> Result<Tensor, TchError>

pub fn f_huber_loss( &self, target: &Tensor, reduction: Reduction, delta: f64 ) -> Result<Tensor, TchError>

pub fn f_huber_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction, delta: f64 ) -> Result<Tensor, TchError>

pub fn f_huber_loss_backward_out( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction, delta: f64 ) -> Result<Tensor, TchError>

pub fn f_huber_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction, delta: f64 ) -> Result<Tensor, TchError>

pub fn f_hypot(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_hypot_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_hypot_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_i0(&self) -> Result<Tensor, TchError>

pub fn f_i0_(&mut self) -> Result<Tensor, TchError>

pub fn f_i0_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_igamma(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_igamma_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_igamma_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_igammac(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_igammac_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_igammac_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_im2col( &self, kernel_size: impl IntList, dilation: impl IntList, padding: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>

pub fn f_im2col_out( &self, out: &Tensor, kernel_size: impl IntList, dilation: impl IntList, padding: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>

pub fn f_imag(&self) -> Result<Tensor, TchError>

pub fn f_index<T: Borrow<Tensor>>( &self, indices: &[Option<T>] ) -> Result<Tensor, TchError>

pub fn f_index_add( &self, dim: i64, index: &Tensor, source: &Tensor ) -> Result<Tensor, TchError>

pub fn f_index_add_( &mut self, dim: i64, index: &Tensor, source: &Tensor ) -> Result<Tensor, TchError>

pub fn f_index_add_out( &self, out: &Tensor, 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_copy_out( &self, out: &Tensor, dim: i64, index: &Tensor, source: &Tensor ) -> Result<Tensor, TchError>

pub fn f_index_fill<S: Into<Scalar>>( &self, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>

pub fn f_index_fill_<S: Into<Scalar>>( &mut self, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>

pub fn f_index_fill_int_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>

pub fn f_index_fill_int_tensor( &self, dim: i64, index: &Tensor, value: &Tensor ) -> Result<Tensor, TchError>

pub fn f_index_fill_int_tensor_( &mut self, dim: i64, index: &Tensor, value: &Tensor ) -> Result<Tensor, TchError>

pub fn f_index_fill_int_tensor_out( &self, out: &Tensor, dim: i64, index: &Tensor, value: &Tensor ) -> Result<Tensor, TchError>

pub fn f_index_put<T: Borrow<Tensor>>( &self, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Result<Tensor, TchError>

pub fn f_index_put_<T: Borrow<Tensor>>( &mut self, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Result<Tensor, TchError>

pub fn f_index_put_out<T: Borrow<Tensor>>( &self, out: &Tensor, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Result<Tensor, TchError>

pub fn f_index_reduce( &self, dim: i64, index: &Tensor, source: &Tensor, reduce: &str, include_self: bool ) -> Result<Tensor, TchError>

pub fn f_index_reduce_( &mut self, dim: i64, index: &Tensor, source: &Tensor, reduce: &str, include_self: bool ) -> Result<Tensor, TchError>

pub fn f_index_reduce_out( &self, out: &Tensor, dim: i64, index: &Tensor, source: &Tensor, reduce: &str, include_self: bool ) -> Result<Tensor, TchError>

pub fn f_index_select( &self, dim: i64, index: &Tensor ) -> Result<Tensor, TchError>

pub fn f_index_select_backward( grad: &Tensor, self_sizes: impl IntList, 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_index_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, indices: &[Option<T>] ) -> Result<Tensor, TchError>

pub fn f_indices(&self) -> Result<Tensor, TchError>

pub fn f_indices_copy(&self) -> Result<Tensor, TchError>

pub fn f_indices_copy_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_infinitely_differentiable_gelu_backward( &self, grad: &Tensor ) -> Result<Tensor, TchError>

pub fn f_inner(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_inner_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_instance_norm<T: Borrow<Tensor>>( &self, weight: Option<T>, bias: Option<T>, running_mean: Option<T>, running_var: Option<T>, use_input_stats: bool, momentum: f64, eps: f64, cudnn_enabled: bool ) -> Result<Tensor, TchError>

pub fn f_int_repr(&self) -> Result<Tensor, TchError>

pub fn f_int_repr_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_inverse(&self) -> Result<Tensor, TchError>

pub fn f_inverse_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_is_coalesced(&self) -> Result<bool, TchError>

pub fn f_is_complex(&self) -> Result<bool, TchError>

pub fn f_is_conj(&self) -> Result<bool, TchError>

pub fn f_is_distributed(&self) -> Result<bool, TchError>

pub fn f_is_floating_point(&self) -> Result<bool, TchError>

pub fn f_is_inference(&self) -> Result<bool, TchError>

pub fn f_is_leaf(&self) -> Result<bool, TchError>

pub fn f_is_neg(&self) -> Result<bool, TchError>

pub fn f_is_nonzero(&self) -> Result<bool, TchError>

pub fn f_is_pinned(&self, device: Device) -> Result<bool, TchError>

pub fn f_is_same_size(&self, other: &Tensor) -> Result<bool, TchError>

pub fn f_is_set_to(&self, tensor: &Tensor) -> Result<bool, TchError>

pub fn f_is_signed(&self) -> Result<bool, TchError>

pub fn f_is_vulkan_available() -> Result<bool, TchError>

pub fn f_isclose( &self, other: &Tensor, rtol: f64, atol: f64, equal_nan: bool ) -> Result<Tensor, TchError>

pub fn f_isfinite(&self) -> Result<Tensor, TchError>

pub fn f_isin( elements: &Tensor, test_elements: &Tensor, assume_unique: bool, invert: bool ) -> Result<Tensor, TchError>

pub fn f_isin_scalar_tensor<S: Into<Scalar>>( element: S, test_elements: &Tensor, assume_unique: bool, invert: bool ) -> Result<Tensor, TchError>

pub fn f_isin_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, element: S, test_elements: &Tensor, assume_unique: bool, invert: bool ) -> Result<Tensor, TchError>

pub fn f_isin_tensor_scalar<S: Into<Scalar>>( elements: &Tensor, test_element: S, assume_unique: bool, invert: bool ) -> Result<Tensor, TchError>

pub fn f_isin_tensor_scalar_out<S: Into<Scalar>>( out: &Tensor, elements: &Tensor, test_element: S, assume_unique: bool, invert: bool ) -> Result<Tensor, TchError>

pub fn f_isin_tensor_tensor_out( out: &Tensor, elements: &Tensor, test_elements: &Tensor, assume_unique: bool, invert: bool ) -> Result<Tensor, TchError>

pub fn f_isinf(&self) -> Result<Tensor, TchError>

pub fn f_isinf_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_isnan(&self) -> Result<Tensor, TchError>

pub fn f_isnan_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_isneginf(&self) -> Result<Tensor, TchError>

pub fn f_isneginf_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_isposinf(&self) -> Result<Tensor, TchError>

pub fn f_isposinf_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_isreal(&self) -> Result<Tensor, TchError>

pub fn f_istft<T: Borrow<Tensor>>( &self, n_fft: i64, hop_length: impl Into<Option<i64>>, win_length: impl Into<Option<i64>>, window: Option<T>, center: bool, normalized: bool, onesided: bool, length: impl Into<Option<i64>>, return_complex: bool ) -> Result<Tensor, TchError>

pub fn f_kaiser_window( window_length: i64, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_kaiser_window_beta( window_length: i64, periodic: bool, beta: f64, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_kaiser_window_beta_out( out: &Tensor, window_length: i64, periodic: bool, beta: f64 ) -> Result<Tensor, TchError>

pub fn f_kaiser_window_out( out: &Tensor, window_length: i64 ) -> Result<Tensor, TchError>

pub fn f_kaiser_window_periodic( window_length: i64, periodic: bool, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_kaiser_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> Result<Tensor, TchError>

pub fn f_kl_div( &self, target: &Tensor, reduction: Reduction, log_target: bool ) -> Result<Tensor, TchError>

pub fn f_kron(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_kron_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_kthvalue( &self, k: i64, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_kthvalue_values( &self, values: &Tensor, indices: &Tensor, k: i64, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_l1_loss( &self, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_layer_norm<T: Borrow<Tensor>>( &self, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64, cudnn_enable: bool ) -> Result<Tensor, TchError>

pub fn f_lcm(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_lcm_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_lcm_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_ldexp(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ldexp_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ldexp_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_le<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_le_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_le_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_le_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_le_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_le_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_leaky_relu(&self) -> Result<Tensor, TchError>

pub fn f_leaky_relu_(&mut self) -> Result<Tensor, TchError>

pub fn f_leaky_relu_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, negative_slope: S, self_is_result: bool ) -> Result<Tensor, TchError>

pub fn f_leaky_relu_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, negative_slope: S, self_is_result: bool ) -> Result<Tensor, TchError>

pub fn f_leaky_relu_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_lerp<S: Into<Scalar>>( &self, end: &Tensor, weight: S ) -> Result<Tensor, TchError>

pub fn f_lerp_<S: Into<Scalar>>( &mut self, end: &Tensor, weight: S ) -> Result<Tensor, TchError>

pub fn f_lerp_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, end: &Tensor, weight: S ) -> Result<Tensor, TchError>

pub fn f_lerp_tensor( &self, end: &Tensor, weight: &Tensor ) -> Result<Tensor, TchError>

pub fn f_lerp_tensor_( &mut self, end: &Tensor, weight: &Tensor ) -> Result<Tensor, TchError>

pub fn f_lerp_tensor_out( &self, out: &Tensor, end: &Tensor, weight: &Tensor ) -> Result<Tensor, TchError>

pub fn f_less<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_less_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_less_equal<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_less_equal_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

pub fn f_less_equal_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_less_equal_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_less_equal_tensor_( &mut self, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_less_equal_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_less_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_less_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_less_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_less_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_lgamma(&self) -> Result<Tensor, TchError>

pub fn f_lgamma_(&mut self) -> Result<Tensor, TchError>

pub fn f_lgamma_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_lift(&self) -> Result<Tensor, TchError>

pub fn f_lift_fresh(&self) -> Result<Tensor, TchError>

pub fn f_lift_fresh_copy(&self) -> Result<Tensor, TchError>

pub fn f_lift_fresh_copy_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_lift_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_cholesky(&self, upper: bool) -> Result<Tensor, TchError>

pub fn f_linalg_cholesky_ex( &self, upper: bool, check_errors: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_cholesky_ex_l( &self, l: &Tensor, info: &Tensor, upper: bool, check_errors: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_cholesky_out( &self, out: &Tensor, upper: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_cond<S: Into<Scalar>>(&self, p: S) -> Result<Tensor, TchError>

pub fn f_linalg_cond_out<S: Into<Scalar>>( &self, out: &Tensor, p: S ) -> Result<Tensor, TchError>

pub fn f_linalg_cond_p_str(&self, p: &str) -> Result<Tensor, TchError>

pub fn f_linalg_cond_p_str_out( &self, out: &Tensor, p: &str ) -> Result<Tensor, TchError>

pub fn f_linalg_cross( &self, other: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_linalg_cross_out( &self, out: &Tensor, other: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_linalg_det(a: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_det_out(out: &Tensor, a: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_diagonal( a: &Tensor, offset: i64, dim1: i64, dim2: i64 ) -> Result<Tensor, TchError>

pub fn f_linalg_eig(&self) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_eig_out( &self, eigenvalues: &Tensor, eigenvectors: &Tensor ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_eigh(&self, uplo: &str) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_eigh_eigvals( &self, eigvals: &Tensor, eigvecs: &Tensor, uplo: &str ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_eigvals(&self) -> Result<Tensor, TchError>

pub fn f_linalg_eigvals_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_eigvalsh(&self, uplo: &str) -> Result<Tensor, TchError>

pub fn f_linalg_eigvalsh_out( &self, out: &Tensor, uplo: &str ) -> Result<Tensor, TchError>

pub fn f_linalg_householder_product( &self, tau: &Tensor ) -> Result<Tensor, TchError>

pub fn f_linalg_householder_product_out( &self, out: &Tensor, tau: &Tensor ) -> Result<Tensor, TchError>

pub fn f_linalg_inv(a: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_inv_ex( a: &Tensor, check_errors: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_inv_ex_inverse( inverse: &Tensor, info: &Tensor, a: &Tensor, check_errors: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_inv_out(out: &Tensor, a: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_ldl_factor( &self, hermitian: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_ldl_factor_ex( &self, hermitian: bool, check_errors: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_ldl_factor_ex_out( &self, ld: &Tensor, pivots: &Tensor, info: &Tensor, hermitian: bool, check_errors: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_ldl_factor_out( &self, ld: &Tensor, pivots: &Tensor, hermitian: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_ldl_solve( ld: &Tensor, pivots: &Tensor, b: &Tensor, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_ldl_solve_out( out: &Tensor, ld: &Tensor, pivots: &Tensor, b: &Tensor, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_lstsq( &self, b: &Tensor, rcond: impl Into<Option<f64>>, driver: &str ) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_lstsq_out( &self, solution: &Tensor, residuals: &Tensor, rank: &Tensor, singular_values: &Tensor, b: &Tensor, rcond: impl Into<Option<f64>>, driver: &str ) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_lu( a: &Tensor, pivot: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_lu_factor( a: &Tensor, pivot: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_lu_factor_ex( a: &Tensor, pivot: bool, check_errors: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_lu_factor_ex_out( lu: &Tensor, pivots: &Tensor, info: &Tensor, a: &Tensor, pivot: bool, check_errors: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_lu_factor_out( lu: &Tensor, pivots: &Tensor, a: &Tensor, pivot: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_lu_out( p: &Tensor, l: &Tensor, u: &Tensor, a: &Tensor, pivot: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_lu_solve( lu: &Tensor, pivots: &Tensor, b: &Tensor, left: bool, adjoint: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_lu_solve_out( out: &Tensor, lu: &Tensor, pivots: &Tensor, b: &Tensor, left: bool, adjoint: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_matmul(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_matmul_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_exp(&self) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_exp_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_power(&self, n: i64) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_power_out( &self, out: &Tensor, n: i64 ) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank( &self, tol: f64, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_atol_rtol_float( &self, atol: impl Into<Option<f64>>, rtol: impl Into<Option<f64>>, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_atol_rtol_float_out( &self, out: &Tensor, atol: impl Into<Option<f64>>, rtol: impl Into<Option<f64>>, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_atol_rtol_tensor<T: Borrow<Tensor>>( &self, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_atol_rtol_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_out( &self, out: &Tensor, tol: f64, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_out_tol_tensor( &self, out: &Tensor, tol: &Tensor, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_matrix_rank_tol_tensor( &self, tol: &Tensor, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_multi_dot<T: Borrow<Tensor>>( tensors: &[T] ) -> Result<Tensor, TchError>

pub fn f_linalg_multi_dot_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T] ) -> Result<Tensor, TchError>

pub fn f_linalg_norm<S: Into<Scalar>>( &self, ord: S, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_linalg_norm_ord_str( &self, ord: &str, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_linalg_norm_ord_str_out( &self, out: &Tensor, ord: &str, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_linalg_norm_out<S: Into<Scalar>>( &self, out: &Tensor, ord: S, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_linalg_pinv( &self, rcond: f64, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_atol_rtol_float( &self, atol: impl Into<Option<f64>>, rtol: impl Into<Option<f64>>, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_atol_rtol_float_out( &self, out: &Tensor, atol: impl Into<Option<f64>>, rtol: impl Into<Option<f64>>, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_atol_rtol_tensor<T: Borrow<Tensor>>( &self, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_atol_rtol_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_out( &self, out: &Tensor, rcond: f64, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_out_rcond_tensor( &self, out: &Tensor, rcond: &Tensor, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_pinv_rcond_tensor( &self, rcond: &Tensor, hermitian: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_qr(a: &Tensor, mode: &str) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_qr_out( q: &Tensor, r: &Tensor, a: &Tensor, mode: &str ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_slogdet(a: &Tensor) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_slogdet_out( sign: &Tensor, logabsdet: &Tensor, a: &Tensor ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_solve( a: &Tensor, b: &Tensor, left: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_solve_ex( a: &Tensor, b: &Tensor, left: bool, check_errors: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_solve_ex_out( result: &Tensor, info: &Tensor, a: &Tensor, b: &Tensor, left: bool, check_errors: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_linalg_solve_out( out: &Tensor, a: &Tensor, b: &Tensor, left: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_solve_triangular( &self, b: &Tensor, upper: bool, left: bool, unitriangular: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_solve_triangular_out( &self, out: &Tensor, b: &Tensor, upper: bool, left: bool, unitriangular: bool ) -> Result<Tensor, TchError>

pub fn f_linalg_svd( a: &Tensor, full_matrices: bool, driver: &str ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_svd_u( u: &Tensor, s: &Tensor, vh: &Tensor, a: &Tensor, full_matrices: bool, driver: &str ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_linalg_svdvals(a: &Tensor, driver: &str) -> Result<Tensor, TchError>

pub fn f_linalg_svdvals_out( out: &Tensor, a: &Tensor, driver: &str ) -> Result<Tensor, TchError>

pub fn f_linalg_tensorinv(&self, ind: i64) -> Result<Tensor, TchError>

pub fn f_linalg_tensorinv_out( &self, out: &Tensor, ind: i64 ) -> Result<Tensor, TchError>

pub fn f_linalg_tensorsolve( &self, other: &Tensor, dims: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_linalg_tensorsolve_out( &self, out: &Tensor, other: &Tensor, dims: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_linalg_vander( x: &Tensor, n: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_linalg_vecdot( x: &Tensor, y: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_linalg_vecdot_out( out: &Tensor, x: &Tensor, y: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_linear<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T> ) -> Result<Tensor, TchError>

pub fn f_linear_out<T: Borrow<Tensor>>( &self, out: &Tensor, 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(&self, mean: f64, std: f64) -> Result<Tensor, TchError>

pub fn f_log_normal_(&mut self, mean: f64, std: f64) -> Result<Tensor, TchError>

pub fn f_log_normal_out( &self, out: &Tensor, mean: f64, std: f64 ) -> Result<Tensor, TchError>

pub fn f_log_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_log_sigmoid(&self) -> Result<Tensor, TchError>

pub fn f_log_sigmoid_backward( &self, grad_output: &Tensor, buffer: &Tensor ) -> Result<Tensor, TchError>

pub fn f_log_sigmoid_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, buffer: &Tensor ) -> Result<Tensor, TchError>

pub fn f_log_sigmoid_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_log_softmax( &self, dim: i64, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_log_softmax_int_out( &self, out: &Tensor, dim: i64, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_logaddexp(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logaddexp2(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logaddexp2_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_logaddexp_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_logcumsumexp(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_logcumsumexp_out( &self, out: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_logdet(&self) -> Result<Tensor, TchError>

pub fn f_logical_and(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_and_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_and_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_logical_not(&self) -> Result<Tensor, TchError>

pub fn f_logical_not_(&mut self) -> Result<Tensor, TchError>

pub fn f_logical_not_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_or(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_or_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_or_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_logical_xor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_xor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_logical_xor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_logit(&self, eps: impl Into<Option<f64>>) -> Result<Tensor, TchError>

pub fn f_logit_( &mut self, eps: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_logit_backward( &self, grad_output: &Tensor, eps: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_logit_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, eps: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_logit_out( &self, out: &Tensor, eps: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_logspace<S: Into<Scalar>>( start: S, end: S, steps: 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: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_logsumexp_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_lstm<T: Borrow<Tensor>>( &self, hx: &[T], params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_lstm_cell<T: Borrow<Tensor>>( &self, hx: &[T], w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Result<(Tensor, Tensor), TchError>

pub fn f_lstm_data<T: Borrow<Tensor>>( data: &Tensor, batch_sizes: &Tensor, hx: &[T], params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_lstm_mps_backward<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &[T], out2: &[T], grad_y: Option<T>, grad_hy: Option<T>, grad_cy: Option<T>, z_state: &Tensor, cell_state_fwd: &Tensor, layersoutputs: &Tensor, hx: &[T], params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> Result<(), TchError>

pub fn f_lt<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_lt_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_lt_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_lt_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_lt_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_lt_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_lu_solve( &self, lu_data: &Tensor, lu_pivots: &Tensor ) -> Result<Tensor, TchError>

pub fn f_lu_solve_out( &self, out: &Tensor, lu_data: &Tensor, lu_pivots: &Tensor ) -> Result<Tensor, TchError>

pub fn f_lu_unpack( lu_data: &Tensor, lu_pivots: &Tensor, unpack_data: bool, unpack_pivots: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_lu_unpack_out( p: &Tensor, l: &Tensor, u: &Tensor, lu_data: &Tensor, lu_pivots: &Tensor, unpack_data: bool, unpack_pivots: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_margin_ranking_loss( input1: &Tensor, input2: &Tensor, target: &Tensor, margin: f64, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_masked_fill<S: Into<Scalar>>( &self, mask: &Tensor, value: S ) -> Result<Tensor, TchError>

pub fn f_masked_fill_<S: Into<Scalar>>( &mut self, mask: &Tensor, value: S ) -> Result<Tensor, TchError>

pub fn f_masked_fill_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, mask: &Tensor, value: S ) -> Result<Tensor, TchError>

pub fn f_masked_fill_tensor( &self, mask: &Tensor, value: &Tensor ) -> Result<Tensor, TchError>

pub fn f_masked_fill_tensor_( &mut self, mask: &Tensor, value: &Tensor ) -> Result<Tensor, TchError>

pub fn f_masked_fill_tensor_out( &self, out: &Tensor, 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_scatter_out( &self, out: &Tensor, mask: &Tensor, source: &Tensor ) -> Result<Tensor, TchError>

pub fn f_masked_select(&self, mask: &Tensor) -> Result<Tensor, TchError>

pub fn f_masked_select_backward( &self, grad: &Tensor, mask: &Tensor ) -> Result<Tensor, TchError>

pub fn f_masked_select_out( &self, out: &Tensor, mask: &Tensor ) -> Result<Tensor, TchError>

pub fn f_matmul(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_matmul_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_matrix_exp(&self) -> Result<Tensor, TchError>

pub fn f_matrix_exp_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>

pub fn f_matrix_h(&self) -> Result<Tensor, TchError>

pub fn f_matrix_power(&self, n: i64) -> Result<Tensor, TchError>

pub fn f_matrix_power_out( &self, out: &Tensor, n: i64 ) -> Result<Tensor, TchError>

pub fn f_max(&self) -> Result<Tensor, TchError>

pub fn f_max_dim( &self, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_dim_max( &self, max: &Tensor, max_values: &Tensor, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_other(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_max_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_max_pool1d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_max_pool1d_with_indices( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_pool2d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_max_pool2d_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_max_pool2d_backward_out( &self, out: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_max_pool2d_with_indices( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_pool2d_with_indices_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool, indices: &Tensor ) -> Result<Tensor, TchError>

pub fn f_max_pool2d_with_indices_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool, indices: &Tensor ) -> Result<Tensor, TchError>

pub fn f_max_pool2d_with_indices_out( &self, out: &Tensor, indices: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_pool3d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_max_pool3d_with_indices( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_pool3d_with_indices_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool, indices: &Tensor ) -> Result<Tensor, TchError>

pub fn f_max_pool3d_with_indices_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool, indices: &Tensor ) -> Result<Tensor, TchError>

pub fn f_max_pool3d_with_indices_out( &self, out: &Tensor, indices: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_max_unary_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_max_unpool2d( &self, indices: &Tensor, output_size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_max_unpool2d_out( &self, out: &Tensor, indices: &Tensor, output_size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_max_unpool3d( &self, indices: &Tensor, output_size: impl IntList, stride: impl IntList, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_max_unpool3d_out( &self, out: &Tensor, indices: &Tensor, output_size: impl IntList, stride: impl IntList, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_maximum(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_maximum_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_mean(&self, dtype: impl Into<Option<Kind>>) -> Result<Tensor, TchError>

pub fn f_mean_dim( &self, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_mean_out( &self, out: &Tensor, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_median(&self) -> Result<Tensor, TchError>

pub fn f_median_dim( &self, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_median_dim_values( &self, values: &Tensor, indices: &Tensor, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_median_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_meshgrid<T: Borrow<Tensor>>( tensors: &[T] ) -> Result<Vec<Tensor>, TchError>

pub fn f_meshgrid_indexing<T: Borrow<Tensor>>( tensors: &[T], indexing: &str ) -> Result<Vec<Tensor>, TchError>

pub fn f_mh(&self) -> Result<Tensor, TchError>

pub fn f_min(&self) -> Result<Tensor, TchError>

pub fn f_min_dim( &self, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_min_dim_min( &self, min: &Tensor, min_indices: &Tensor, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_min_other(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_min_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_min_unary_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_minimum(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_minimum_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_miopen_batch_norm<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, running_mean: Option<T>, running_var: Option<T>, training: bool, exponential_average_factor: f64, epsilon: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_miopen_batch_norm_backward<T: Borrow<Tensor>>( &self, grad_output: &Tensor, weight: &Tensor, running_mean: Option<T>, running_var: Option<T>, save_mean: Option<T>, save_var: Option<T>, epsilon: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_miopen_batch_norm_backward_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, 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_batch_norm_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, 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_convolution<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_add_relu<T: Borrow<Tensor>, S: Into<Scalar>>( &self, weight: &Tensor, z: &Tensor, alpha: S, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_relu<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_transpose<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Result<Tensor, TchError>

pub fn f_miopen_convolution_transpose_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, 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: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Result<Tensor, TchError>

pub fn f_miopen_depthwise_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, 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: impl IntList, dropout_state: Option<T> ) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_miopen_rnn_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, out4: &Tensor, 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: impl IntList, dropout_state: Option<T> ) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_mish(&self) -> Result<Tensor, TchError>

pub fn f_mish_(&mut self) -> Result<Tensor, TchError>

pub fn f_mish_backward(&self, grad_output: &Tensor) -> Result<Tensor, TchError>

pub fn f_mish_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_mkldnn_adaptive_avg_pool2d( &self, output_size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_mkldnn_adaptive_avg_pool2d_backward( &self, grad_output: &Tensor ) -> Result<Tensor, TchError>

pub fn f_mkldnn_adaptive_avg_pool2d_backward_out( &self, out: &Tensor, grad_output: &Tensor ) -> Result<Tensor, TchError>

pub fn f_mkldnn_adaptive_avg_pool2d_out( &self, out: &Tensor, output_size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_mkldnn_convolution<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

pub fn f_mkldnn_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

pub fn f_mkldnn_linear<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T> ) -> Result<Tensor, TchError>

pub fn f_mkldnn_linear_backward_input( input_size: impl IntList, grad_output: &Tensor, weight: &Tensor ) -> Result<Tensor, TchError>

pub fn f_mkldnn_linear_backward_input_out( out: &Tensor, input_size: impl IntList, grad_output: &Tensor, weight: &Tensor ) -> Result<Tensor, TchError>

pub fn f_mkldnn_linear_backward_weights( &self, grad_output: &Tensor, weight: &Tensor, bias_defined: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_mkldnn_linear_backward_weights_out( &self, out0: &Tensor, out1: &Tensor, grad_output: &Tensor, weight: &Tensor, bias_defined: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_mkldnn_linear_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T> ) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool2d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool2d_backward( &self, grad_output: &Tensor, output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool2d_backward_out( &self, out: &Tensor, grad_output: &Tensor, output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool2d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool3d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool3d_backward( &self, grad_output: &Tensor, output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool3d_backward_out( &self, out: &Tensor, grad_output: &Tensor, output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_mkldnn_max_pool3d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_mkldnn_reorder_conv2d_weight( &self, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, input_size: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_mkldnn_reorder_conv2d_weight_out( &self, out: &Tensor, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, input_size: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_mkldnn_reorder_conv3d_weight( &self, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

pub fn f_mkldnn_reorder_conv3d_weight_out( &self, out: &Tensor, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>

pub fn f_mkldnn_rnn_layer( &self, weight0: &Tensor, weight1: &Tensor, weight2: &Tensor, weight3: &Tensor, hx_: &Tensor, cx_: &Tensor, reverse: bool, batch_sizes: impl IntList, mode: i64, hidden_size: i64, num_layers: i64, has_biases: bool, bidirectional: bool, batch_first: bool, train: bool ) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_mkldnn_rnn_layer_backward<T: Borrow<Tensor>>( &self, weight1: &Tensor, weight2: &Tensor, weight3: &Tensor, weight4: &Tensor, hx_: &Tensor, cx_tmp: &Tensor, output: &Tensor, hy_: &Tensor, cy_: &Tensor, grad_output: Option<T>, grad_hy: Option<T>, grad_cy: Option<T>, reverse: bool, mode: i64, hidden_size: i64, num_layers: i64, has_biases: bool, train: bool, bidirectional: bool, batch_sizes: impl IntList, batch_first: bool, workspace: &Tensor ) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_mkldnn_rnn_layer_backward_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, out4: &Tensor, out5: &Tensor, out6: &Tensor, weight1: &Tensor, weight2: &Tensor, weight3: &Tensor, weight4: &Tensor, hx_: &Tensor, cx_tmp: &Tensor, output: &Tensor, hy_: &Tensor, cy_: &Tensor, grad_output: Option<T>, grad_hy: Option<T>, grad_cy: Option<T>, reverse: bool, mode: i64, hidden_size: i64, num_layers: i64, has_biases: bool, train: bool, bidirectional: bool, batch_sizes: impl IntList, batch_first: bool, workspace: &Tensor ) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_mkldnn_rnn_layer_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, weight0: &Tensor, weight1: &Tensor, weight2: &Tensor, weight3: &Tensor, hx_: &Tensor, cx_: &Tensor, reverse: bool, batch_sizes: impl IntList, mode: i64, hidden_size: i64, num_layers: i64, has_biases: bool, bidirectional: bool, batch_first: bool, train: bool ) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>

pub fn f_mm(&self, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_mm_out(&self, out: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_mode( &self, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_mode_values( &self, values: &Tensor, indices: &Tensor, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_moveaxis( &self, source: impl IntList, destination: impl IntList ) -> Result<Tensor, TchError>

pub fn f_moveaxis_int( &self, source: i64, destination: i64 ) -> Result<Tensor, TchError>

pub fn f_movedim( &self, source: impl IntList, destination: impl IntList ) -> Result<Tensor, TchError>

pub fn f_movedim_int( &self, source: i64, destination: i64 ) -> Result<Tensor, TchError>

pub fn f_mse_loss( &self, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_mse_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_mse_loss_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_mse_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_msort(&self) -> Result<Tensor, TchError>

pub fn f_msort_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_mt(&self) -> Result<Tensor, TchError>

pub fn f_mul(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_mul_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_mul_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_mul_scalar<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_mul_scalar_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

pub fn f_mul_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_multi_margin_loss_backward<T: Borrow<Tensor>, S: Into<Scalar>>( &self, grad_output: &Tensor, target: &Tensor, p: S, margin: S, weight: Option<T>, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_multi_margin_loss_backward_grad_input<T: Borrow<Tensor>, S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, p: S, margin: S, weight: Option<T>, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_multilabel_margin_loss( &self, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_multilabel_margin_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction, is_target: &Tensor ) -> Result<Tensor, TchError>

pub fn f_multilabel_margin_loss_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction, is_target: &Tensor ) -> Result<Tensor, TchError>

pub fn f_multilabel_margin_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_multinomial( &self, num_samples: i64, replacement: bool ) -> Result<Tensor, TchError>

pub fn f_multinomial_out( &self, out: &Tensor, num_samples: i64, replacement: bool ) -> Result<Tensor, TchError>

pub fn f_multiply(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_multiply_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_multiply_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_multiply_scalar<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_multiply_scalar_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

pub fn f_mv(&self, vec: &Tensor) -> Result<Tensor, TchError>

pub fn f_mv_out(&self, out: &Tensor, vec: &Tensor) -> Result<Tensor, TchError>

pub fn f_mvlgamma(&self, p: i64) -> Result<Tensor, TchError>

pub fn f_mvlgamma_(&mut self, p: i64) -> Result<Tensor, TchError>

pub fn f_mvlgamma_out(&self, out: &Tensor, p: i64) -> Result<Tensor, TchError>

pub fn f_nan_to_num( &self, nan: impl Into<Option<f64>>, posinf: impl Into<Option<f64>>, neginf: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_nan_to_num_( &mut self, nan: impl Into<Option<f64>>, posinf: impl Into<Option<f64>>, neginf: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_nan_to_num_out( &self, out: &Tensor, nan: impl Into<Option<f64>>, posinf: impl Into<Option<f64>>, neginf: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_nanmean( &self, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_nanmean_out( &self, out: &Tensor, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_nanmedian(&self) -> Result<Tensor, TchError>

pub fn f_nanmedian_dim( &self, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_nanmedian_dim_values( &self, values: &Tensor, indices: &Tensor, dim: i64, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_nanmedian_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_nanquantile( &self, q: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Result<Tensor, TchError>

pub fn f_nanquantile_out( &self, out: &Tensor, q: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Result<Tensor, TchError>

pub fn f_nanquantile_scalar( &self, q: f64, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Result<Tensor, TchError>

pub fn f_nanquantile_scalar_out( &self, out: &Tensor, q: f64, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Result<Tensor, TchError>

pub fn f_nansum( &self, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_nansum_out( &self, out: &Tensor, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_narrow( &self, dim: i64, start: i64, length: i64 ) -> Result<Tensor, TchError>

pub fn f_narrow_copy( &self, dim: i64, start: i64, length: i64 ) -> Result<Tensor, TchError>

pub fn f_narrow_copy_out( &self, out: &Tensor, dim: i64, start: i64, length: i64 ) -> Result<Tensor, TchError>

pub fn f_narrow_tensor( &self, dim: i64, start: &Tensor, length: i64 ) -> Result<Tensor, TchError>

pub fn f_native_batch_norm<T: Borrow<Tensor>>( &self, weight: Option<T>, bias: Option<T>, running_mean: Option<T>, running_var: Option<T>, training: bool, momentum: f64, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_native_batch_norm_out<T: Borrow<Tensor>>( &self, out: &Tensor, save_mean: &Tensor, save_invstd: &Tensor, weight: Option<T>, bias: Option<T>, running_mean: Option<T>, running_var: Option<T>, training: bool, momentum: f64, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_native_channel_shuffle(&self, groups: i64) -> Result<Tensor, TchError>

pub fn f_native_dropout( &self, p: f64, train: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_native_dropout_backward( grad_output: &Tensor, mask: &Tensor, scale: f64 ) -> Result<Tensor, TchError>

pub fn f_native_dropout_backward_out( out: &Tensor, grad_output: &Tensor, mask: &Tensor, scale: f64 ) -> Result<Tensor, TchError>

pub fn f_native_dropout_out( &self, out0: &Tensor, out1: &Tensor, p: f64, train: bool ) -> Result<(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_group_norm_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, weight: Option<T>, bias: Option<T>, n: i64, c: i64, hxw: i64, group: i64, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_native_layer_norm<T: Borrow<Tensor>>( &self, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_native_layer_norm_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_native_norm(&self) -> Result<Tensor, TchError>

pub fn f_native_norm_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_native_norm_scalaropt_dim_dtype<S: Into<Scalar>>( &self, p: S, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_native_norm_scalaropt_dim_dtype_out<S: Into<Scalar>>( &self, out: &Tensor, p: S, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_ne<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_ne_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>

pub fn f_ne_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_ne_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ne_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_ne_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_neg(&self) -> Result<Tensor, TchError>

pub fn f_neg_(&mut self) -> Result<Tensor, TchError>

pub fn f_neg_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_negative(&self) -> Result<Tensor, TchError>

pub fn f_negative_(&mut self) -> Result<Tensor, TchError>

pub fn f_negative_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_nested_to_padded_tensor( &self, padding: f64, output_size: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_new_empty( &self, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_new_empty_out( &self, out: &Tensor, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_new_empty_strided( &self, size: impl IntList, stride: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_new_empty_strided_out( &self, out: &Tensor, size: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>

pub fn f_new_full<S: Into<Scalar>>( &self, size: impl IntList, fill_value: S, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_new_full_out<S: Into<Scalar>>( &self, out: &Tensor, size: impl IntList, fill_value: S ) -> Result<Tensor, TchError>

pub fn f_new_ones( &self, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_new_ones_out( &self, out: &Tensor, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_new_zeros( &self, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_new_zeros_out( &self, out: &Tensor, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_nextafter(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_nextafter_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_nextafter_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_nll_loss<T: Borrow<Tensor>>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Result<Tensor, TchError>

pub fn f_nll_loss2d<T: Borrow<Tensor>>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Result<Tensor, TchError>

pub fn f_nll_loss2d_backward<T: Borrow<Tensor>>( &self, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Result<Tensor, TchError>

pub fn f_nll_loss2d_backward_grad_input<T: Borrow<Tensor>>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Result<Tensor, TchError>

pub fn f_nll_loss2d_out<T: Borrow<Tensor>>( &self, out: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Result<Tensor, TchError>

pub fn f_nll_loss_backward<T: Borrow<Tensor>>( &self, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Result<Tensor, TchError>

pub fn f_nll_loss_backward_grad_input<T: Borrow<Tensor>>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Result<Tensor, TchError>

pub fn f_nll_loss_nd<T: Borrow<Tensor>>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Result<Tensor, TchError>

pub fn f_nll_loss_out<T: Borrow<Tensor>>( &self, out: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Result<Tensor, TchError>

pub fn f_nonzero(&self) -> Result<Tensor, TchError>

pub fn f_nonzero_numpy(&self) -> Result<Vec<Tensor>, TchError>

pub fn f_nonzero_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_nonzero_static( &self, size: i64, fill_value: i64 ) -> Result<Tensor, TchError>

pub fn f_nonzero_static_out( &self, out: &Tensor, size: i64, fill_value: i64 ) -> Result<Tensor, TchError>

pub fn f_norm(&self) -> Result<Tensor, TchError>

pub fn f_norm_dtype_out<S: Into<Scalar>>( &self, out: &Tensor, p: S, dim: impl IntList, 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: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_norm_scalar_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_norm_scalaropt_dim<S: Into<Scalar>>( &self, p: S, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_norm_scalaropt_dim_dtype<S: Into<Scalar>>( &self, p: S, dim: impl IntList, keepdim: bool, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_norm_scalaropt_dtype<S: Into<Scalar>>( &self, p: S, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_norm_scalaropt_dtype_out<S: Into<Scalar>>( &self, out: &Tensor, p: S, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_normal_(&mut self, mean: f64, std: f64) -> Result<Tensor, TchError>

pub fn f_normal_functional( &self, mean: f64, std: f64 ) -> Result<Tensor, TchError>

pub fn f_not_equal<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_not_equal_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

pub fn f_not_equal_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_not_equal_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_not_equal_tensor_( &mut self, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_not_equal_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_nuclear_norm(&self, keepdim: bool) -> Result<Tensor, TchError>

pub fn f_nuclear_norm_dim( &self, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_nuclear_norm_dim_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_nuclear_norm_out( &self, out: &Tensor, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_numpy_t(&self) -> Result<Tensor, TchError>

pub fn f_one_hot(&self, num_classes: i64) -> Result<Tensor, TchError>

pub fn f_ones( size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_ones_like(&self) -> Result<Tensor, TchError>

pub fn f_ones_like_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_ones_out(out: &Tensor, size: impl IntList) -> Result<Tensor, TchError>

pub fn f_orgqr(&self, input2: &Tensor) -> Result<Tensor, TchError>

pub fn f_orgqr_out( &self, out: &Tensor, input2: &Tensor ) -> Result<Tensor, TchError>

pub fn f_ormqr( &self, input2: &Tensor, input3: &Tensor, left: bool, transpose: bool ) -> Result<Tensor, TchError>

pub fn f_ormqr_out( &self, out: &Tensor, input2: &Tensor, input3: &Tensor, left: bool, transpose: bool ) -> Result<Tensor, TchError>

pub fn f_outer(&self, vec2: &Tensor) -> Result<Tensor, TchError>

pub fn f_outer_out( &self, out: &Tensor, vec2: &Tensor ) -> Result<Tensor, TchError>

pub fn f_output_nr(&self) -> Result<i64, TchError>

pub fn f_pad( &self, pad: impl IntList, mode: &str, value: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_pad_sequence<T: Borrow<Tensor>>( sequences: &[T], batch_first: bool, padding_value: f64 ) -> Result<Tensor, TchError>

pub fn f_pairwise_distance( x1: &Tensor, x2: &Tensor, p: f64, eps: f64, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_pdist(&self, p: f64) -> Result<Tensor, TchError>

pub fn f_permute(&self, dims: impl IntList) -> Result<Tensor, TchError>

pub fn f_permute_copy(&self, dims: impl IntList) -> Result<Tensor, TchError>

pub fn f_permute_copy_out( &self, out: &Tensor, dims: impl IntList ) -> Result<Tensor, TchError>

pub fn f_pin_memory(&self, device: Device) -> Result<Tensor, TchError>

pub fn f_pinverse(&self, rcond: f64) -> Result<Tensor, TchError>

pub fn f_pixel_shuffle(&self, upscale_factor: i64) -> Result<Tensor, TchError>

pub fn f_pixel_shuffle_out( &self, out: &Tensor, upscale_factor: i64 ) -> Result<Tensor, TchError>

pub fn f_pixel_unshuffle( &self, downscale_factor: i64 ) -> Result<Tensor, TchError>

pub fn f_pixel_unshuffle_out( &self, out: &Tensor, downscale_factor: i64 ) -> Result<Tensor, TchError>

pub fn f_poisson(&self) -> Result<Tensor, TchError>

pub fn f_poisson_nll_loss( &self, target: &Tensor, log_input: bool, full: bool, eps: f64, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_poisson_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_polar(abs: &Tensor, angle: &Tensor) -> Result<Tensor, TchError>

pub fn f_polar_out( out: &Tensor, abs: &Tensor, angle: &Tensor ) -> Result<Tensor, TchError>

pub fn f_polygamma(&self, n: i64) -> Result<Tensor, TchError>

pub fn f_polygamma_(&mut self, n: i64) -> Result<Tensor, TchError>

pub fn f_polygamma_out(&self, out: &Tensor, n: i64) -> Result<Tensor, TchError>

pub fn f_positive(&self) -> Result<Tensor, TchError>

pub fn f_pow(&self, exponent: &Tensor) -> Result<Tensor, TchError>

pub fn f_pow_<S: Into<Scalar>>( &mut self, exponent: S ) -> Result<Tensor, TchError>

pub fn f_pow_scalar<S: Into<Scalar>>( self_scalar: S, exponent: &Tensor ) -> Result<Tensor, TchError>

pub fn f_pow_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, exponent: &Tensor ) -> Result<Tensor, TchError>

pub fn f_pow_tensor_(&mut self, exponent: &Tensor) -> Result<Tensor, TchError>

pub fn f_pow_tensor_scalar<S: Into<Scalar>>( &self, exponent: S ) -> Result<Tensor, TchError>

pub fn f_pow_tensor_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, exponent: S ) -> Result<Tensor, TchError>

pub fn f_pow_tensor_tensor_out( &self, out: &Tensor, exponent: &Tensor ) -> Result<Tensor, TchError>

pub fn f_prelu(&self, weight: &Tensor) -> Result<Tensor, TchError>

pub fn f_prod(&self, dtype: impl Into<Option<Kind>>) -> Result<Tensor, TchError>

pub fn f_prod_dim_int( &self, dim: i64, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_prod_int_out( &self, out: &Tensor, dim: i64, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_prod_out( &self, out: &Tensor, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_put( &self, index: &Tensor, source: &Tensor, accumulate: bool ) -> Result<Tensor, TchError>

pub fn f_put_( &mut self, index: &Tensor, source: &Tensor, accumulate: bool ) -> Result<Tensor, TchError>

pub fn f_put_out( &self, out: &Tensor, index: &Tensor, source: &Tensor, accumulate: bool ) -> Result<Tensor, TchError>

pub fn f_q_per_channel_axis(&self) -> Result<i64, TchError>

pub fn f_q_per_channel_scales(&self) -> Result<Tensor, TchError>

pub fn f_q_per_channel_scales_out( &self, out: &Tensor ) -> Result<Tensor, TchError>

pub fn f_q_per_channel_zero_points(&self) -> Result<Tensor, TchError>

pub fn f_q_per_channel_zero_points_out( &self, out: &Tensor ) -> Result<Tensor, TchError>

pub fn f_q_scale(&self) -> Result<f64, TchError>

pub fn f_q_zero_point(&self) -> Result<i64, TchError>

pub fn f_qr(&self, some: bool) -> Result<(Tensor, Tensor), TchError>

pub fn f_qr_q( &self, q: &Tensor, r: &Tensor, some: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_quantile( &self, q: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Result<Tensor, TchError>

pub fn f_quantile_out( &self, out: &Tensor, q: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Result<Tensor, TchError>

pub fn f_quantile_scalar( &self, q: f64, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Result<Tensor, TchError>

pub fn f_quantile_scalar_out( &self, out: &Tensor, q: f64, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Result<Tensor, TchError>

pub fn f_quantize_per_channel( &self, scales: &Tensor, zero_points: &Tensor, axis: i64, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_quantize_per_channel_out( &self, out: &Tensor, scales: &Tensor, zero_points: &Tensor, axis: i64, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_quantize_per_tensor( &self, scale: f64, zero_point: i64, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_quantize_per_tensor_dynamic( &self, dtype: Kind, reduce_range: bool ) -> Result<Tensor, TchError>

pub fn f_quantize_per_tensor_dynamic_out( &self, out: &Tensor, dtype: Kind, reduce_range: bool ) -> Result<Tensor, TchError>

pub fn f_quantize_per_tensor_out( &self, out: &Tensor, scale: f64, zero_point: i64, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_quantize_per_tensor_tensor_qparams( &self, scale: &Tensor, zero_point: &Tensor, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_quantize_per_tensor_tensor_qparams_out( &self, out: &Tensor, scale: &Tensor, zero_point: &Tensor, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_quantize_per_tensor_tensors<T: Borrow<Tensor>>( tensors: &[T], scales: &Tensor, zero_points: &Tensor, dtype: Kind ) -> Result<Vec<Tensor>, TchError>

pub fn f_quantize_per_tensor_tensors_out<T: Borrow<Tensor>>( out: &[T], tensors: &[T], scales: &Tensor, zero_points: &Tensor, dtype: Kind ) -> Result<(), 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_batch_norm_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: Option<T>, bias: Option<T>, mean: &Tensor, var: &Tensor, eps: f64, output_scale: f64, output_zero_point: i64 ) -> Result<Tensor, TchError>

pub fn f_quantized_gru_cell<S: Into<Scalar>>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: &Tensor, b_hh: &Tensor, packed_ih: &Tensor, packed_hh: &Tensor, col_offsets_ih: &Tensor, col_offsets_hh: &Tensor, scale_ih: S, scale_hh: S, zero_point_ih: S, zero_point_hh: S ) -> Result<Tensor, TchError>

pub fn f_quantized_lstm_cell<T: Borrow<Tensor>, S: Into<Scalar>>( &self, hx: &[T], w_ih: &Tensor, w_hh: &Tensor, b_ih: &Tensor, b_hh: &Tensor, packed_ih: &Tensor, packed_hh: &Tensor, col_offsets_ih: &Tensor, col_offsets_hh: &Tensor, scale_ih: S, scale_hh: S, zero_point_ih: S, zero_point_hh: S ) -> Result<(Tensor, Tensor), TchError>

pub fn f_quantized_max_pool1d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_quantized_max_pool1d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_quantized_max_pool2d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_quantized_max_pool2d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_quantized_max_pool3d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Result<Tensor, TchError>

pub fn f_quantized_max_pool3d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, 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: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_rand_like(&self) -> Result<Tensor, TchError>

pub fn f_rand_like_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_rand_out(out: &Tensor, size: impl IntList) -> Result<Tensor, TchError>

pub fn f_randint( high: i64, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_randint_like(&self, high: i64) -> Result<Tensor, TchError>

pub fn f_randint_like_low_dtype( &self, low: i64, high: i64 ) -> Result<Tensor, TchError>

pub fn f_randint_like_low_dtype_out( &self, out: &Tensor, low: i64, high: i64 ) -> Result<Tensor, TchError>

pub fn f_randint_like_out( &self, out: &Tensor, high: i64 ) -> Result<Tensor, TchError>

pub fn f_randint_low( low: i64, high: i64, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_randint_low_out( out: &Tensor, low: i64, high: i64, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_randint_out( out: &Tensor, high: i64, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_randn( size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_randn_like(&self) -> Result<Tensor, TchError>

pub fn f_randn_like_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_randn_out(out: &Tensor, size: impl IntList) -> Result<Tensor, TchError>

pub fn f_random(&self) -> Result<Tensor, TchError>

pub fn f_random_(&mut self) -> Result<Tensor, TchError>

pub fn f_random_from( &self, from: i64, to: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_random_from_( &mut self, from: i64, to: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_random_from_out( &self, out: &Tensor, from: i64, to: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_random_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_random_to(&self, to: i64) -> Result<Tensor, TchError>

pub fn f_random_to_(&mut self, to: i64) -> Result<Tensor, TchError>

pub fn f_random_to_out(&self, out: &Tensor, to: i64) -> Result<Tensor, TchError>

pub fn f_randperm(n: i64, options: (Kind, Device)) -> Result<Tensor, TchError>

pub fn f_randperm_out(out: &Tensor, n: i64) -> Result<Tensor, TchError>

pub fn f_range<S: Into<Scalar>>( start: S, end: S, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_range_out<S: Into<Scalar>>( out: &Tensor, start: S, end: S ) -> Result<Tensor, TchError>

pub fn f_range_out_<S: Into<Scalar>>( out: &Tensor, start: S, end: S ) -> Result<Tensor, TchError>

pub fn f_range_step<S: Into<Scalar>>( start: S, end: S, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_ravel(&self) -> Result<Tensor, TchError>

pub fn f_real(&self) -> Result<Tensor, TchError>

pub fn f_reciprocal(&self) -> Result<Tensor, TchError>

pub fn f_reciprocal_(&mut self) -> Result<Tensor, TchError>

pub fn f_reciprocal_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_reflection_pad1d( &self, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad1d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad1d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad1d_out( &self, out: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad2d( &self, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad2d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad2d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad2d_out( &self, out: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad3d( &self, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad3d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad3d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_reflection_pad3d_out( &self, out: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_relu(&self) -> Result<Tensor, TchError>

pub fn f_relu6(&self) -> Result<Tensor, TchError>

pub fn f_relu6_(&mut self) -> Result<Tensor, TchError>

pub fn f_relu_(&mut self) -> Result<Tensor, TchError>

pub fn f_relu_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_remainder<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>

pub fn f_remainder_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

pub fn f_remainder_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_remainder_scalar_tensor<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_remainder_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_remainder_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_remainder_tensor_( &mut self, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_remainder_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_renorm<S: Into<Scalar>>( &self, p: S, dim: i64, maxnorm: S ) -> Result<Tensor, TchError>

pub fn f_renorm_<S: Into<Scalar>>( &mut self, p: S, dim: i64, maxnorm: S ) -> Result<Tensor, TchError>

pub fn f_renorm_out<S: Into<Scalar>>( &self, out: &Tensor, p: S, dim: i64, maxnorm: S ) -> Result<Tensor, TchError>

pub fn f_repeat(&self, repeats: impl IntList) -> Result<Tensor, TchError>

pub fn f_repeat_interleave( repeats: &Tensor, output_size: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_repeat_interleave_self_int( &self, repeats: i64, dim: impl Into<Option<i64>>, output_size: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_repeat_interleave_self_tensor( &self, repeats: &Tensor, dim: impl Into<Option<i64>>, output_size: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_repeat_interleave_tensor_out( out: &Tensor, repeats: &Tensor, output_size: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_repeat_out( &self, out: &Tensor, repeats: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad1d( &self, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad1d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad1d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad1d_out( &self, out: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad2d( &self, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad2d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad2d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad2d_out( &self, out: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad3d( &self, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad3d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad3d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_replication_pad3d_out( &self, out: &Tensor, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_requires_grad_( &mut self, requires_grad: bool ) -> Result<Tensor, TchError>

pub fn f_reshape(&self, shape: impl IntList) -> Result<Tensor, TchError>

pub fn f_reshape_as(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_resize(&self, size: impl IntList) -> Result<Tensor, TchError>

pub fn f_resize_(&mut self, size: impl IntList) -> Result<Tensor, TchError>

pub fn f_resize_as(&self, the_template: &Tensor) -> Result<Tensor, TchError>

pub fn f_resize_as_( &mut self, the_template: &Tensor ) -> Result<Tensor, TchError>

pub fn f_resize_as_out( &self, out: &Tensor, the_template: &Tensor ) -> Result<Tensor, TchError>

pub fn f_resize_as_sparse( &self, the_template: &Tensor ) -> Result<Tensor, TchError>

pub fn f_resize_as_sparse_( &mut self, the_template: &Tensor ) -> Result<Tensor, TchError>

pub fn f_resize_as_sparse_out( &self, out: &Tensor, the_template: &Tensor ) -> Result<Tensor, TchError>

pub fn f_resize_out( &self, out: &Tensor, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_resolve_conj(&self) -> Result<Tensor, TchError>

pub fn f_resolve_neg(&self) -> Result<Tensor, TchError>

pub fn f_retains_grad(&self) -> Result<bool, TchError>

pub fn f_rnn_relu<T: Borrow<Tensor>>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_rnn_relu_cell<T: Borrow<Tensor>>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Result<Tensor, TchError>

pub fn f_rnn_relu_data<T: Borrow<Tensor>>( data: &Tensor, batch_sizes: &Tensor, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_rnn_tanh<T: Borrow<Tensor>>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_rnn_tanh_cell<T: Borrow<Tensor>>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Result<Tensor, TchError>

pub fn f_rnn_tanh_data<T: Borrow<Tensor>>( data: &Tensor, batch_sizes: &Tensor, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_roll( &self, shifts: impl IntList, dims: impl IntList ) -> Result<Tensor, TchError>

pub fn f_roll_out( &self, out: &Tensor, shifts: impl IntList, dims: impl IntList ) -> Result<Tensor, TchError>

pub fn f_rot90(&self, k: i64, dims: impl IntList) -> Result<Tensor, TchError>

pub fn f_rot90_out( &self, out: &Tensor, k: i64, dims: impl IntList ) -> Result<Tensor, TchError>

pub fn f_round(&self) -> Result<Tensor, TchError>

pub fn f_round_(&mut self) -> Result<Tensor, TchError>

pub fn f_round_decimals(&self, decimals: i64) -> Result<Tensor, TchError>

pub fn f_round_decimals_(&mut self, decimals: i64) -> Result<Tensor, TchError>

pub fn f_round_decimals_out( &self, out: &Tensor, decimals: i64 ) -> Result<Tensor, TchError>

pub fn f_round_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_row_indices(&self) -> Result<Tensor, TchError>

pub fn f_row_indices_copy(&self) -> Result<Tensor, TchError>

pub fn f_row_indices_copy_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_row_stack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>

pub fn f_row_stack_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T] ) -> Result<Tensor, TchError>

pub fn f_rrelu(&self, training: bool) -> Result<Tensor, TchError>

pub fn f_rrelu_(&mut self, training: bool) -> Result<Tensor, TchError>

pub fn f_rrelu_with_noise( &self, noise: &Tensor, training: bool ) -> Result<Tensor, TchError>

pub fn f_rrelu_with_noise_( &mut self, noise: &Tensor, training: bool ) -> Result<Tensor, TchError>

pub fn f_rrelu_with_noise_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, noise: &Tensor, lower: S, upper: S, training: bool, self_is_result: bool ) -> Result<Tensor, TchError>

pub fn f_rrelu_with_noise_backward_out<S: Into<Scalar>>( &self, out: &Tensor, grad_output: &Tensor, noise: &Tensor, lower: S, upper: S, training: bool, self_is_result: bool ) -> Result<Tensor, TchError>

pub fn f_rrelu_with_noise_out( &self, out: &Tensor, noise: &Tensor, training: bool ) -> Result<Tensor, TchError>

pub fn f_rsqrt(&self) -> Result<Tensor, TchError>

pub fn f_rsqrt_(&mut self) -> Result<Tensor, TchError>

pub fn f_rsqrt_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_rsub(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_rsub_scalar<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_rsub_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_rsub_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_scalar_tensor<S: Into<Scalar>>( s: S, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, s: S ) -> Result<Tensor, TchError>

pub fn f_scaled_dot_product_attention<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, attn_mask: Option<T>, dropout_p: f64, is_causal: bool, scale: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_scatter( &self, dim: i64, index: &Tensor, src: &Tensor ) -> Result<Tensor, TchError>

pub fn f_scatter_( &mut self, dim: i64, index: &Tensor, src: &Tensor ) -> Result<Tensor, TchError>

pub fn f_scatter_add( &self, dim: i64, index: &Tensor, src: &Tensor ) -> Result<Tensor, TchError>

pub fn f_scatter_add_( &mut self, dim: i64, index: &Tensor, src: &Tensor ) -> Result<Tensor, TchError>

pub fn f_scatter_add_out( &self, out: &Tensor, dim: i64, index: &Tensor, src: &Tensor ) -> Result<Tensor, TchError>

pub fn f_scatter_reduce( &self, dim: i64, index: &Tensor, src: &Tensor, reduce: &str ) -> Result<Tensor, TchError>

pub fn f_scatter_reduce_( &mut self, dim: i64, index: &Tensor, src: &Tensor, reduce: &str ) -> Result<Tensor, TchError>

pub fn f_scatter_reduce_out( &self, out: &Tensor, dim: i64, index: &Tensor, src: &Tensor, reduce: &str ) -> Result<Tensor, TchError>

pub fn f_scatter_src_out( &self, out: &Tensor, dim: i64, index: &Tensor, src: &Tensor ) -> Result<Tensor, TchError>

pub fn f_scatter_value<S: Into<Scalar>>( &self, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>

pub fn f_scatter_value_<S: Into<Scalar>>( &mut self, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>

pub fn f_scatter_value_out<S: Into<Scalar>>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>

pub fn f_scatter_value_reduce<S: Into<Scalar>>( &self, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Result<Tensor, TchError>

pub fn f_scatter_value_reduce_<S: Into<Scalar>>( &mut self, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Result<Tensor, TchError>

pub fn f_scatter_value_reduce_out<S: Into<Scalar>>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Result<Tensor, TchError>

pub fn f_searchsorted<T: Borrow<Tensor>>( &self, sorted_sequence: &Tensor, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Result<Tensor, TchError>

pub fn f_searchsorted_scalar<T: Borrow<Tensor>, S: Into<Scalar>>( sorted_sequence: &Tensor, self_scalar: S, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Result<Tensor, TchError>

pub fn f_searchsorted_scalar_out<T: Borrow<Tensor>, S: Into<Scalar>>( out: &Tensor, sorted_sequence: &Tensor, self_scalar: S, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Result<Tensor, TchError>

pub fn f_searchsorted_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, sorted_sequence: &Tensor, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Result<Tensor, TchError>

pub fn f_segment_reduce<T: Borrow<Tensor>, S: Into<Scalar>>( data: &Tensor, reduce: &str, lengths: Option<T>, indices: Option<T>, offsets: Option<T>, axis: i64, unsafe_: bool, initial: S ) -> Result<Tensor, TchError>

pub fn f_segment_reduce_out<T: Borrow<Tensor>, S: Into<Scalar>>( out: &Tensor, data: &Tensor, reduce: &str, lengths: Option<T>, indices: Option<T>, offsets: Option<T>, axis: i64, unsafe_: bool, initial: S ) -> Result<Tensor, TchError>

pub fn f_select(&self, dim: i64, index: i64) -> Result<Tensor, TchError>

pub fn f_select_backward( grad_output: &Tensor, input_sizes: impl IntList, dim: i64, index: i64 ) -> Result<Tensor, TchError>

pub fn f_select_backward_out( out: &Tensor, grad_output: &Tensor, input_sizes: impl IntList, dim: i64, index: i64 ) -> Result<Tensor, TchError>

pub fn f_select_copy(&self, dim: i64, index: i64) -> Result<Tensor, TchError>

pub fn f_select_copy_int_out( &self, out: &Tensor, dim: i64, index: i64 ) -> Result<Tensor, TchError>

pub fn f_select_scatter( &self, src: &Tensor, dim: i64, index: i64 ) -> Result<Tensor, TchError>

pub fn f_select_scatter_out( &self, out: &Tensor, src: &Tensor, 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(&self) -> Result<Tensor, TchError>

pub fn f_set_(&mut self) -> Result<Tensor, TchError>

pub fn f_set_data(&mut self, new_data: &Tensor) -> Result<(), TchError>

pub fn f_set_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_set_requires_grad(&self, r: bool) -> Result<Tensor, TchError>

pub fn f_set_source_tensor(&self, source: &Tensor) -> Result<Tensor, TchError>

pub fn f_set_source_tensor_( &mut self, source: &Tensor ) -> Result<Tensor, TchError>

pub fn f_set_source_tensor_out( &self, out: &Tensor, source: &Tensor ) -> Result<Tensor, TchError>

pub fn f_set_source_tensor_storage_offset_( &mut self, source: &Tensor, storage_offset: i64, size: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>

pub fn f_sgn(&self) -> Result<Tensor, TchError>

pub fn f_sgn_(&mut self) -> Result<Tensor, TchError>

pub fn f_sgn_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sigmoid(&self) -> Result<Tensor, TchError>

pub fn f_sigmoid_(&mut self) -> Result<Tensor, TchError>

pub fn f_sigmoid_backward( grad_output: &Tensor, output: &Tensor ) -> Result<Tensor, TchError>

pub fn f_sigmoid_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output: &Tensor ) -> Result<Tensor, TchError>

pub fn f_sigmoid_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sign(&self) -> Result<Tensor, TchError>

pub fn f_sign_(&mut self) -> Result<Tensor, TchError>

pub fn f_sign_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_signbit(&self) -> Result<Tensor, TchError>

pub fn f_signbit_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_silu(&self) -> Result<Tensor, TchError>

pub fn f_silu_(&mut self) -> Result<Tensor, TchError>

pub fn f_silu_backward(&self, grad_output: &Tensor) -> Result<Tensor, TchError>

pub fn f_silu_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor ) -> Result<Tensor, TchError>

pub fn f_silu_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sin(&self) -> Result<Tensor, TchError>

pub fn f_sin_(&mut self) -> Result<Tensor, TchError>

pub fn f_sin_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sinc(&self) -> Result<Tensor, TchError>

pub fn f_sinc_(&mut self) -> Result<Tensor, TchError>

pub fn f_sinc_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sinh(&self) -> Result<Tensor, TchError>

pub fn f_sinh_(&mut self) -> Result<Tensor, TchError>

pub fn f_sinh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_slice( &self, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Result<Tensor, TchError>

pub fn f_slice_backward( grad_output: &Tensor, input_sizes: impl IntList, dim: i64, start: i64, end: i64, step: i64 ) -> Result<Tensor, TchError>

pub fn f_slice_backward_out( out: &Tensor, grad_output: &Tensor, input_sizes: impl IntList, dim: i64, start: i64, end: i64, step: i64 ) -> Result<Tensor, TchError>

pub fn f_slice_copy( &self, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Result<Tensor, TchError>

pub fn f_slice_copy_tensor_out( &self, out: &Tensor, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Result<Tensor, TchError>

pub fn f_slice_scatter( &self, src: &Tensor, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Result<Tensor, TchError>

pub fn f_slice_scatter_out( &self, out: &Tensor, src: &Tensor, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Result<Tensor, TchError>

pub fn f_slogdet(&self) -> Result<(Tensor, Tensor), TchError>

pub fn f_slogdet_out( &self, sign: &Tensor, logabsdet: &Tensor ) -> Result<(Tensor, Tensor), TchError>

pub fn f_slow_conv3d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_slow_conv3d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList ) -> Result<Tensor, TchError>

pub fn f_slow_conv_dilated2d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_slow_conv_dilated2d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_slow_conv_dilated3d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_slow_conv_dilated3d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_slow_conv_transpose2d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_slow_conv_transpose2d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_slow_conv_transpose3d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_slow_conv_transpose3d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>

pub fn f_smm(&self, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss( &self, target: &Tensor, reduction: Reduction, beta: f64 ) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction, beta: f64 ) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction, beta: f64 ) -> Result<Tensor, TchError>

pub fn f_smooth_l1_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction, beta: f64 ) -> Result<Tensor, TchError>

pub fn f_soft_margin_loss( &self, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_soft_margin_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_soft_margin_loss_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_soft_margin_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction ) -> Result<Tensor, TchError>

pub fn f_softmax( &self, dim: i64, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_softmax_int_out( &self, out: &Tensor, dim: i64, dtype: impl Into<Option<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 ) -> Result<Tensor, TchError>

pub fn f_softplus_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, beta: S, threshold: S ) -> Result<Tensor, TchError>

pub fn f_softplus_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_softshrink(&self) -> Result<Tensor, TchError>

pub fn f_softshrink_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, lambd: S ) -> Result<Tensor, TchError>

pub fn f_softshrink_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, lambd: S ) -> Result<Tensor, TchError>

pub fn f_softshrink_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_sort( &self, dim: i64, descending: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_sort_stable( &self, stable: bool, dim: i64, descending: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_sort_values( &self, values: &Tensor, indices: &Tensor, dim: i64, descending: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_sort_values_stable( &self, values: &Tensor, indices: &Tensor, stable: bool, dim: i64, descending: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_sparse_bsc_tensor( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_bsc_tensor_ccol_row_value_size( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_bsr_tensor( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_bsr_tensor_crow_col_value_size( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_compressed_tensor( compressed_indices: &Tensor, plain_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_compressed_tensor_comp_plain_value_size( compressed_indices: &Tensor, plain_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_coo_tensor( size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_coo_tensor_indices( indices: &Tensor, values: &Tensor, options: (Kind, Device), is_coalesced: bool ) -> Result<Tensor, TchError>

pub fn f_sparse_coo_tensor_indices_size( indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device), is_coalesced: bool ) -> Result<Tensor, TchError>

pub fn f_sparse_coo_tensor_size_out( out: &Tensor, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_sparse_csc_tensor( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_csc_tensor_ccol_row_value_size( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_csr_tensor( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_csr_tensor_crow_col_value_size( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_sparse_dim(&self) -> Result<i64, TchError>

pub fn f_sparse_mask(&self, mask: &Tensor) -> Result<Tensor, TchError>

pub fn f_sparse_mask_out( &self, out: &Tensor, mask: &Tensor ) -> Result<Tensor, TchError>

pub fn f_sparse_resize( &self, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Result<Tensor, TchError>

pub fn f_sparse_resize_( &mut self, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Result<Tensor, TchError>

pub fn f_sparse_resize_and_clear( &self, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Result<Tensor, TchError>

pub fn f_sparse_resize_and_clear_( &mut self, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Result<Tensor, TchError>

pub fn f_sparse_resize_and_clear_out( &self, out: &Tensor, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Result<Tensor, TchError>

pub fn f_sparse_resize_out( &self, out: &Tensor, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Result<Tensor, TchError>

pub fn f_sparse_sampled_addmm( &self, mat1: &Tensor, mat2: &Tensor ) -> Result<Tensor, TchError>

pub fn f_sparse_sampled_addmm_out( &self, out: &Tensor, mat1: &Tensor, mat2: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_airy_ai(x: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_airy_ai_out( out: &Tensor, x: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_bessel_j0(&self) -> Result<Tensor, TchError>

pub fn f_special_bessel_j0_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_bessel_j1(&self) -> Result<Tensor, TchError>

pub fn f_special_bessel_j1_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_bessel_y0(&self) -> Result<Tensor, TchError>

pub fn f_special_bessel_y0_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_bessel_y1(&self) -> Result<Tensor, TchError>

pub fn f_special_bessel_y1_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_t( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_t_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_t_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_t_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_t_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_t_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_u( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_u_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_u_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_u_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_u_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_u_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_v( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_v_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_v_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_v_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_v_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_v_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_w( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_w_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_w_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_w_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_w_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_chebyshev_polynomial_w_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_digamma(&self) -> Result<Tensor, TchError>

pub fn f_special_digamma_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_entr(&self) -> Result<Tensor, TchError>

pub fn f_special_entr_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_erf(&self) -> Result<Tensor, TchError>

pub fn f_special_erf_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_erfc(&self) -> Result<Tensor, TchError>

pub fn f_special_erfc_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_erfcx(&self) -> Result<Tensor, TchError>

pub fn f_special_erfcx_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_erfinv(&self) -> Result<Tensor, TchError>

pub fn f_special_erfinv_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_exp2(&self) -> Result<Tensor, TchError>

pub fn f_special_exp2_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_expit(&self) -> Result<Tensor, TchError>

pub fn f_special_expit_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_expm1(&self) -> Result<Tensor, TchError>

pub fn f_special_expm1_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_gammainc(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_gammainc_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_gammaincc(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_gammaincc_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_gammaln(&self) -> Result<Tensor, TchError>

pub fn f_special_gammaln_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_h( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_h_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_h_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_h_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_h_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_h_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_he( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_he_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_he_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_he_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_he_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_hermite_polynomial_he_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_i0(&self) -> Result<Tensor, TchError>

pub fn f_special_i0_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_i0e(&self) -> Result<Tensor, TchError>

pub fn f_special_i0e_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_i1(&self) -> Result<Tensor, TchError>

pub fn f_special_i1_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_i1e(&self) -> Result<Tensor, TchError>

pub fn f_special_i1e_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_laguerre_polynomial_l( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_laguerre_polynomial_l_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_laguerre_polynomial_l_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_laguerre_polynomial_l_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_laguerre_polynomial_l_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_laguerre_polynomial_l_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_legendre_polynomial_p( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_legendre_polynomial_p_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_legendre_polynomial_p_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_legendre_polynomial_p_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_legendre_polynomial_p_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_legendre_polynomial_p_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_log1p(&self) -> Result<Tensor, TchError>

pub fn f_special_log1p_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_log_ndtr(&self) -> Result<Tensor, TchError>

pub fn f_special_log_ndtr_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_log_softmax( &self, dim: i64, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_special_logit( &self, eps: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_special_logit_out( &self, out: &Tensor, eps: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_special_logsumexp( &self, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_special_logsumexp_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_special_modified_bessel_i0(&self) -> Result<Tensor, TchError>

pub fn f_special_modified_bessel_i0_out( &self, out: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_modified_bessel_i1(&self) -> Result<Tensor, TchError>

pub fn f_special_modified_bessel_i1_out( &self, out: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_modified_bessel_k0(&self) -> Result<Tensor, TchError>

pub fn f_special_modified_bessel_k0_out( &self, out: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_modified_bessel_k1(&self) -> Result<Tensor, TchError>

pub fn f_special_modified_bessel_k1_out( &self, out: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_multigammaln(&self, p: i64) -> Result<Tensor, TchError>

pub fn f_special_multigammaln_out( &self, out: &Tensor, p: i64 ) -> Result<Tensor, TchError>

pub fn f_special_ndtr(&self) -> Result<Tensor, TchError>

pub fn f_special_ndtr_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_ndtri(&self) -> Result<Tensor, TchError>

pub fn f_special_ndtri_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_polygamma(&self, n: i64) -> Result<Tensor, TchError>

pub fn f_special_polygamma_out( &self, out: &Tensor, n: i64 ) -> Result<Tensor, TchError>

pub fn f_special_psi(&self) -> Result<Tensor, TchError>

pub fn f_special_psi_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_round(&self, decimals: i64) -> Result<Tensor, TchError>

pub fn f_special_round_out( &self, out: &Tensor, decimals: i64 ) -> Result<Tensor, TchError>

pub fn f_special_scaled_modified_bessel_k0( x: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_scaled_modified_bessel_k0_out( out: &Tensor, x: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_scaled_modified_bessel_k1( x: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_scaled_modified_bessel_k1_out( out: &Tensor, x: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_t( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_t_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_t_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_t_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_t_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_t_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_u( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_u_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_u_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_u_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_u_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_u_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_v( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_v_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_v_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_v_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_v_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_v_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_w( x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_w_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_w_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_w_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_w_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_shifted_chebyshev_polynomial_w_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_sinc(&self) -> Result<Tensor, TchError>

pub fn f_special_sinc_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_softmax( &self, dim: i64, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_special_spherical_bessel_j0(x: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_spherical_bessel_j0_out( out: &Tensor, x: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_xlog1py(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_other_scalar<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_other_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_self_scalar<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_xlog1py_self_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_xlogy(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_xlogy_other_scalar<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_special_xlogy_other_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_special_xlogy_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_xlogy_self_scalar<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_xlogy_self_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_zeta(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_special_zeta_other_scalar<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_special_zeta_other_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_special_zeta_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_zeta_self_scalar<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_special_zeta_self_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_split( &self, split_size: i64, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_split_copy( &self, split_size: i64, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_split_copy_tensor_out<T: Borrow<Tensor>>( &self, out: &[T], split_size: i64, dim: i64 ) -> Result<(), TchError>

pub fn f_split_sizes( &self, split_size: impl IntList, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_split_with_sizes( &self, split_sizes: impl IntList, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_split_with_sizes_copy( &self, split_sizes: impl IntList, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_split_with_sizes_copy_out<T: Borrow<Tensor>>( &self, out: &[T], split_sizes: impl IntList, dim: i64 ) -> Result<(), TchError>

pub fn f_sqrt(&self) -> Result<Tensor, TchError>

pub fn f_sqrt_(&mut self) -> Result<Tensor, TchError>

pub fn f_sqrt_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_square(&self) -> Result<Tensor, TchError>

pub fn f_square_(&mut self) -> Result<Tensor, TchError>

pub fn f_square_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_squeeze(&self) -> Result<Tensor, TchError>

pub fn f_squeeze_(&mut self) -> Result<Tensor, TchError>

pub fn f_squeeze_copy(&self) -> Result<Tensor, TchError>

pub fn f_squeeze_copy_dim(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_squeeze_copy_dim_out( &self, out: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_squeeze_copy_dims(&self, dim: impl IntList) -> Result<Tensor, TchError>

pub fn f_squeeze_copy_dims_out( &self, out: &Tensor, dim: impl IntList ) -> Result<Tensor, TchError>

pub fn f_squeeze_copy_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_squeeze_dim(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_squeeze_dim_(&mut self, dim: i64) -> Result<Tensor, TchError>

pub fn f_squeeze_dims(&self, dim: impl IntList) -> Result<Tensor, TchError>

pub fn f_squeeze_dims_(&mut self, dim: impl IntList) -> Result<Tensor, TchError>

pub fn f_sspaddmm( &self, mat1: &Tensor, mat2: &Tensor ) -> Result<Tensor, TchError>

pub fn f_sspaddmm_out( &self, out: &Tensor, mat1: &Tensor, mat2: &Tensor ) -> Result<Tensor, TchError>

pub fn f_stack<T: Borrow<Tensor>>( tensors: &[T], dim: i64 ) -> Result<Tensor, TchError>

pub fn f_stack_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T], dim: i64 ) -> Result<Tensor, TchError>

pub fn f_std(&self, unbiased: bool) -> Result<Tensor, TchError>

pub fn f_std_correction<S: Into<Scalar>>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_std_correction_out<S: Into<Scalar>>( &self, out: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_std_dim( &self, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_std_mean(&self, unbiased: bool) -> Result<(Tensor, Tensor), TchError>

pub fn f_std_mean_correction<S: Into<Scalar>>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_std_mean_correction_out<S: Into<Scalar>>( &self, out0: &Tensor, out1: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_std_mean_dim( &self, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_std_out( &self, out: &Tensor, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_stft<T: Borrow<Tensor>>( &self, n_fft: i64, hop_length: impl Into<Option<i64>>, win_length: impl Into<Option<i64>>, window: Option<T>, normalized: bool, onesided: bool, return_complex: bool ) -> Result<Tensor, TchError>

pub fn f_stft_center<T: Borrow<Tensor>>( &self, n_fft: i64, hop_length: impl Into<Option<i64>>, win_length: impl Into<Option<i64>>, window: Option<T>, center: bool, pad_mode: &str, normalized: bool, onesided: bool, return_complex: bool ) -> Result<Tensor, TchError>

pub fn f_sub(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_sub_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_sub_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_sub_scalar<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_sub_scalar_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

pub fn f_sub_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_subtract(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_subtract_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_subtract_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_subtract_scalar<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_subtract_scalar_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

pub fn f_sum(&self, dtype: impl Into<Option<Kind>>) -> Result<Tensor, TchError>

pub fn f_sum_dim_intlist( &self, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_sum_intlist_out( &self, out: &Tensor, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_sum_out( &self, out: &Tensor, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_sum_to_size(&self, size: impl IntList) -> Result<Tensor, TchError>

pub fn f_svd( &self, some: bool, compute_uv: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_svd_u( &self, u: &Tensor, s: &Tensor, v: &Tensor, some: bool, compute_uv: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_swapaxes(&self, axis0: i64, axis1: i64) -> Result<Tensor, TchError>

pub fn f_swapaxes_( &mut self, axis0: i64, axis1: i64 ) -> Result<Tensor, TchError>

pub fn f_swapdims(&self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>

pub fn f_swapdims_(&mut self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>

pub fn f_tr(&self) -> Result<Tensor, TchError>

pub fn f_t_(&mut self) -> Result<Tensor, TchError>

pub fn f_t_copy(&self) -> Result<Tensor, TchError>

pub fn f_t_copy_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_take(&self, index: &Tensor) -> Result<Tensor, TchError>

pub fn f_take_along_dim( &self, indices: &Tensor, dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_take_along_dim_out( &self, out: &Tensor, indices: &Tensor, dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_take_out( &self, out: &Tensor, index: &Tensor ) -> Result<Tensor, TchError>

pub fn f_tan(&self) -> Result<Tensor, TchError>

pub fn f_tan_(&mut self) -> Result<Tensor, TchError>

pub fn f_tan_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_tanh(&self) -> Result<Tensor, TchError>

pub fn f_tanh_(&mut self) -> Result<Tensor, TchError>

pub fn f_tanh_backward( grad_output: &Tensor, output: &Tensor ) -> Result<Tensor, TchError>

pub fn f_tanh_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output: &Tensor ) -> Result<Tensor, TchError>

pub fn f_tanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_tensor_split( &self, sections: i64, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_tensor_split_indices( &self, indices: impl IntList, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_tensor_split_tensor_indices_or_sections( &self, tensor_indices_or_sections: &Tensor, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_tensordot( &self, other: &Tensor, dims_self: impl IntList, dims_other: impl IntList ) -> Result<Tensor, TchError>

pub fn f_tensordot_out( &self, out: &Tensor, other: &Tensor, dims_self: impl IntList, dims_other: impl IntList ) -> Result<Tensor, TchError>

pub fn f_threshold<S: Into<Scalar>>( &self, threshold: S, value: S ) -> Result<Tensor, TchError>

pub fn f_threshold_<S: Into<Scalar>>( &mut self, threshold: S, value: S ) -> Result<Tensor, TchError>

pub fn f_threshold_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, threshold: S ) -> Result<Tensor, TchError>

pub fn f_threshold_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, threshold: S ) -> Result<Tensor, TchError>

pub fn f_threshold_out<S: Into<Scalar>>( &self, out: &Tensor, threshold: S, value: S ) -> Result<Tensor, TchError>

pub fn f_tile(&self, dims: impl IntList) -> Result<Tensor, TchError>

pub fn f_to(&self, device: Device) -> Result<Tensor, TchError>

pub fn f_to_dense( &self, dtype: impl Into<Option<Kind>>, masked_grad: bool ) -> Result<Tensor, TchError>

pub fn f_to_dense_backward( &self, grad: &Tensor, masked_grad: bool ) -> Result<Tensor, TchError>

pub fn f_to_device_( &self, device: Device, dtype: Kind, non_blocking: bool, copy: bool ) -> Result<Tensor, TchError>

pub fn f_to_dtype( &self, dtype: Kind, non_blocking: bool, copy: bool ) -> Result<Tensor, TchError>

pub fn f_to_dtype_layout( &self, options: (Kind, Device), non_blocking: bool, copy: bool ) -> Result<Tensor, TchError>

pub fn f_to_mkldnn( &self, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_to_mkldnn_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>

pub fn f_to_mkldnn_out( &self, out: &Tensor, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>

pub fn f_to_other( &self, other: &Tensor, non_blocking: bool, copy: bool ) -> Result<Tensor, TchError>

pub fn f_to_padded_tensor( &self, padding: f64, output_size: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_to_padded_tensor_out( &self, out: &Tensor, padding: f64, output_size: impl IntListOption ) -> Result<Tensor, TchError>

pub fn f_to_sparse( &self, layout: Option<Layout>, blocksize: impl IntListOption, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_to_sparse_bsc( &self, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_to_sparse_bsr( &self, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_to_sparse_csc( &self, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_to_sparse_csr( &self, dense_dim: impl Into<Option<i64>> ) -> Result<Tensor, TchError>

pub fn f_to_sparse_sparse_dim( &self, sparse_dim: i64 ) -> Result<Tensor, TchError>

pub fn f_topk( &self, k: i64, dim: i64, largest: bool, sorted: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_topk_values( &self, values: &Tensor, indices: &Tensor, k: i64, dim: i64, largest: bool, sorted: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_totype(&self, scalar_type: Kind) -> Result<Tensor, TchError>

pub fn f_trace(&self) -> Result<Tensor, TchError>

pub fn f_trace_backward( grad: &Tensor, sizes: impl IntList ) -> Result<Tensor, TchError>

pub fn f_trace_out(&self, out: &Tensor) -> 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_transpose_copy(&self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>

pub fn f_transpose_copy_int_out( &self, out: &Tensor, dim0: i64, dim1: i64 ) -> Result<Tensor, TchError>

pub fn f_trapezoid(y: &Tensor, dim: i64) -> Result<Tensor, TchError>

pub fn f_trapezoid_x( y: &Tensor, x: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_trapz(y: &Tensor, x: &Tensor, dim: i64) -> Result<Tensor, TchError>

pub fn f_trapz_dx(y: &Tensor, dx: f64, dim: i64) -> Result<Tensor, TchError>

pub fn f_triangular_solve( &self, a: &Tensor, upper: bool, transpose: bool, unitriangular: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_triangular_solve_x( &self, x: &Tensor, m: &Tensor, a: &Tensor, upper: bool, transpose: bool, unitriangular: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_tril(&self, diagonal: i64) -> Result<Tensor, TchError>

pub fn f_tril_(&mut self, diagonal: i64) -> Result<Tensor, TchError>

pub fn f_tril_indices( row: i64, col: i64, offset: i64, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_tril_indices_out( out: &Tensor, row: i64, col: i64, offset: i64 ) -> 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_indices_out( out: &Tensor, row: i64, col: i64, offset: i64 ) -> Result<Tensor, TchError>

pub fn f_triu_out( &self, out: &Tensor, diagonal: i64 ) -> Result<Tensor, TchError>

pub fn f_true_divide(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_true_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_true_divide_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_true_divide_scalar<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_true_divide_scalar_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

pub fn f_trunc(&self) -> Result<Tensor, TchError>

pub fn f_trunc_(&mut self) -> Result<Tensor, TchError>

pub fn f_trunc_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_type_as(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_unbind(&self, dim: i64) -> Result<Vec<Tensor>, TchError>

pub fn f_unbind_copy(&self, dim: i64) -> Result<Vec<Tensor>, TchError>

pub fn f_unbind_copy_int_out<T: Borrow<Tensor>>( &self, out: &[T], dim: i64 ) -> Result<(), TchError>

pub fn f_unflatten( &self, dim: i64, sizes: impl IntList ) -> Result<Tensor, TchError>

pub fn f_unflatten_dense_tensors<T: Borrow<Tensor>>( flat: &Tensor, tensors: &[T] ) -> Result<Vec<Tensor>, TchError>

pub fn f_unfold( &self, dimension: i64, size: i64, step: i64 ) -> Result<Tensor, TchError>

pub fn f_unfold_backward( grad_in: &Tensor, input_sizes: impl IntList, dim: i64, size: i64, step: i64 ) -> Result<Tensor, TchError>

pub fn f_unfold_backward_out( out: &Tensor, grad_in: &Tensor, input_sizes: impl IntList, dim: i64, size: i64, step: i64 ) -> Result<Tensor, TchError>

pub fn f_unfold_copy( &self, dimension: i64, size: i64, step: i64 ) -> Result<Tensor, TchError>

pub fn f_unfold_copy_out( &self, out: &Tensor, dimension: i64, size: i64, step: i64 ) -> Result<Tensor, TchError>

pub fn f_uniform(&self, from: f64, to: f64) -> Result<Tensor, TchError>

pub fn f_uniform_(&mut self, from: f64, to: f64) -> Result<Tensor, TchError>

pub fn f_uniform_out( &self, out: &Tensor, 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_consecutive_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, 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_unique_dim_consecutive_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, dim: i64, return_inverse: bool, return_counts: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_unique_dim_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, dim: i64, sorted: bool, return_inverse: bool, return_counts: bool ) -> Result<(Tensor, Tensor, Tensor), TchError>

pub fn f_unsafe_chunk( &self, chunks: i64, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_unsafe_split( &self, split_size: i64, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_unsafe_split_tensor_out<T: Borrow<Tensor>>( &self, out: &[T], split_size: i64, dim: i64 ) -> Result<(), TchError>

pub fn f_unsafe_split_with_sizes( &self, split_sizes: impl IntList, dim: i64 ) -> Result<Vec<Tensor>, TchError>

pub fn f_unsafe_split_with_sizes_out<T: Borrow<Tensor>>( &self, out: &[T], split_sizes: impl IntList, dim: i64 ) -> Result<(), 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_unsqueeze_copy(&self, dim: i64) -> Result<Tensor, TchError>

pub fn f_unsqueeze_copy_out( &self, out: &Tensor, dim: i64 ) -> Result<Tensor, TchError>

pub fn f_upsample_bicubic2d( &self, output_size: impl IntList, 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: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_bicubic2d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, 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: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_bicubic2d_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_upsample_bilinear2d( &self, output_size: impl IntList, 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: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_bilinear2d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, 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: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_bilinear2d_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d( &self, output_size: impl IntList, align_corners: bool, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d_out( &self, out: &Tensor, output_size: impl IntList, align_corners: bool, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_linear1d_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d( &self, output_size: impl IntList, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d_out( &self, out: &Tensor, output_size: impl IntList, scales: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest1d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest2d( &self, output_size: impl IntList, 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: impl IntList, input_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest2d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, 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: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest2d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest3d( &self, output_size: impl IntList, 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: impl IntList, input_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest3d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, 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: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_nearest3d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_upsample_trilinear3d( &self, output_size: impl IntList, 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: impl IntList, input_size: impl IntList, align_corners: bool, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_trilinear3d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, 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: impl IntList, align_corners: bool, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Result<Tensor, TchError>

pub fn f_upsample_trilinear3d_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Result<Tensor, TchError>

pub fn f_value_selecting_reduction_backward( grad: &Tensor, dim: i64, indices: &Tensor, sizes: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_values(&self) -> Result<Tensor, TchError>

pub fn f_values_copy(&self) -> Result<Tensor, TchError>

pub fn f_values_copy_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_vander( x: &Tensor, n: impl Into<Option<i64>>, increasing: bool ) -> Result<Tensor, TchError>

pub fn f_var(&self, unbiased: bool) -> Result<Tensor, TchError>

pub fn f_var_correction<S: Into<Scalar>>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_var_correction_out<S: Into<Scalar>>( &self, out: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_var_dim( &self, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_var_mean(&self, unbiased: bool) -> Result<(Tensor, Tensor), TchError>

pub fn f_var_mean_correction<S: Into<Scalar>>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_var_mean_correction_out<S: Into<Scalar>>( &self, out0: &Tensor, out1: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_var_mean_dim( &self, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_var_out( &self, out: &Tensor, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Result<Tensor, TchError>

pub fn f_vdot(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_vdot_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_view_(&self, size: impl IntList) -> 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_complex_copy(&self) -> Result<Tensor, TchError>

pub fn f_view_as_complex_copy_out( &self, out: &Tensor ) -> Result<Tensor, TchError>

pub fn f_view_as_real(&self) -> Result<Tensor, TchError>

pub fn f_view_as_real_copy(&self) -> Result<Tensor, TchError>

pub fn f_view_as_real_copy_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_view_copy(&self, size: impl IntList) -> Result<Tensor, TchError>

pub fn f_view_copy_dtype(&self, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_view_copy_dtype_out( &self, out: &Tensor, dtype: Kind ) -> Result<Tensor, TchError>

pub fn f_view_copy_out( &self, out: &Tensor, size: impl IntList ) -> Result<Tensor, TchError>

pub fn f_view_dtype(&self, dtype: Kind) -> Result<Tensor, TchError>

pub fn f_vsplit(&self, sections: i64) -> Result<Vec<Tensor>, TchError>

pub fn f_vsplit_array( &self, indices: impl IntList ) -> Result<Vec<Tensor>, TchError>

pub fn f_vstack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>

pub fn f_vstack_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T] ) -> Result<Tensor, TchError>

pub fn f_where_(condition: &Tensor) -> Result<Vec<Tensor>, TchError>

pub fn f_where_scalar<S: Into<Scalar>>( condition: &Tensor, self_scalar: S, other: S ) -> Result<Tensor, TchError>

pub fn f_where_scalarother<S: Into<Scalar>>( &self, condition: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_where_scalarself<S: Into<Scalar>>( condition: &Tensor, self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_where_self( &self, condition: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_where_self_out( &self, out: &Tensor, condition: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_xlogy(&self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_xlogy_(&mut self, other: &Tensor) -> Result<Tensor, TchError>

pub fn f_xlogy_outscalar_other<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Result<Tensor, TchError>

pub fn f_xlogy_outscalar_self<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_xlogy_outtensor( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_xlogy_scalar_other<S: Into<Scalar>>( &self, other: S ) -> Result<Tensor, TchError>

pub fn f_xlogy_scalar_other_<S: Into<Scalar>>( &mut self, other: S ) -> Result<Tensor, TchError>

pub fn f_xlogy_scalar_self<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Result<Tensor, TchError>

pub fn f_zero(&self) -> Result<Tensor, TchError>

pub fn f_zero_(&mut self) -> Result<Tensor, TchError>

pub fn f_zero_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_zeros( size: impl IntList, options: (Kind, Device) ) -> Result<Tensor, TchError>

pub fn f_zeros_like(&self) -> Result<Tensor, TchError>

pub fn f_zeros_like_out(&self, out: &Tensor) -> Result<Tensor, TchError>

pub fn f_zeros_out(out: &Tensor, size: impl IntList) -> Result<Tensor, TchError>

impl Tensor

pub fn internal_and_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_and_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_iand_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_iand_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_ilshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_ilshift_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_ior_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_ior_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_irshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_irshift_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_ixor_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_ixor_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_lshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_lshift_scalar_out_<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn internal_lshift_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_lshift_tensor_out_( &self, out: &Tensor, other: &Tensor ) -> Tensor

pub fn internal_or_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_or_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_rshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_rshift_scalar_out_<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn internal_rshift_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_rshift_tensor_out_( &self, out: &Tensor, other: &Tensor ) -> Tensor

pub fn internal_xor_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_xor_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn internal_adaptive_avg_pool2d(&self, output_size: impl IntList) -> Tensor

pub fn internal_adaptive_avg_pool2d_backward( &self, grad_output: &Tensor ) -> Tensor

pub fn internal_adaptive_avg_pool2d_backward_out( &self, out: &Tensor, grad_output: &Tensor ) -> Tensor

pub fn internal_adaptive_avg_pool2d_out( &self, out: &Tensor, output_size: impl IntList ) -> Tensor

pub fn internal_adaptive_avg_pool3d(&self, output_size: impl IntList) -> Tensor

pub fn internal_adaptive_avg_pool3d_backward( &self, grad_output: &Tensor ) -> Tensor

pub fn internal_adaptive_avg_pool3d_backward_out( &self, out: &Tensor, grad_output: &Tensor ) -> Tensor

pub fn internal_adaptive_avg_pool3d_out( &self, out: &Tensor, output_size: impl IntList ) -> Tensor

pub fn internal_add_batch_dim(&self, batch_dim: i64, level: i64) -> Tensor

pub fn internal_add_relu(&self, other: &Tensor) -> Tensor

pub fn internal_add_relu_(&mut self, other: &Tensor) -> Tensor

pub fn internal_add_relu_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn internal_add_relu_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn internal_add_relu_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn internal_add_relu_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn internal_addmm_activation( &self, mat1: &Tensor, mat2: &Tensor, use_gelu: bool ) -> Tensor

pub fn internal_addmm_activation_out( &self, out: &Tensor, mat1: &Tensor, mat2: &Tensor, use_gelu: bool ) -> Tensor

pub fn internal_aminmax(&self) -> (Tensor, Tensor)

pub fn internal_aminmax_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn internal_aminmax_dim_out( &self, out0: &Tensor, out1: &Tensor, dim: i64, keepdim: bool ) -> (Tensor, Tensor)

pub fn internal_aminmax_out( &self, out0: &Tensor, out1: &Tensor ) -> (Tensor, Tensor)

pub fn internal_amp_update_scale( &self, growth_tracker: &Tensor, found_inf: &Tensor, scale_growth_factor: f64, scale_backoff_factor: f64, growth_interval: i64 ) -> (Tensor, Tensor)

pub fn internal_amp_update_scale_( &mut self, growth_tracker: &Tensor, found_inf: &Tensor, scale_growth_factor: f64, scale_backoff_factor: f64, growth_interval: i64 ) -> Tensor

pub fn internal_amp_update_scale_out( &self, out: &Tensor, growth_tracker: &Tensor, found_inf: &Tensor, scale_growth_factor: f64, scale_backoff_factor: f64, growth_interval: i64 ) -> Tensor

pub fn internal_assert_tensor_metadata( a: &Tensor, size: impl IntListOption, stride: impl IntListOption, dtype: impl Into<Option<Kind>> )

pub fn internal_autocast_to_full_precision( &self, cuda_enabled: bool, cpu_enabled: bool ) -> Tensor

pub fn internal_autocast_to_reduced_precision( &self, cuda_enabled: bool, cpu_enabled: bool, cuda_dtype: Kind, cpu_dtype: Kind ) -> 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_cdist_backward( grad: &Tensor, x1: &Tensor, x2: &Tensor, p: f64, cdist: &Tensor ) -> Tensor

pub fn internal_cdist_backward_out( out: &Tensor, grad: &Tensor, x1: &Tensor, x2: &Tensor, p: f64, cdist: &Tensor ) -> Tensor

pub fn internal_cholesky_solve_helper(&self, a: &Tensor, upper: bool) -> Tensor

pub fn internal_cholesky_solve_helper_out( &self, out: &Tensor, a: &Tensor, upper: bool ) -> Tensor

pub fn internal_coalesce(&self) -> Tensor

pub fn internal_coalesce_out(&self, out: &Tensor) -> Tensor

pub fn internal_coalesced(&self, coalesced: bool) -> Tensor

pub fn internal_coalesced_(&mut self, coalesced: bool) -> Tensor

pub fn internal_coalesced_out(&self, out: &Tensor, coalesced: bool) -> Tensor

pub fn internal_compute_linear_combination( &self, coefficients: &Tensor ) -> Tensor

pub fn internal_compute_linear_combination_out( &self, out: &Tensor, coefficients: &Tensor ) -> Tensor

pub fn internal_conj(&self) -> Tensor

pub fn internal_conj_copy(&self) -> Tensor

pub fn internal_conj_copy_out(&self, out: &Tensor) -> Tensor

pub fn internal_conj_physical(&self) -> Tensor

pub fn internal_conj_physical_out(&self, out: &Tensor) -> Tensor

pub fn internal_conv_depthwise2d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn internal_conv_depthwise2d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn internal_convert_indices_from_coo_to_csr( &self, size: i64, out_int32: bool ) -> Tensor

pub fn internal_convert_indices_from_coo_to_csr_out( &self, out: &Tensor, size: i64, out_int32: bool ) -> Tensor

pub fn internal_convert_indices_from_csr_to_coo( crow_indices: &Tensor, col_indices: &Tensor, out_int32: bool, transpose: bool ) -> Tensor

pub fn internal_convert_indices_from_csr_to_coo_out( out: &Tensor, crow_indices: &Tensor, col_indices: &Tensor, out_int32: bool, transpose: bool ) -> Tensor

pub fn internal_convolution<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, transposed: bool, output_padding: impl IntList, groups: i64, benchmark: bool, deterministic: bool, cudnn_enabled: bool, allow_tf32: bool ) -> Tensor

pub fn internal_convolution_deprecated<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, transposed: bool, output_padding: impl IntList, groups: i64, benchmark: bool, deterministic: bool, cudnn_enabled: bool ) -> Tensor

pub fn internal_convolution_mode<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: &str, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn internal_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, transposed: bool, output_padding: impl IntList, groups: i64, benchmark: bool, deterministic: bool, cudnn_enabled: bool, allow_tf32: bool ) -> Tensor

pub fn internal_copy_from(&self, dst: &Tensor, non_blocking: bool) -> Tensor

pub fn internal_copy_from_and_resize(&self, dst: &Tensor) -> Tensor

pub fn internal_copy_from_and_resize_out( &self, out: &Tensor, dst: &Tensor ) -> Tensor

pub fn internal_copy_from_out( &self, out: &Tensor, dst: &Tensor, non_blocking: bool ) -> Tensor

pub fn internal_cslt_compress(&self) -> Tensor

pub fn internal_cslt_sparse_mm<T: Borrow<Tensor>>( compressed_a: &Tensor, dense_b: &Tensor, bias: Option<T>, transpose_result: bool ) -> Tensor

pub fn internal_ctc_loss( log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, blank: i64, zero_infinity: bool ) -> (Tensor, Tensor)

pub fn internal_ctc_loss_backward( grad: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, neg_log_likelihood: &Tensor, log_alpha: &Tensor, blank: i64, zero_infinity: bool ) -> Tensor

pub fn internal_ctc_loss_backward_out( out: &Tensor, grad: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, neg_log_likelihood: &Tensor, log_alpha: &Tensor, blank: i64, zero_infinity: bool ) -> Tensor

pub fn internal_ctc_loss_backward_tensor( grad: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: &Tensor, target_lengths: &Tensor, neg_log_likelihood: &Tensor, log_alpha: &Tensor, blank: i64, zero_infinity: bool ) -> Tensor

pub fn internal_ctc_loss_out( out0: &Tensor, out1: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, blank: i64, zero_infinity: bool ) -> (Tensor, Tensor)

pub fn internal_ctc_loss_tensor( log_probs: &Tensor, targets: &Tensor, input_lengths: &Tensor, target_lengths: &Tensor, blank: i64, zero_infinity: bool ) -> (Tensor, Tensor)

pub fn internal_ctc_loss_tensor_out( out0: &Tensor, out1: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: &Tensor, target_lengths: &Tensor, blank: i64, zero_infinity: bool ) -> (Tensor, Tensor)

pub fn internal_cudnn_ctc_loss( log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, blank: i64, deterministic: bool, zero_infinity: bool ) -> (Tensor, Tensor)

pub fn internal_cudnn_ctc_loss_out( out0: &Tensor, out1: &Tensor, log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, blank: i64, deterministic: bool, zero_infinity: bool ) -> (Tensor, Tensor)

pub fn internal_cudnn_ctc_loss_tensor( log_probs: &Tensor, targets: &Tensor, input_lengths: &Tensor, target_lengths: &Tensor, 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_init_dropout_state_out( out: &Tensor, dropout: f64, train: bool, dropout_seed: i64 ) -> Tensor

pub fn internal_cudnn_rnn<T: Borrow<Tensor>>( &self, weight: &[T], weight_stride0: i64, weight_buf: Option<T>, hx: &Tensor, cx: Option<T>, mode: i64, hidden_size: i64, proj_size: i64, num_layers: i64, batch_first: bool, dropout: f64, train: bool, bidirectional: bool, batch_sizes: impl IntList, dropout_state: Option<T> ) -> (Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn internal_cudnn_rnn_flatten_weight<T: Borrow<Tensor>>( weight_arr: &[T], weight_stride0: i64, input_size: i64, mode: i64, hidden_size: i64, proj_size: i64, num_layers: i64, batch_first: bool, bidirectional: bool ) -> Tensor

pub fn internal_cudnn_rnn_flatten_weight_out<T: Borrow<Tensor>>( out: &Tensor, weight_arr: &[T], weight_stride0: i64, input_size: i64, mode: i64, hidden_size: i64, proj_size: i64, num_layers: i64, batch_first: bool, bidirectional: bool ) -> Tensor

pub fn internal_cudnn_rnn_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, out4: &Tensor, weight: &[T], weight_stride0: i64, weight_buf: Option<T>, hx: &Tensor, cx: Option<T>, mode: i64, hidden_size: i64, proj_size: i64, num_layers: i64, batch_first: bool, dropout: f64, train: bool, bidirectional: bool, batch_sizes: impl IntList, dropout_state: Option<T> ) -> (Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn internal_debug_has_internal_overlap(&self) -> i64

pub fn internal_dim_arange(like: &Tensor, dim: i64) -> Tensor

pub fn internal_dimi(&self) -> i64

pub fn internal_dimv(&self) -> i64

pub fn internal_dirichlet_grad( x: &Tensor, alpha: &Tensor, total: &Tensor ) -> Tensor

pub fn internal_dirichlet_grad_out( out: &Tensor, x: &Tensor, alpha: &Tensor, total: &Tensor ) -> Tensor

pub fn internal_efficient_attention_backward<T: Borrow<Tensor>>( grad_out_: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, bias: Option<T>, out: &Tensor, cu_seqlens_q: Option<T>, cu_seqlens_k: Option<T>, max_seqlen_k: i64, max_seqlen_q: i64, logsumexp: &Tensor, dropout_p: f64, philox_seed: &Tensor, philox_offset: &Tensor, custom_mask_type: i64, bias_requires_grad: bool, scale: impl Into<Option<f64>>, num_splits_key: impl Into<Option<i64>> ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_efficientzerotensor( size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn internal_efficientzerotensor_out( out: &Tensor, size: impl IntList ) -> Tensor

pub fn internal_embedding_bag<T: Borrow<Tensor>>( weight: &Tensor, indices: &Tensor, offsets: &Tensor, scale_grad_by_freq: bool, mode: i64, sparse: bool, per_sample_weights: Option<T>, include_last_offset: bool, padding_idx: i64 ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_embedding_bag_backward<T: Borrow<Tensor>>( grad: &Tensor, indices: &Tensor, offsets: &Tensor, offset2bag: &Tensor, bag_size: &Tensor, maximum_indices: &Tensor, num_weights: i64, scale_grad_by_freq: bool, mode: i64, sparse: bool, per_sample_weights: Option<T>, padding_idx: i64 ) -> Tensor

pub fn internal_embedding_bag_dense_backward<T: Borrow<Tensor>>( grad: &Tensor, indices: &Tensor, offset2bag: &Tensor, bag_size: &Tensor, maximum_indices: &Tensor, num_weights: i64, scale_grad_by_freq: bool, mode: i64, per_sample_weights: Option<T>, padding_idx: i64 ) -> Tensor

pub fn internal_embedding_bag_dense_backward_out<T: Borrow<Tensor>>( out: &Tensor, grad: &Tensor, indices: &Tensor, offset2bag: &Tensor, bag_size: &Tensor, maximum_indices: &Tensor, num_weights: i64, scale_grad_by_freq: bool, mode: i64, per_sample_weights: Option<T>, padding_idx: i64 ) -> Tensor

pub fn internal_embedding_bag_forward_only<T: Borrow<Tensor>>( weight: &Tensor, indices: &Tensor, offsets: &Tensor, scale_grad_by_freq: bool, mode: i64, sparse: bool, per_sample_weights: Option<T>, include_last_offset: bool, padding_idx: i64 ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_embedding_bag_forward_only_out<T: Borrow<Tensor>>( out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, weight: &Tensor, indices: &Tensor, offsets: &Tensor, scale_grad_by_freq: bool, mode: i64, sparse: bool, per_sample_weights: Option<T>, include_last_offset: bool, padding_idx: i64 ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_embedding_bag_out<T: Borrow<Tensor>>( out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, weight: &Tensor, indices: &Tensor, offsets: &Tensor, scale_grad_by_freq: bool, mode: i64, sparse: bool, per_sample_weights: Option<T>, include_last_offset: bool, padding_idx: i64 ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_embedding_bag_per_sample_weights_backward( grad: &Tensor, weight: &Tensor, indices: &Tensor, offsets: &Tensor, offset2bag: &Tensor, mode: i64, padding_idx: i64 ) -> Tensor

pub fn internal_embedding_bag_per_sample_weights_backward_out( out: &Tensor, grad: &Tensor, weight: &Tensor, indices: &Tensor, offsets: &Tensor, offset2bag: &Tensor, mode: i64, padding_idx: i64 ) -> Tensor

pub fn internal_embedding_bag_sparse_backward<T: Borrow<Tensor>>( grad: &Tensor, indices: &Tensor, offsets: &Tensor, offset2bag: &Tensor, bag_size: &Tensor, num_weights: i64, scale_grad_by_freq: bool, mode: i64, per_sample_weights: Option<T>, padding_idx: i64 ) -> Tensor

pub fn internal_empty_affine_quantized( size: impl IntList, options: (Kind, Device), scale: f64, zero_point: i64 ) -> Tensor

pub fn internal_empty_affine_quantized_out( out: &Tensor, size: impl IntList, scale: f64, zero_point: i64 ) -> Tensor

pub fn internal_empty_per_channel_affine_quantized( size: impl IntList, scales: &Tensor, zero_points: &Tensor, axis: i64, options: (Kind, Device) ) -> Tensor

pub fn internal_empty_per_channel_affine_quantized_out( out: &Tensor, size: impl IntList, scales: &Tensor, zero_points: &Tensor, axis: i64 ) -> Tensor

pub fn internal_euclidean_dist(x1: &Tensor, x2: &Tensor) -> Tensor

pub fn internal_euclidean_dist_out( out: &Tensor, x1: &Tensor, x2: &Tensor ) -> Tensor

pub fn internal_fake_quantize_learnable_per_channel_affine( &self, scale: &Tensor, zero_point: &Tensor, axis: i64, quant_min: i64, quant_max: i64, grad_factor: f64 ) -> Tensor

pub fn internal_fake_quantize_learnable_per_channel_affine_backward( &self, grad: &Tensor, scale: &Tensor, zero_point: &Tensor, axis: i64, quant_min: i64, quant_max: i64, grad_factor: f64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_fake_quantize_learnable_per_channel_affine_out( &self, out: &Tensor, scale: &Tensor, zero_point: &Tensor, axis: i64, quant_min: i64, quant_max: i64, grad_factor: f64 ) -> Tensor

pub fn internal_fake_quantize_learnable_per_tensor_affine( &self, scale: &Tensor, zero_point: &Tensor, quant_min: i64, quant_max: i64, grad_factor: f64 ) -> Tensor

pub fn internal_fake_quantize_learnable_per_tensor_affine_backward( &self, grad: &Tensor, scale: &Tensor, zero_point: &Tensor, quant_min: i64, quant_max: i64, grad_factor: f64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_fake_quantize_learnable_per_tensor_affine_out( &self, out: &Tensor, scale: &Tensor, zero_point: &Tensor, quant_min: i64, quant_max: i64, grad_factor: f64 ) -> Tensor

pub fn internal_fake_quantize_per_tensor_affine_cachemask_tensor_qparams( &self, scale: &Tensor, zero_point: &Tensor, fake_quant_enabled: &Tensor, quant_min: i64, quant_max: i64 ) -> (Tensor, Tensor)

pub fn internal_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out( &self, out0: &Tensor, out1: &Tensor, scale: &Tensor, zero_point: &Tensor, fake_quant_enabled: &Tensor, quant_min: i64, quant_max: i64 ) -> (Tensor, Tensor)

pub fn internal_fft_c2c( &self, dim: impl IntList, normalization: i64, forward: bool ) -> Tensor

pub fn internal_fft_c2c_out( &self, out: &Tensor, dim: impl IntList, normalization: i64, forward: bool ) -> Tensor

pub fn internal_fft_c2r( &self, dim: impl IntList, normalization: i64, last_dim_size: i64 ) -> Tensor

pub fn internal_fft_c2r_out( &self, out: &Tensor, dim: impl IntList, normalization: i64, last_dim_size: i64 ) -> Tensor

pub fn internal_fft_r2c( &self, dim: impl IntList, normalization: i64, onesided: bool ) -> Tensor

pub fn internal_fft_r2c_out( &self, out: &Tensor, dim: impl IntList, normalization: i64, onesided: bool ) -> Tensor

pub fn internal_fill_mem_eff_dropout_mask_( &mut self, dropout_p: f64, seed: i64, offset: i64 ) -> Tensor

pub fn internal_flash_attention_backward( grad_out: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, out: &Tensor, logsumexp: &Tensor, cum_seq_q: &Tensor, cum_seq_k: &Tensor, max_q: i64, max_k: i64, dropout_p: f64, is_causal: bool, philox_seed: &Tensor, philox_offset: &Tensor, scale: impl Into<Option<f64>> ) -> (Tensor, Tensor, Tensor)

pub fn internal_foobar(&self, arg1: bool, arg2: bool, arg3: bool) -> Tensor

pub fn internal_foobar_out( &self, out: &Tensor, arg1: bool, arg2: bool, arg3: bool ) -> Tensor

pub fn internal_functional_assert_async( &self, assert_msg: &str, dep_token: &Tensor ) -> Tensor

pub fn internal_functional_sym_constrain_range<S: Into<Scalar>>( size: S, min: impl Into<Option<i64>>, max: impl Into<Option<i64>>, dep_token: &Tensor ) -> Tensor

pub fn internal_functional_sym_constrain_range_for_size<S: Into<Scalar>>( size: S, min: impl Into<Option<i64>>, max: impl Into<Option<i64>>, dep_token: &Tensor ) -> Tensor

pub fn internal_fused_dropout(&self, p: f64) -> (Tensor, Tensor)

pub fn internal_fused_dropout_out( &self, out0: &Tensor, out1: &Tensor, p: f64 ) -> (Tensor, Tensor)

pub fn internal_fused_moving_avg_obs_fq_helper( &self, observer_on: &Tensor, fake_quant_on: &Tensor, running_min: &Tensor, running_max: &Tensor, scale: &Tensor, zero_point: &Tensor, averaging_const: f64, quant_min: i64, quant_max: i64, ch_axis: i64, per_row_fake_quant: bool, symmetric_quant: bool ) -> (Tensor, Tensor)

pub fn internal_fused_moving_avg_obs_fq_helper_functional( &self, observer_on: &Tensor, fake_quant_on: &Tensor, running_min: &Tensor, running_max: &Tensor, scale: &Tensor, zero_point: &Tensor, averaging_const: f64, quant_min: i64, quant_max: i64, ch_axis: i64, per_row_fake_quant: bool, symmetric_quant: bool ) -> (Tensor, Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn internal_fused_moving_avg_obs_fq_helper_out( &self, out0: &Tensor, out1: &Tensor, observer_on: &Tensor, fake_quant_on: &Tensor, running_min: &Tensor, running_max: &Tensor, scale: &Tensor, zero_point: &Tensor, averaging_const: f64, quant_min: i64, quant_max: i64, ch_axis: i64, per_row_fake_quant: bool, symmetric_quant: bool ) -> (Tensor, Tensor)

pub fn internal_fused_sdp_choice<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, attn_mask: Option<T>, dropout_p: f64, is_causal: bool, scale: impl Into<Option<f64>> ) -> i64

pub fn internal_fw_primal(&self, level: i64) -> Tensor

pub fn internal_fw_primal_copy(&self, level: i64) -> Tensor

pub fn internal_fw_primal_copy_out(&self, out: &Tensor, level: i64) -> Tensor

pub fn internal_gather_sparse_backward( &self, dim: i64, index: &Tensor, grad: &Tensor ) -> Tensor

pub fn internal_grid_sampler_2d_cpu_fallback( &self, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> Tensor

pub fn internal_grid_sampler_2d_cpu_fallback_backward( &self, grad_output: &Tensor, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> (Tensor, Tensor)

pub fn internal_grid_sampler_2d_cpu_fallback_out( &self, out: &Tensor, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> Tensor

pub fn internal_has_compatible_shallow_copy_type(&self, from: &Tensor) -> bool

pub fn internal_has_same_storage_numel(&self, other: &Tensor) -> bool

pub fn internal_histogramdd_bin_edges<T: Borrow<Tensor>>( &self, bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool ) -> Vec<Tensor>

pub fn internal_histogramdd_bin_edges_out<T: Borrow<Tensor>>( &self, out: &[T], bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool )

pub fn internal_histogramdd_from_bin_cts<T: Borrow<Tensor>>( &self, bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool ) -> Tensor

pub fn internal_histogramdd_from_bin_cts_out<T: Borrow<Tensor>>( &self, out: &Tensor, bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool ) -> Tensor

pub fn internal_histogramdd_from_bin_tensors<T: Borrow<Tensor>>( &self, bins: &[T], weight: Option<T>, density: bool ) -> Tensor

pub fn internal_histogramdd_from_bin_tensors_out<T: Borrow<Tensor>>( &self, out: &Tensor, bins: &[T], weight: Option<T>, density: bool ) -> Tensor

pub fn internal_index_put_impl<T: Borrow<Tensor>>( &self, indices: &[Option<T>], values: &Tensor, accumulate: bool, unsafe_: bool ) -> Tensor

pub fn internal_index_put_impl_<T: Borrow<Tensor>>( &mut self, indices: &[Option<T>], values: &Tensor, accumulate: bool, unsafe_: bool ) -> Tensor

pub fn internal_index_put_impl_out<T: Borrow<Tensor>>( &self, out: &Tensor, indices: &[Option<T>], values: &Tensor, accumulate: bool, unsafe_: bool ) -> Tensor

pub fn internal_indices(&self) -> Tensor

pub fn internal_indices_copy(&self) -> Tensor

pub fn internal_indices_copy_out(&self, out: &Tensor) -> Tensor

pub fn internal_int_mm(&self, mat2: &Tensor) -> Tensor

pub fn internal_int_mm_out(&self, out: &Tensor, mat2: &Tensor) -> Tensor

pub fn internal_is_all_true(&self) -> Tensor

pub fn internal_is_any_true(&self) -> Tensor

pub fn internal_is_zerotensor(&self) -> bool

pub fn internal_linalg_check_errors( info: &Tensor, api_name: &str, is_matrix: bool )

pub fn internal_linalg_det(a: &Tensor) -> (Tensor, Tensor, Tensor)

pub fn internal_linalg_det_result( result: &Tensor, lu: &Tensor, pivots: &Tensor, a: &Tensor ) -> (Tensor, Tensor, Tensor)

pub fn internal_linalg_eigh( a: &Tensor, uplo: &str, compute_v: bool ) -> (Tensor, Tensor)

pub fn internal_linalg_eigh_eigenvalues( eigenvalues: &Tensor, eigenvectors: &Tensor, a: &Tensor, uplo: &str, compute_v: bool ) -> (Tensor, Tensor)

pub fn internal_linalg_slogdet(a: &Tensor) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_linalg_slogdet_sign( sign: &Tensor, logabsdet: &Tensor, lu: &Tensor, pivots: &Tensor, a: &Tensor ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_linalg_solve_ex( a: &Tensor, b: &Tensor, left: bool, check_errors: bool ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_linalg_solve_ex_result( result: &Tensor, lu: &Tensor, pivots: &Tensor, info: &Tensor, a: &Tensor, b: &Tensor, left: bool, check_errors: bool ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_linalg_svd( a: &Tensor, full_matrices: bool, compute_uv: bool, driver: &str ) -> (Tensor, Tensor, Tensor)

pub fn internal_linalg_svd_u( u: &Tensor, s: &Tensor, vh: &Tensor, a: &Tensor, full_matrices: bool, compute_uv: bool, driver: &str ) -> (Tensor, Tensor, Tensor)

pub fn internal_log_softmax(&self, dim: i64, half_to_float: bool) -> Tensor

pub fn internal_log_softmax_backward_data( grad_output: &Tensor, output: &Tensor, dim: i64, input_dtype: Kind ) -> Tensor

pub fn internal_log_softmax_backward_data_out( out: &Tensor, grad_output: &Tensor, output: &Tensor, dim: i64, input_dtype: Kind ) -> Tensor

pub fn internal_log_softmax_out( &self, out: &Tensor, dim: i64, half_to_float: bool ) -> Tensor

pub fn internal_logcumsumexp(&self, dim: i64) -> Tensor

pub fn internal_logcumsumexp_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn internal_lstm_mps<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, Tensor, Tensor, Tensor)

pub fn internal_lstm_mps_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, out4: &Tensor, out5: &Tensor, hx: &[T], params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> (Tensor, Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn internal_lu_with_info( &self, pivot: bool, check_errors: bool ) -> (Tensor, Tensor, Tensor)

pub fn internal_make_dep_token(options: (Kind, Device)) -> Tensor

pub fn internal_make_dual( primal: &Tensor, tangent: &Tensor, level: i64 ) -> Tensor

pub fn internal_make_dual_copy( primal: &Tensor, tangent: &Tensor, level: i64 ) -> Tensor

pub fn internal_make_dual_copy_out( out: &Tensor, primal: &Tensor, tangent: &Tensor, level: i64 ) -> Tensor

pub fn internal_make_per_channel_quantized_tensor( &self, scale: &Tensor, zero_point: &Tensor, axis: i64 ) -> Tensor

pub fn internal_make_per_channel_quantized_tensor_out( &self, out: &Tensor, 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_make_per_tensor_quantized_tensor_out( &self, out: &Tensor, scale: f64, zero_point: i64 ) -> Tensor

pub fn internal_masked_scale(&self, mask: &Tensor, scale: f64) -> Tensor

pub fn internal_masked_scale_out( &self, out: &Tensor, mask: &Tensor, scale: f64 ) -> Tensor

pub fn internal_masked_softmax( &self, mask: &Tensor, dim: impl Into<Option<i64>>, mask_type: impl Into<Option<i64>> ) -> Tensor

pub fn internal_masked_softmax_backward( grad_output: &Tensor, output: &Tensor, mask: &Tensor, dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_masked_softmax_backward_out( out: &Tensor, grad_output: &Tensor, output: &Tensor, mask: &Tensor, dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_masked_softmax_out( &self, out: &Tensor, mask: &Tensor, dim: impl Into<Option<i64>>, mask_type: impl Into<Option<i64>> ) -> Tensor

pub fn internal_mkldnn_reshape(&self, shape: impl IntList) -> Tensor

pub fn internal_mkldnn_reshape_out( &self, out: &Tensor, shape: impl IntList ) -> 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_mkldnn_transpose_out( &self, out: &Tensor, dim0: i64, dim1: i64 ) -> Tensor

pub fn internal_mps_convolution<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn internal_mps_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn internal_mps_convolution_transpose( &self, weight: &Tensor, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn internal_mps_convolution_transpose_out( &self, out: &Tensor, weight: &Tensor, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn internal_native_batch_norm_legit<T: Borrow<Tensor>>( &self, weight: Option<T>, bias: Option<T>, running_mean: &Tensor, running_var: &Tensor, training: bool, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_native_batch_norm_legit_functional<T: Borrow<Tensor>>( &self, weight: Option<T>, bias: Option<T>, running_mean: &Tensor, running_var: &Tensor, training: bool, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn internal_native_batch_norm_legit_no_stats<T: Borrow<Tensor>>( &self, weight: Option<T>, bias: Option<T>, training: bool, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_native_batch_norm_legit_no_stats_out<T: Borrow<Tensor>>( &self, out: &Tensor, save_mean: &Tensor, save_invstd: &Tensor, weight: Option<T>, bias: Option<T>, training: bool, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_native_batch_norm_legit_no_training<T: Borrow<Tensor>>( &self, weight: Option<T>, bias: Option<T>, running_mean: &Tensor, running_var: &Tensor, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_native_batch_norm_legit_no_training_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, weight: Option<T>, bias: Option<T>, running_mean: &Tensor, running_var: &Tensor, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_native_batch_norm_legit_out<T: Borrow<Tensor>>( &self, out: &Tensor, save_mean: &Tensor, save_invstd: &Tensor, weight: Option<T>, bias: Option<T>, running_mean: &Tensor, running_var: &Tensor, training: bool, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_native_multi_head_attention<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, embed_dim: i64, num_head: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, mask: Option<T>, need_weights: bool, average_attn_weights: bool, mask_type: impl Into<Option<i64>> ) -> (Tensor, Tensor)

pub fn internal_native_multi_head_attention_out<T: Borrow<Tensor>>( out0: &Tensor, out1: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, embed_dim: i64, num_head: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, mask: Option<T>, need_weights: bool, average_attn_weights: bool, mask_type: impl Into<Option<i64>> ) -> (Tensor, Tensor)

pub fn internal_neg_view(&self) -> Tensor

pub fn internal_neg_view_copy(&self) -> Tensor

pub fn internal_neg_view_copy_out(&self, out: &Tensor) -> Tensor

pub fn internal_nested_from_padded( padded: &Tensor, cpu_nested_shape_example: &Tensor, fuse_transform_0213: bool ) -> Tensor

pub fn internal_nested_from_padded_and_nested_example( padded: &Tensor, nt_example: &Tensor ) -> Tensor

pub fn internal_nested_from_padded_and_nested_example_out( out: &Tensor, padded: &Tensor, nt_example: &Tensor ) -> Tensor

pub fn internal_nested_from_padded_out( out: &Tensor, padded: &Tensor, cpu_nested_shape_example: &Tensor, fuse_transform_0213: bool ) -> Tensor

pub fn internal_nested_select_backward( &self, grad_output: &Tensor, dim: i64, index: i64 ) -> Tensor

pub fn internal_nested_sum_backward( &self, grad: &Tensor, dim: impl IntListOption, keepdim: bool ) -> Tensor

pub fn internal_nested_view_from_buffer( &self, nested_size: &Tensor, nested_strides: &Tensor, offsets: &Tensor ) -> Tensor

pub fn internal_nested_view_from_buffer_copy( &self, nested_size: &Tensor, nested_strides: &Tensor, offsets: &Tensor ) -> Tensor

pub fn internal_nested_view_from_buffer_copy_out( &self, out: &Tensor, nested_size: &Tensor, nested_strides: &Tensor, offsets: &Tensor ) -> Tensor

pub fn internal_new_zeros_with_same_feature_meta( &self, other: &Tensor, self_num_batch_dims: i64 ) -> Tensor

pub fn internal_new_zeros_with_same_feature_meta_out( &self, out: &Tensor, other: &Tensor, self_num_batch_dims: i64 ) -> Tensor

pub fn internal_nnpack_available() -> bool

pub fn internal_nnpack_spatial_convolution<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList ) -> Tensor

pub fn internal_nnpack_spatial_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList ) -> Tensor

pub fn internal_nnz(&self) -> i64

pub fn internal_pack_padded_sequence( &self, lengths: &Tensor, batch_first: bool ) -> (Tensor, Tensor)

pub fn internal_pack_padded_sequence_backward( grad: &Tensor, input_size: impl IntList, batch_sizes: &Tensor, batch_first: bool ) -> Tensor

pub fn internal_pack_padded_sequence_out( &self, out0: &Tensor, out1: &Tensor, lengths: &Tensor, batch_first: bool ) -> (Tensor, Tensor)

pub fn internal_pad_circular(&self, pad: impl IntList) -> Tensor

pub fn internal_pad_enum( &self, pad: impl IntList, mode: i64, value: impl Into<Option<f64>> ) -> 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_pdist_backward_out( &self, out: &Tensor, grad: &Tensor, p: f64, pdist: &Tensor ) -> Tensor

pub fn internal_pin_memory(&self, device: Device) -> Tensor

pub fn internal_pin_memory_out(&self, out: &Tensor, device: Device) -> Tensor

pub fn internal_prelu_kernel(&self, weight: &Tensor) -> Tensor

pub fn internal_prelu_kernel_backward( &self, grad_output: &Tensor, weight: &Tensor ) -> (Tensor, Tensor)

pub fn internal_propagate_xla_data(&self, output: &Tensor)

pub fn internal_remove_batch_dim( &self, level: i64, batch_size: i64, out_dim: i64 ) -> Tensor

pub fn internal_reshape_alias( &self, size: impl IntList, stride: impl IntList ) -> Tensor

pub fn internal_reshape_alias_copy( &self, size: impl IntList, stride: impl IntList ) -> Tensor

pub fn internal_reshape_alias_copy_out( &self, out: &Tensor, size: impl IntList, stride: impl IntList ) -> Tensor

pub fn internal_reshape_copy(&self, size: impl IntList) -> Tensor

pub fn internal_reshape_from_tensor(&self, shape: &Tensor) -> Tensor

pub fn internal_resize_output( &self, size: impl IntList, device: Device ) -> Tensor

pub fn internal_resize_output_( &mut self, size: impl IntList, device: Device ) -> Tensor

pub fn internal_resize_output_out( &self, out: &Tensor, size: impl IntList, device: Device ) -> Tensor

pub fn internal_rowwise_prune( weight: &Tensor, mask: &Tensor, compressed_indices_dtype: Kind ) -> (Tensor, Tensor)

pub fn internal_sample_dirichlet(&self) -> Tensor

pub fn internal_sample_dirichlet_out(&self, out: &Tensor) -> Tensor

pub fn internal_saturate_weight_to_fp16(weight: &Tensor) -> Tensor

pub fn internal_scaled_dot_product_attention_math<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, attn_mask: Option<T>, dropout_p: f64, is_causal: bool, dropout_mask: Option<T>, scale: impl Into<Option<f64>> ) -> (Tensor, Tensor)

pub fn internal_scaled_dot_product_efficient_attention<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, attn_bias: Option<T>, compute_log_sumexp: bool, dropout_p: f64, is_causal: bool, scale: impl Into<Option<f64>> ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn internal_scaled_dot_product_flash_attention_backward( grad_out: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, out: &Tensor, logsumexp: &Tensor, cum_seq_q: &Tensor, cum_seq_k: &Tensor, max_q: i64, max_k: i64, dropout_p: f64, is_causal: bool, philox_seed: &Tensor, philox_offset: &Tensor, scale: impl Into<Option<f64>> ) -> (Tensor, Tensor, Tensor)

pub fn internal_scaled_mm<T: Borrow<Tensor>>( &self, mat2: &Tensor, bias: Option<T>, out_dtype: impl Into<Option<Kind>>, scale_a: Option<T>, scale_b: Option<T>, scale_result: Option<T> ) -> (Tensor, Tensor)

pub fn internal_scaled_mm_out<T: Borrow<Tensor>>( &self, out: &Tensor, out_amax: &Tensor, mat2: &Tensor, bias: Option<T>, out_dtype: impl Into<Option<Kind>>, scale_a: Option<T>, scale_b: Option<T>, scale_result: Option<T> ) -> (Tensor, Tensor)

pub fn internal_scatter_reduce( &self, dim: i64, index: &Tensor, src: &Tensor, reduce: &str, include_self: bool ) -> Tensor

pub fn internal_scatter_reduce_( &mut self, dim: i64, index: &Tensor, src: &Tensor, reduce: &str, include_self: bool ) -> Tensor

pub fn internal_scatter_reduce_two_out( &self, out: &Tensor, dim: i64, index: &Tensor, src: &Tensor, reduce: &str, include_self: bool ) -> Tensor

pub fn internal_segment_reduce_backward<T: Borrow<Tensor>, S: Into<Scalar>>( grad: &Tensor, output: &Tensor, data: &Tensor, reduce: &str, lengths: Option<T>, offsets: Option<T>, axis: i64, initial: S ) -> Tensor

pub fn internal_segment_reduce_backward_out<T: Borrow<Tensor>, S: Into<Scalar>>( out: &Tensor, grad: &Tensor, output: &Tensor, data: &Tensor, reduce: &str, lengths: Option<T>, offsets: Option<T>, axis: i64, initial: S ) -> Tensor

pub fn internal_shape_as_tensor(&self) -> Tensor

pub fn internal_slow_conv2d_backward( &self, grad_input: &Tensor, grad_weight: &Tensor, grad_bias: &Tensor, grad_output: &Tensor, weight: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList ) -> (Tensor, Tensor, Tensor)

pub fn internal_sobol_engine_draw( quasi: &Tensor, n: i64, sobolstate: &Tensor, dimension: i64, num_generated: i64, dtype: impl Into<Option<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( grad_output: &Tensor, output: &Tensor, dim: i64, input_dtype: Kind ) -> Tensor

pub fn internal_softmax_backward_data_out( grad_input: &Tensor, grad_output: &Tensor, output: &Tensor, dim: i64, input_dtype: Kind ) -> Tensor

pub fn internal_softmax_out( &self, out: &Tensor, dim: i64, half_to_float: bool ) -> Tensor

pub fn internal_sparse_addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn internal_sparse_addmm_out( &self, out: &Tensor, mat1: &Tensor, mat2: &Tensor ) -> Tensor

pub fn internal_sparse_broadcast_to(&self, size: impl IntList) -> Tensor

pub fn internal_sparse_broadcast_to_copy(&self, size: impl IntList) -> Tensor

pub fn internal_sparse_broadcast_to_copy_out( &self, out: &Tensor, size: impl IntList ) -> Tensor

pub fn internal_sparse_bsc_tensor_unsafe( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn internal_sparse_bsr_tensor_unsafe( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn internal_sparse_compressed_tensor_unsafe( compressed_indices: &Tensor, plain_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn internal_sparse_coo_tensor_unsafe( indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device), is_coalesced: bool ) -> Tensor

pub fn internal_sparse_coo_tensor_with_dims( sparse_dim: i64, dense_dim: i64, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn internal_sparse_coo_tensor_with_dims_and_tensors( sparse_dim: i64, dense_dim: i64, size: impl IntList, indices: &Tensor, values: &Tensor, options: (Kind, Device), is_coalesced: bool ) -> Tensor

pub fn internal_sparse_coo_tensor_with_dims_and_tensors_out( out: &Tensor, sparse_dim: i64, dense_dim: i64, size: impl IntList, indices: &Tensor, values: &Tensor, is_coalesced: bool ) -> Tensor

pub fn internal_sparse_coo_tensor_with_dims_out( out: &Tensor, sparse_dim: i64, dense_dim: i64, size: impl IntList ) -> Tensor

pub fn internal_sparse_csc_tensor_unsafe( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn internal_sparse_csr_prod( &self, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn internal_sparse_csr_prod_dim_dtype_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn internal_sparse_csr_sum( &self, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn internal_sparse_csr_sum_dim_dtype_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn internal_sparse_csr_tensor_unsafe( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn internal_sparse_log_softmax( &self, dim: i64, half_to_float: bool ) -> Tensor

pub fn internal_sparse_log_softmax_backward_data( &self, grad_output: &Tensor, output: &Tensor, dim: i64 ) -> Tensor

pub fn internal_sparse_log_softmax_backward_data_out( &self, out: &Tensor, grad_output: &Tensor, output: &Tensor, dim: i64 ) -> Tensor

pub fn internal_sparse_log_softmax_int( &self, dim: i64, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn internal_sparse_log_softmax_out( &self, out: &Tensor, dim: i64, half_to_float: bool ) -> Tensor

pub fn internal_sparse_mask_projection( &self, mask: &Tensor, accumulate_matches: bool ) -> Tensor

pub fn internal_sparse_mask_projection_out( &self, out: &Tensor, mask: &Tensor, accumulate_matches: bool ) -> Tensor

pub fn internal_sparse_mm(sparse: &Tensor, dense: &Tensor) -> Tensor

pub fn internal_sparse_mm_reduce( sparse: &Tensor, dense: &Tensor, reduce: &str ) -> Tensor

pub fn internal_sparse_mm_reduce_impl( &self, other: &Tensor, reduce: &str ) -> (Tensor, Tensor)

pub fn internal_sparse_semi_structured_linear<T: Borrow<Tensor>>( &self, weight: &Tensor, meta: &Tensor, bias: Option<T>, activation: &str ) -> Tensor

pub fn internal_sparse_softmax(&self, dim: i64, half_to_float: bool) -> Tensor

pub fn internal_sparse_softmax_backward_data( &self, grad_output: &Tensor, output: &Tensor, dim: i64 ) -> Tensor

pub fn internal_sparse_softmax_backward_data_out( &self, out: &Tensor, grad_output: &Tensor, output: &Tensor, dim: i64 ) -> Tensor

pub fn internal_sparse_softmax_int( &self, dim: i64, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn internal_sparse_softmax_out( &self, out: &Tensor, dim: i64, half_to_float: bool ) -> Tensor

pub fn internal_sparse_sparse_matmul(&self, other: &Tensor) -> Tensor

pub fn internal_sparse_sparse_matmul_out( &self, out: &Tensor, other: &Tensor ) -> Tensor

pub fn internal_sparse_sum(&self) -> Tensor

pub fn internal_sparse_sum_backward( &self, grad: &Tensor, dim: impl IntList ) -> Tensor

pub fn internal_sparse_sum_backward_out( &self, out: &Tensor, grad: &Tensor, dim: impl IntList ) -> Tensor

pub fn internal_sparse_sum_dim(&self, dim: impl IntList) -> Tensor

pub fn internal_sparse_sum_dim_dtype( &self, dim: impl IntList, dtype: Kind ) -> Tensor

pub fn internal_sparse_sum_dim_out( &self, out: &Tensor, dim: impl IntList ) -> Tensor

pub fn internal_sparse_sum_dtype(&self, dtype: Kind) -> Tensor

pub fn internal_spdiags( diagonals: &Tensor, offsets: &Tensor, shape: impl IntList, layout: Option<Layout> ) -> Tensor

pub fn internal_spdiags_out( out: &Tensor, diagonals: &Tensor, offsets: &Tensor, shape: impl IntList, layout: Option<Layout> ) -> Tensor

pub fn internal_stack<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor

pub fn internal_stack_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T], dim: i64 ) -> Tensor

pub fn internal_standard_gamma(&self) -> Tensor

pub fn internal_standard_gamma_grad(&self, output: &Tensor) -> Tensor

pub fn internal_standard_gamma_grad_out( &self, out: &Tensor, output: &Tensor ) -> Tensor

pub fn internal_standard_gamma_out(&self, out: &Tensor) -> Tensor

pub fn internal_test_ambiguous_defaults( dummy: &Tensor, a: i64, b: i64 ) -> Tensor

pub fn internal_test_ambiguous_defaults_b( dummy: &Tensor, a: i64, b: &str ) -> Tensor

pub fn internal_test_autograd_multiple_dispatch(&self) -> Tensor

pub fn internal_test_autograd_multiple_dispatch_fullcoverage_out( &self, out: &Tensor ) -> Tensor

pub fn internal_test_autograd_multiple_dispatch_ntonly(&self, b: bool) -> Tensor

pub fn internal_test_autograd_multiple_dispatch_view(&self) -> Tensor

pub fn internal_test_autograd_multiple_dispatch_view_copy(&self) -> Tensor

pub fn internal_test_autograd_multiple_dispatch_view_copy_out( &self, out: &Tensor ) -> Tensor

pub fn internal_test_check_tensor(&self) -> Tensor

pub fn internal_test_functorch_fallback(&self, other: &Tensor) -> Tensor

pub fn internal_test_functorch_fallback_out( &self, out: &Tensor, other: &Tensor ) -> Tensor

pub fn internal_test_optional_filled_intlist( values: &Tensor, addends: impl IntListOption ) -> Tensor

pub fn internal_test_optional_filled_intlist_out( out: &Tensor, values: &Tensor, addends: impl IntListOption ) -> Tensor

pub fn internal_test_optional_floatlist( values: &Tensor, addends: impl DoubleList ) -> Tensor

pub fn internal_test_optional_floatlist_out( out: &Tensor, values: &Tensor, addends: impl DoubleList ) -> Tensor

pub fn internal_test_optional_intlist( values: &Tensor, addends: impl IntListOption ) -> Tensor

pub fn internal_test_optional_intlist_out( out: &Tensor, values: &Tensor, addends: impl IntListOption ) -> Tensor

pub fn internal_test_serialization_subcmul(&self, other: &Tensor) -> Tensor

pub fn internal_test_string_default(dummy: &Tensor, a: &str, b: &str) -> Tensor

pub fn internal_test_warn_in_autograd(&self) -> Tensor

pub fn internal_test_warn_in_autograd_out(&self, out: &Tensor) -> Tensor

pub fn internal_to_copy( &self, options: (Kind, Device), non_blocking: bool ) -> Tensor

pub fn internal_to_copy_out(&self, out: &Tensor, non_blocking: bool) -> Tensor

pub fn internal_to_cpu<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn internal_to_dense( &self, dtype: impl Into<Option<Kind>>, masked_grad: bool ) -> Tensor

pub fn internal_to_dense_out( &self, out: &Tensor, dtype: impl Into<Option<Kind>>, masked_grad: bool ) -> Tensor

pub fn internal_to_sparse( &self, layout: Option<Layout>, blocksize: impl IntListOption, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_bsc( &self, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_bsc_out( &self, out: &Tensor, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_bsr( &self, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_bsr_out( &self, out: &Tensor, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_csc( &self, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_csc_out( &self, out: &Tensor, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_csr( &self, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_csr_out( &self, out: &Tensor, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_out( &self, out: &Tensor, layout: Option<Layout>, blocksize: impl IntListOption, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn internal_to_sparse_semi_structured(dense: &Tensor) -> (Tensor, Tensor)

pub fn internal_to_sparse_sparse_dim(&self, sparse_dim: i64) -> Tensor

pub fn internal_to_sparse_sparse_dim_out( &self, out: &Tensor, sparse_dim: i64 ) -> Tensor

pub fn internal_transform_bias_rescale_qkv( qkv: &Tensor, qkv_bias: &Tensor, num_heads: i64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_transform_bias_rescale_qkv_out( out0: &Tensor, out1: &Tensor, out2: &Tensor, qkv: &Tensor, qkv_bias: &Tensor, num_heads: i64 ) -> (Tensor, Tensor, Tensor)

pub fn internal_transformer_encoder_layer_fwd<T: Borrow<Tensor>>( src: &Tensor, embed_dim: i64, num_heads: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, use_gelu: bool, norm_first: bool, eps: f64, norm_weight_1: &Tensor, norm_bias_1: &Tensor, norm_weight_2: &Tensor, norm_bias_2: &Tensor, ffn_weight_1: &Tensor, ffn_bias_1: &Tensor, ffn_weight_2: &Tensor, ffn_bias_2: &Tensor, mask: Option<T>, mask_type: impl Into<Option<i64>> ) -> Tensor

pub fn internal_transformer_encoder_layer_fwd_out<T: Borrow<Tensor>>( out: &Tensor, src: &Tensor, embed_dim: i64, num_heads: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, use_gelu: bool, norm_first: bool, eps: f64, norm_weight_1: &Tensor, norm_bias_1: &Tensor, norm_weight_2: &Tensor, norm_bias_2: &Tensor, ffn_weight_1: &Tensor, ffn_bias_1: &Tensor, ffn_weight_2: &Tensor, ffn_bias_2: &Tensor, mask: Option<T>, mask_type: impl Into<Option<i64>> ) -> Tensor

pub fn internal_trilinear( i1: &Tensor, i2: &Tensor, i3: &Tensor, expand1: impl IntList, expand2: impl IntList, expand3: impl IntList, sumdim: impl IntList, unroll_dim: i64 ) -> Tensor

pub fn internal_trilinear_out( out: &Tensor, i1: &Tensor, i2: &Tensor, i3: &Tensor, expand1: impl IntList, expand2: impl IntList, expand3: impl IntList, sumdim: impl IntList, unroll_dim: i64 ) -> Tensor

pub fn internal_triton_multi_head_attention<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, embed_dim: i64, num_head: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, mask: Option<T> ) -> Tensor

pub fn internal_triton_multi_head_attention_out<T: Borrow<Tensor>>( out: &Tensor, query: &Tensor, key: &Tensor, value: &Tensor, embed_dim: i64, num_head: i64, qkv_weight: &Tensor, qkv_bias: &Tensor, proj_weight: &Tensor, proj_bias: &Tensor, mask: Option<T> ) -> Tensor

pub fn internal_triton_scaled_dot_attention( q: &Tensor, k: &Tensor, v: &Tensor, dropout_p: f64 ) -> Tensor

pub fn internal_triton_scaled_dot_attention_out( out: &Tensor, q: &Tensor, k: &Tensor, v: &Tensor, dropout_p: f64 ) -> 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_unique2_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, sorted: bool, return_inverse: bool, return_counts: bool ) -> (Tensor, Tensor, Tensor)

pub fn internal_unique_out( &self, out0: &Tensor, out1: &Tensor, sorted: bool, return_inverse: bool ) -> (Tensor, Tensor)

pub fn internal_unpack_dual(dual: &Tensor, level: i64) -> (Tensor, Tensor)

pub fn internal_unsafe_index<T: Borrow<Tensor>>( &self, indices: &[Option<T>] ) -> Tensor

pub fn internal_unsafe_index_put<T: Borrow<Tensor>>( &self, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Tensor

pub fn internal_unsafe_view(&self, size: impl IntList) -> Tensor

pub fn internal_unsafe_view_out( &self, out: &Tensor, size: impl IntList ) -> Tensor

pub fn internal_upsample_bicubic2d_aa( &self, output_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_bicubic2d_aa_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_bicubic2d_aa_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_bicubic2d_aa_out( &self, out: &Tensor, output_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_bicubic2d_aa_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Tensor

pub fn internal_upsample_bilinear2d_aa( &self, output_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_bilinear2d_aa_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_bilinear2d_aa_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_bilinear2d_aa_out( &self, out: &Tensor, output_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_bilinear2d_aa_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Tensor

pub fn internal_upsample_nearest_exact1d( &self, output_size: impl IntList, scales: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact1d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact1d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact1d_out( &self, out: &Tensor, output_size: impl IntList, scales: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact1d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Tensor

pub fn internal_upsample_nearest_exact2d( &self, output_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact2d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact2d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact2d_out( &self, out: &Tensor, output_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact2d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Tensor

pub fn internal_upsample_nearest_exact3d( &self, output_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact3d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact3d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact3d_out( &self, out: &Tensor, output_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn internal_upsample_nearest_exact3d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Tensor

pub fn internal_use_cudnn_ctc_loss( log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, blank: i64 ) -> bool

pub fn internal_use_cudnn_ctc_loss_tensor( log_probs: &Tensor, targets: &Tensor, input_lengths: &Tensor, target_lengths: &Tensor, blank: i64 ) -> bool

pub fn internal_use_cudnn_rnn_flatten_weight() -> bool

pub fn internal_validate_compressed_sparse_indices( is_crow: bool, compressed_idx: &Tensor, plain_idx: &Tensor, cdim: i64, dim: i64, nnz: i64 )

pub fn internal_validate_sparse_bsc_tensor_args( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList )

pub fn internal_validate_sparse_bsr_tensor_args( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList )

pub fn internal_validate_sparse_compressed_tensor_args( compressed_indices: &Tensor, plain_indices: &Tensor, values: &Tensor, size: impl IntList, layout: Layout )

pub fn internal_validate_sparse_csc_tensor_args( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList )

pub fn internal_validate_sparse_csr_tensor_args( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList )

pub fn internal_values(&self) -> Tensor

pub fn internal_values_copy(&self) -> Tensor

pub fn internal_values_copy_out(&self, out: &Tensor) -> Tensor

pub fn internal_version(&self) -> i64

pub fn internal_weight_norm(v: &Tensor, g: &Tensor, dim: i64) -> 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 internal_weight_norm_interface( v: &Tensor, g: &Tensor, dim: i64 ) -> (Tensor, Tensor)

pub fn internal_weight_norm_interface_backward( grad_w: &Tensor, saved_v: &Tensor, saved_g: &Tensor, saved_norms: &Tensor, dim: i64 ) -> (Tensor, Tensor)

pub fn internal_weight_norm_interface_backward_out( out0: &Tensor, out1: &Tensor, grad_w: &Tensor, saved_v: &Tensor, saved_g: &Tensor, saved_norms: &Tensor, dim: i64 ) -> (Tensor, Tensor)

pub fn internal_weight_norm_interface_out( out0: &Tensor, out1: &Tensor, v: &Tensor, g: &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: impl IntList) -> Tensor

pub fn adaptive_avg_pool2d(&self, output_size: impl IntList) -> Tensor

pub fn adaptive_avg_pool2d_out( &self, out: &Tensor, output_size: impl IntList ) -> Tensor

pub fn adaptive_avg_pool3d(&self, output_size: impl IntList) -> Tensor

pub fn adaptive_avg_pool3d_backward( &self, grad_input: &Tensor, grad_output: &Tensor ) -> Tensor

pub fn adaptive_avg_pool3d_out( &self, out: &Tensor, output_size: impl IntList ) -> Tensor

pub fn adaptive_max_pool1d(&self, output_size: impl IntList) -> (Tensor, Tensor)

pub fn adaptive_max_pool2d(&self, output_size: impl IntList) -> (Tensor, Tensor)

pub fn adaptive_max_pool2d_backward( &self, grad_output: &Tensor, indices: &Tensor ) -> Tensor

pub fn adaptive_max_pool2d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, indices: &Tensor ) -> Tensor

pub fn adaptive_max_pool2d_out( &self, out: &Tensor, indices: &Tensor, output_size: impl IntList ) -> (Tensor, Tensor)

pub fn adaptive_max_pool3d(&self, output_size: impl IntList) -> (Tensor, Tensor)

pub fn adaptive_max_pool3d_backward( &self, grad_output: &Tensor, indices: &Tensor ) -> Tensor

pub fn adaptive_max_pool3d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, indices: &Tensor ) -> Tensor

pub fn adaptive_max_pool3d_out( &self, out: &Tensor, indices: &Tensor, output_size: impl IntList ) -> (Tensor, Tensor)

pub fn g_add(&self, other: &Tensor) -> Tensor

pub fn g_add_(&mut self, other: &Tensor) -> Tensor

pub fn add_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn g_add_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_add_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn add_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn addbmm(&self, batch1: &Tensor, batch2: &Tensor) -> Tensor

pub fn addbmm_(&mut self, batch1: &Tensor, batch2: &Tensor) -> Tensor

pub fn addbmm_out( &self, out: &Tensor, batch1: &Tensor, batch2: &Tensor ) -> Tensor

pub fn addcdiv(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

pub fn addcdiv_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

pub fn addcdiv_out( &self, out: &Tensor, tensor1: &Tensor, tensor2: &Tensor ) -> Tensor

pub fn addcmul(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

pub fn addcmul_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

pub fn addcmul_out( &self, out: &Tensor, tensor1: &Tensor, tensor2: &Tensor ) -> Tensor

pub fn addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn addmm_(&mut self, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn addmm_out(&self, out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn addmv(&self, mat: &Tensor, vec: &Tensor) -> Tensor

pub fn addmv_(&mut self, mat: &Tensor, vec: &Tensor) -> Tensor

pub fn addmv_out(&self, out: &Tensor, mat: &Tensor, vec: &Tensor) -> Tensor

pub fn addr(&self, vec1: &Tensor, vec2: &Tensor) -> Tensor

pub fn addr_(&mut self, vec1: &Tensor, vec2: &Tensor) -> Tensor

pub fn addr_out(&self, out: &Tensor, vec1: &Tensor, vec2: &Tensor) -> Tensor

pub fn adjoint(&self) -> Tensor

pub fn affine_grid_generator( theta: &Tensor, size: impl IntList, align_corners: bool ) -> Tensor

pub fn affine_grid_generator_backward( grad: &Tensor, size: impl IntList, align_corners: bool ) -> Tensor

pub fn affine_grid_generator_out( out: &Tensor, theta: &Tensor, size: impl IntList, align_corners: bool ) -> Tensor

pub fn alias(&self) -> Tensor

pub fn alias_copy(&self) -> Tensor

pub fn alias_copy_out(&self, out: &Tensor) -> Tensor

pub fn align_as(&self, other: &Tensor) -> Tensor

pub fn align_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn all(&self) -> Tensor

pub fn all_all_out(&self, out: &Tensor) -> Tensor

pub fn all_dim(&self, dim: i64, keepdim: bool) -> Tensor

pub fn all_out(&self, out: &Tensor, dim: i64, keepdim: bool) -> Tensor

pub fn allclose( &self, other: &Tensor, rtol: f64, atol: f64, equal_nan: bool ) -> bool

pub fn alpha_dropout(&self, p: f64, train: bool) -> Tensor

pub fn alpha_dropout_(&mut self, p: f64, train: bool) -> Tensor

pub fn amax(&self, dim: impl IntList, keepdim: bool) -> Tensor

pub fn amax_out(&self, out: &Tensor, dim: impl IntList, keepdim: bool) -> Tensor

pub fn amin(&self, dim: impl IntList, keepdim: bool) -> Tensor

pub fn amin_out(&self, out: &Tensor, dim: impl IntList, keepdim: bool) -> Tensor

pub fn aminmax( &self, dim: impl Into<Option<i64>>, keepdim: bool ) -> (Tensor, Tensor)

pub fn aminmax_out( &self, min: &Tensor, max: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool ) -> (Tensor, Tensor)

pub fn angle(&self) -> Tensor

pub fn angle_out(&self, out: &Tensor) -> Tensor

pub fn any(&self) -> Tensor

pub fn any_all_out(&self, out: &Tensor) -> Tensor

pub fn any_dim(&self, dim: i64, keepdim: bool) -> Tensor

pub fn any_out(&self, out: &Tensor, dim: i64, keepdim: bool) -> Tensor

pub fn arange<S: Into<Scalar>>(end: S, options: (Kind, Device)) -> Tensor

pub fn arange_start<S: Into<Scalar>>( start: S, end: S, options: (Kind, Device) ) -> Tensor

pub fn arange_start_step<S: Into<Scalar>>( start: S, end: S, step: S, options: (Kind, Device) ) -> Tensor

pub fn arccos(&self) -> Tensor

pub fn arccos_(&mut self) -> Tensor

pub fn arccos_out(&self, out: &Tensor) -> Tensor

pub fn arccosh(&self) -> Tensor

pub fn arccosh_(&mut self) -> Tensor

pub fn arccosh_out(&self, out: &Tensor) -> Tensor

pub fn arcsin(&self) -> Tensor

pub fn arcsin_(&mut self) -> Tensor

pub fn arcsin_out(&self, out: &Tensor) -> Tensor

pub fn arcsinh(&self) -> Tensor

pub fn arcsinh_(&mut self) -> Tensor

pub fn arcsinh_out(&self, out: &Tensor) -> Tensor

pub fn arctan(&self) -> Tensor

pub fn arctan2(&self, other: &Tensor) -> Tensor

pub fn arctan2_(&mut self, other: &Tensor) -> Tensor

pub fn arctan2_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn arctan_(&mut self) -> Tensor

pub fn arctan_out(&self, out: &Tensor) -> Tensor

pub fn arctanh(&self) -> Tensor

pub fn arctanh_(&mut self) -> Tensor

pub fn arctanh_out(&self, out: &Tensor) -> Tensor

pub fn argmax(&self, dim: impl Into<Option<i64>>, keepdim: bool) -> Tensor

pub fn argmax_out( &self, out: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool ) -> Tensor

pub fn argmin(&self, dim: impl Into<Option<i64>>, keepdim: bool) -> Tensor

pub fn argmin_out( &self, out: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool ) -> Tensor

pub fn argsort(&self, dim: i64, descending: bool) -> Tensor

pub fn argsort_stable(&self, stable: bool, dim: i64, descending: bool) -> Tensor

pub fn argsort_stable_out( &self, out: &Tensor, stable: bool, dim: i64, descending: bool ) -> Tensor

pub fn argwhere(&self) -> Tensor

pub fn as_strided( &self, size: impl IntList, stride: impl IntList, storage_offset: impl Into<Option<i64>> ) -> Tensor

pub fn as_strided_( &mut self, size: impl IntList, stride: impl IntList, storage_offset: impl Into<Option<i64>> ) -> Tensor

pub fn as_strided_copy( &self, size: impl IntList, stride: impl IntList, storage_offset: impl Into<Option<i64>> ) -> Tensor

pub fn as_strided_copy_out( &self, out: &Tensor, size: impl IntList, stride: impl IntList, storage_offset: impl Into<Option<i64>> ) -> Tensor

pub fn as_strided_scatter( &self, src: &Tensor, size: impl IntList, stride: impl IntList, storage_offset: impl Into<Option<i64>> ) -> Tensor

pub fn as_strided_scatter_out( &self, out: &Tensor, src: &Tensor, size: impl IntList, stride: impl IntList, storage_offset: impl Into<Option<i64>> ) -> Tensor

pub fn asin(&self) -> Tensor

pub fn asin_(&mut self) -> Tensor

pub fn asin_out(&self, out: &Tensor) -> Tensor

pub fn asinh(&self) -> Tensor

pub fn asinh_(&mut self) -> Tensor

pub fn asinh_out(&self, out: &Tensor) -> Tensor

pub fn atan(&self) -> Tensor

pub fn atan2(&self, other: &Tensor) -> Tensor

pub fn atan2_(&mut self, other: &Tensor) -> Tensor

pub fn atan2_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn atan_(&mut self) -> Tensor

pub fn atan_out(&self, out: &Tensor) -> Tensor

pub fn atanh(&self) -> Tensor

pub fn atanh_(&mut self) -> Tensor

pub fn atanh_out(&self, out: &Tensor) -> Tensor

pub fn atleast_1d(&self) -> Tensor

pub fn atleast_1d_sequence<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn atleast_2d(&self) -> Tensor

pub fn atleast_2d_sequence<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn atleast_3d(&self) -> Tensor

pub fn atleast_3d_sequence<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn avg_pool1d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool ) -> Tensor

pub fn avg_pool2d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, 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: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Tensor

pub fn avg_pool2d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Tensor

pub fn avg_pool2d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Tensor

pub fn avg_pool3d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, 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: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Tensor

pub fn avg_pool3d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Tensor

pub fn avg_pool3d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, ceil_mode: bool, count_include_pad: bool, divisor_override: impl Into<Option<i64>> ) -> Tensor

pub fn baddbmm<S: Into<Scalar>>( &self, batch1: &Tensor, batch2: &Tensor, beta: S, alpha: S ) -> Tensor

pub fn baddbmm_(&mut self, batch1: &Tensor, batch2: &Tensor) -> Tensor

pub fn baddbmm_out( &self, out: &Tensor, batch1: &Tensor, batch2: &Tensor ) -> Tensor

pub fn bartlett_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn bartlett_window_out(out: &Tensor, window_length: i64) -> Tensor

pub fn bartlett_window_periodic( window_length: i64, periodic: bool, options: (Kind, Device) ) -> Tensor

pub fn bartlett_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> 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>, sum_dy: &Tensor, sum_dy_xmu: &Tensor, count: &Tensor ) -> Tensor

pub fn batch_norm_backward_elemt_out<T: Borrow<Tensor>>( &self, out: &Tensor, grad_out: &Tensor, mean: &Tensor, invstd: &Tensor, weight: Option<T>, sum_dy: &Tensor, sum_dy_xmu: &Tensor, count: &Tensor ) -> Tensor

pub fn batch_norm_backward_reduce<T: Borrow<Tensor>>( &self, grad_out: &Tensor, mean: &Tensor, invstd: &Tensor, weight: Option<T>, input_g: bool, weight_g: bool, bias_g: bool ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn batch_norm_backward_reduce_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, 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_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, 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_gather_stats_with_counts_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, 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_stats_out( &self, out0: &Tensor, out1: &Tensor, 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 batch_norm_update_stats_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, running_mean: Option<T>, running_var: Option<T>, momentum: f64 ) -> (Tensor, Tensor)

pub fn bernoulli(&self) -> Tensor

pub fn bernoulli_(&mut self, p: &Tensor) -> Tensor

pub fn bernoulli_float_(&mut self, p: f64) -> Tensor

pub fn bernoulli_p(&self, p: f64) -> Tensor

pub fn bernoulli_tensor(&self, p: &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_grad_input<T: Borrow<Tensor>>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction ) -> Tensor

pub fn binary_cross_entropy_out<T: Borrow<Tensor>>( &self, out: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction ) -> Tensor

pub fn binary_cross_entropy_with_logits<T: Borrow<Tensor>>( &self, target: &Tensor, weight: Option<T>, pos_weight: Option<T>, reduction: Reduction ) -> Tensor

pub fn binary_cross_entropy_with_logits_out<T: Borrow<Tensor>>( &self, out: &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 bincount_out<T: Borrow<Tensor>>( &self, out: &Tensor, weights: Option<T>, minlength: i64 ) -> Tensor

pub fn binomial(count: &Tensor, prob: &Tensor) -> Tensor

pub fn binomial_out(out: &Tensor, count: &Tensor, prob: &Tensor) -> Tensor

pub fn bitwise_and<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn bitwise_and_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn bitwise_and_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn bitwise_and_scalar_tensor<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_and_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_and_tensor(&self, other: &Tensor) -> Tensor

pub fn bitwise_and_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_and_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn bitwise_left_shift(&self, other: &Tensor) -> Tensor

pub fn bitwise_left_shift_(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_left_shift_scalar_tensor<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_left_shift_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_left_shift_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Tensor

pub fn bitwise_left_shift_tensor_scalar<S: Into<Scalar>>( &self, other: S ) -> Tensor

pub fn bitwise_left_shift_tensor_scalar_<S: Into<Scalar>>( &mut self, other: S ) -> Tensor

pub fn bitwise_left_shift_tensor_scalar_out<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_or_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn bitwise_or_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn bitwise_or_scalar_tensor<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_or_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_or_tensor(&self, other: &Tensor) -> Tensor

pub fn bitwise_or_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_or_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn bitwise_right_shift(&self, other: &Tensor) -> Tensor

pub fn bitwise_right_shift_(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_right_shift_scalar_tensor<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_right_shift_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_right_shift_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Tensor

pub fn bitwise_right_shift_tensor_scalar<S: Into<Scalar>>( &self, other: S ) -> Tensor

pub fn bitwise_right_shift_tensor_scalar_<S: Into<Scalar>>( &mut self, other: S ) -> Tensor

pub fn bitwise_right_shift_tensor_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn bitwise_xor<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn bitwise_xor_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn bitwise_xor_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn bitwise_xor_scalar_tensor<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_xor_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn bitwise_xor_tensor(&self, other: &Tensor) -> Tensor

pub fn bitwise_xor_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn bitwise_xor_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn blackman_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn blackman_window_out(out: &Tensor, window_length: i64) -> Tensor

pub fn blackman_window_periodic( window_length: i64, periodic: bool, options: (Kind, Device) ) -> Tensor

pub fn blackman_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> Tensor

pub fn block_diag<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn block_diag_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor

pub fn bmm(&self, mat2: &Tensor) -> Tensor

pub fn bmm_out(&self, out: &Tensor, mat2: &Tensor) -> Tensor

pub fn broadcast_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn broadcast_to(&self, size: impl IntList) -> Tensor

pub fn bucketize( &self, boundaries: &Tensor, out_int32: bool, right: bool ) -> Tensor

pub fn bucketize_scalar<S: Into<Scalar>>( self_scalar: S, boundaries: &Tensor, out_int32: bool, right: bool ) -> Tensor

pub fn bucketize_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, boundaries: &Tensor, out_int32: bool, right: bool ) -> Tensor

pub fn bucketize_tensor_out( &self, out: &Tensor, boundaries: &Tensor, out_int32: bool, right: bool ) -> Tensor

pub fn can_cast(from: Kind, to: Kind) -> bool

pub fn cartesian_prod<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn cat<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor

pub fn cat_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T], dim: i64 ) -> Tensor

pub fn cauchy(&self, median: f64, sigma: f64) -> Tensor

pub fn cauchy_(&mut self, median: f64, sigma: f64) -> Tensor

pub fn cauchy_out(&self, out: &Tensor, median: f64, sigma: f64) -> Tensor

pub fn ccol_indices(&self) -> Tensor

pub fn ccol_indices_copy(&self) -> Tensor

pub fn ccol_indices_copy_out(&self, out: &Tensor) -> 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 celu_out(&self, out: &Tensor) -> Tensor

pub fn chain_matmul<T: Borrow<Tensor>>(matrices: &[T]) -> Tensor

pub fn chain_matmul_out<T: Borrow<Tensor>>( out: &Tensor, matrices: &[T] ) -> Tensor

pub fn chalf(&self) -> Tensor

pub fn channel_shuffle(&self, groups: i64) -> Tensor

pub fn channel_shuffle_out(&self, out: &Tensor, groups: i64) -> Tensor

pub fn cholesky(&self, upper: bool) -> Tensor

pub fn cholesky_inverse(&self, upper: bool) -> Tensor

pub fn cholesky_inverse_out(&self, out: &Tensor, upper: bool) -> Tensor

pub fn cholesky_out(&self, out: &Tensor, upper: bool) -> Tensor

pub fn cholesky_solve(&self, input2: &Tensor, upper: bool) -> Tensor

pub fn cholesky_solve_out( &self, out: &Tensor, input2: &Tensor, upper: bool ) -> Tensor

pub fn choose_qparams_optimized( &self, numel: i64, n_bins: i64, ratio: f64, bit_width: i64 ) -> (Tensor, Tensor)

pub fn chunk(&self, chunks: i64, dim: i64) -> Vec<Tensor>

pub fn clamp<S: Into<Scalar>>(&self, min: S, max: S) -> Tensor

pub fn clamp_<S: Into<Scalar>>(&mut self, min: S, max: S) -> Tensor

pub fn clamp_max<S: Into<Scalar>>(&self, max: S) -> Tensor

pub fn clamp_max_<S: Into<Scalar>>(&mut self, max: S) -> Tensor

pub fn clamp_max_out<S: Into<Scalar>>(&self, out: &Tensor, max: S) -> Tensor

pub fn clamp_max_tensor(&self, max: &Tensor) -> Tensor

pub fn clamp_max_tensor_(&mut self, max: &Tensor) -> Tensor

pub fn clamp_max_tensor_out(&self, out: &Tensor, max: &Tensor) -> Tensor

pub fn clamp_min<S: Into<Scalar>>(&self, min: S) -> Tensor

pub fn clamp_min_<S: Into<Scalar>>(&mut self, min: S) -> Tensor

pub fn clamp_min_out<S: Into<Scalar>>(&self, out: &Tensor, min: S) -> Tensor

pub fn clamp_min_tensor(&self, min: &Tensor) -> Tensor

pub fn clamp_min_tensor_(&mut self, min: &Tensor) -> Tensor

pub fn clamp_min_tensor_out(&self, out: &Tensor, min: &Tensor) -> Tensor

pub fn clamp_out<S: Into<Scalar>>(&self, out: &Tensor, min: S, max: S) -> Tensor

pub fn clamp_tensor<T: Borrow<Tensor>>( &self, min: Option<T>, max: Option<T> ) -> Tensor

pub fn clamp_tensor_<T: Borrow<Tensor>>( &mut self, min: Option<T>, max: Option<T> ) -> Tensor

pub fn clamp_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, min: Option<T>, max: Option<T> ) -> Tensor

pub fn clip<S: Into<Scalar>>(&self, min: S, max: S) -> Tensor

pub fn clip_<S: Into<Scalar>>(&mut self, min: S, max: S) -> Tensor

pub fn clip_out<S: Into<Scalar>>(&self, out: &Tensor, min: S, max: S) -> Tensor

pub fn clip_tensor<T: Borrow<Tensor>>( &self, min: Option<T>, max: Option<T> ) -> Tensor

pub fn clip_tensor_<T: Borrow<Tensor>>( &mut self, min: Option<T>, max: Option<T> ) -> Tensor

pub fn clip_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, min: Option<T>, max: Option<T> ) -> Tensor

pub fn clone(&self, out: &Tensor) -> Tensor

pub fn coalesce(&self) -> Tensor

pub fn col2im( &self, output_size: impl IntList, kernel_size: impl IntList, dilation: impl IntList, padding: impl IntList, stride: impl IntList ) -> Tensor

pub fn col2im_out( &self, out: &Tensor, output_size: impl IntList, kernel_size: impl IntList, dilation: impl IntList, padding: impl IntList, stride: impl IntList ) -> Tensor

pub fn col_indices(&self) -> Tensor

pub fn col_indices_copy(&self) -> Tensor

pub fn col_indices_copy_out(&self, out: &Tensor) -> Tensor

pub fn column_stack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn column_stack_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T] ) -> Tensor

pub fn combinations(&self, r: i64, with_replacement: bool) -> Tensor

pub fn complex(real: &Tensor, imag: &Tensor) -> Tensor

pub fn complex_out(out: &Tensor, real: &Tensor, imag: &Tensor) -> Tensor

pub fn concat<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor

pub fn concat_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T], dim: i64 ) -> Tensor

pub fn concatenate<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor

pub fn concatenate_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T], dim: i64 ) -> Tensor

pub fn conj(&self) -> Tensor

pub fn conj_physical(&self) -> Tensor

pub fn conj_physical_(&mut self) -> Tensor

pub fn conj_physical_out(&self, out: &Tensor) -> Tensor

pub fn constant_pad_nd(&self, pad: impl IntList) -> Tensor

pub fn constant_pad_nd_out(&self, out: &Tensor, pad: impl IntList) -> Tensor

pub fn contiguous(&self) -> Tensor

pub fn conv1d<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn conv1d_padding<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: &str, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn conv2d<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn conv2d_padding<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: &str, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn conv3d<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn conv3d_padding<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: &str, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn conv_depthwise3d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn conv_depthwise3d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> 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_tbc_out( &self, out: &Tensor, weight: &Tensor, bias: &Tensor, pad: i64 ) -> Tensor

pub fn conv_transpose1d<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, groups: i64, dilation: impl IntList ) -> Tensor

pub fn conv_transpose2d<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, groups: i64, dilation: impl IntList ) -> Tensor

pub fn conv_transpose3d<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, groups: i64, dilation: impl IntList ) -> Tensor

pub fn convolution<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, transposed: bool, output_padding: impl IntList, groups: i64 ) -> Tensor

pub fn convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, transposed: bool, output_padding: impl IntList, groups: i64 ) -> Tensor

pub fn convolution_overrideable<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, transposed: bool, output_padding: impl IntList, groups: i64 ) -> Tensor

pub fn convolution_overrideable_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, transposed: bool, output_padding: impl IntList, groups: i64 ) -> Tensor

pub fn copy_sparse_to_sparse(&self, src: &Tensor, non_blocking: bool) -> Tensor

pub fn copy_sparse_to_sparse_( &mut self, src: &Tensor, non_blocking: bool ) -> Tensor

pub fn copy_sparse_to_sparse_out( &self, out: &Tensor, src: &Tensor, non_blocking: bool ) -> Tensor

pub fn copysign(&self, other: &Tensor) -> Tensor

pub fn copysign_(&mut self, other: &Tensor) -> Tensor

pub fn copysign_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn copysign_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn copysign_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn copysign_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn corrcoef(&self) -> Tensor

pub fn cos(&self) -> Tensor

pub fn cos_(&mut self) -> Tensor

pub fn cos_out(&self, out: &Tensor) -> Tensor

pub fn cosh(&self) -> Tensor

pub fn cosh_(&mut self) -> Tensor

pub fn cosh_out(&self, out: &Tensor) -> Tensor

pub fn cosine_embedding_loss( input1: &Tensor, input2: &Tensor, target: &Tensor, margin: f64, reduction: Reduction ) -> Tensor

pub fn cosine_similarity(x1: &Tensor, x2: &Tensor, dim: i64, eps: f64) -> Tensor

pub fn count_nonzero(&self, dim: impl Into<Option<i64>>) -> Tensor

pub fn count_nonzero_dim_intlist(&self, dim: impl IntList) -> Tensor

pub fn count_nonzero_dim_intlist_out( &self, out: &Tensor, dim: impl IntList ) -> Tensor

pub fn count_nonzero_out( &self, out: &Tensor, dim: impl Into<Option<i64>> ) -> Tensor

pub fn cov<T: Borrow<Tensor>>( &self, correction: i64, fweights: Option<T>, aweights: Option<T> ) -> Tensor

pub fn cross(&self, other: &Tensor, dim: impl Into<Option<i64>>) -> Tensor

pub fn cross_entropy_loss<T: Borrow<Tensor>>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, label_smoothing: f64 ) -> Tensor

pub fn cross_out( &self, out: &Tensor, other: &Tensor, dim: impl Into<Option<i64>> ) -> Tensor

pub fn crow_indices(&self) -> Tensor

pub fn crow_indices_copy(&self) -> Tensor

pub fn crow_indices_copy_out(&self, out: &Tensor) -> Tensor

pub fn ctc_loss( log_probs: &Tensor, targets: &Tensor, input_lengths: impl IntList, target_lengths: impl IntList, blank: i64, reduction: Reduction, zero_infinity: bool ) -> Tensor

pub fn ctc_loss_tensor( log_probs: &Tensor, targets: &Tensor, input_lengths: &Tensor, target_lengths: &Tensor, blank: i64, reduction: Reduction, zero_infinity: bool ) -> Tensor

pub fn cudnn_affine_grid_generator( theta: &Tensor, n: i64, c: i64, h: i64, w: i64 ) -> Tensor

pub fn cudnn_affine_grid_generator_backward( grad: &Tensor, n: i64, c: i64, h: i64, w: i64 ) -> Tensor

pub fn cudnn_affine_grid_generator_backward_out( out: &Tensor, grad: &Tensor, n: i64, c: i64, h: i64, w: i64 ) -> Tensor

pub fn cudnn_affine_grid_generator_out( out: &Tensor, theta: &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_batch_norm_backward_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, 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_batch_norm_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, 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_convolution( &self, weight: &Tensor, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool, allow_tf32: bool ) -> Tensor

pub fn cudnn_convolution_add_relu<T: Borrow<Tensor>, S: Into<Scalar>>( &self, weight: &Tensor, z: &Tensor, alpha: S, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn cudnn_convolution_add_relu_out<T: Borrow<Tensor>, S: Into<Scalar>>( &self, out: &Tensor, weight: &Tensor, z: &Tensor, alpha: S, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn cudnn_convolution_out( &self, out: &Tensor, weight: &Tensor, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool, allow_tf32: bool ) -> Tensor

pub fn cudnn_convolution_relu<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn cudnn_convolution_relu_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn cudnn_convolution_transpose( &self, weight: &Tensor, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool, allow_tf32: bool ) -> Tensor

pub fn cudnn_convolution_transpose_out( &self, out: &Tensor, weight: &Tensor, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool, allow_tf32: bool ) -> Tensor

pub fn cudnn_grid_sampler(&self, grid: &Tensor) -> Tensor

pub fn cudnn_grid_sampler_backward( &self, grid: &Tensor, grad_output: &Tensor ) -> (Tensor, Tensor)

pub fn cudnn_grid_sampler_backward_out( &self, out0: &Tensor, out1: &Tensor, grid: &Tensor, grad_output: &Tensor ) -> (Tensor, Tensor)

pub fn cudnn_grid_sampler_out(&self, out: &Tensor, grid: &Tensor) -> Tensor

pub fn cudnn_is_acceptable(&self) -> bool

pub fn cummax(&self, dim: i64) -> (Tensor, Tensor)

pub fn cummax_out( &self, values: &Tensor, indices: &Tensor, dim: i64 ) -> (Tensor, Tensor)

pub fn cummaxmin_backward( &self, grad: &Tensor, indices: &Tensor, dim: i64 ) -> Tensor

pub fn cummin(&self, dim: i64) -> (Tensor, Tensor)

pub fn cummin_out( &self, values: &Tensor, indices: &Tensor, dim: i64 ) -> (Tensor, Tensor)

pub fn cumprod(&self, dim: i64, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn cumprod_(&mut self, dim: i64, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn cumprod_backward( &self, grad: &Tensor, dim: i64, output: &Tensor ) -> Tensor

pub fn cumprod_out( &self, out: &Tensor, dim: i64, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn cumsum(&self, dim: i64, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn cumsum_(&mut self, dim: i64, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn cumsum_out( &self, out: &Tensor, dim: i64, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn cumulative_trapezoid(y: &Tensor, dim: i64) -> Tensor

pub fn cumulative_trapezoid_x(y: &Tensor, x: &Tensor, dim: i64) -> Tensor

pub fn data(&self) -> Tensor

pub fn deg2rad(&self) -> Tensor

pub fn deg2rad_(&mut self) -> Tensor

pub fn deg2rad_out(&self, out: &Tensor) -> Tensor

pub fn dense_dim(&self) -> i64

pub fn dequantize(&self) -> Tensor

pub fn dequantize_self_out(&self, out: &Tensor) -> Tensor

pub fn dequantize_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn dequantize_tensors_out<T: Borrow<Tensor>>(out: &[T], tensors: &[T])

pub fn det(&self) -> Tensor

pub fn detach(&self) -> Tensor

pub fn detach_(&mut self) -> Tensor

pub fn detach_copy(&self) -> Tensor

pub fn detach_copy_out(&self, out: &Tensor) -> Tensor

pub fn diag(&self, diagonal: i64) -> Tensor

pub fn diag_embed(&self, offset: i64, dim1: i64, dim2: i64) -> Tensor

pub fn diag_embed_out( &self, out: &Tensor, offset: i64, dim1: i64, dim2: i64 ) -> Tensor

pub fn diag_out(&self, out: &Tensor, diagonal: i64) -> Tensor

pub fn diagflat(&self, offset: i64) -> Tensor

pub fn diagonal(&self, offset: i64, dim1: i64, dim2: i64) -> Tensor

pub fn diagonal_backward( grad_output: &Tensor, input_sizes: impl IntList, offset: i64, dim1: i64, dim2: i64 ) -> Tensor

pub fn diagonal_backward_out( out: &Tensor, grad_output: &Tensor, input_sizes: impl IntList, offset: i64, dim1: i64, dim2: i64 ) -> Tensor

pub fn diagonal_copy(&self, offset: i64, dim1: i64, dim2: i64) -> Tensor

pub fn diagonal_copy_out( &self, out: &Tensor, offset: i64, dim1: i64, dim2: i64 ) -> Tensor

pub fn diagonal_scatter( &self, src: &Tensor, offset: i64, dim1: i64, dim2: i64 ) -> Tensor

pub fn diagonal_scatter_out( &self, out: &Tensor, src: &Tensor, offset: i64, dim1: i64, dim2: i64 ) -> Tensor

pub fn diff<T: Borrow<Tensor>>( &self, n: i64, dim: i64, prepend: Option<T>, append: Option<T> ) -> Tensor

pub fn diff_out<T: Borrow<Tensor>>( &self, out: &Tensor, n: i64, dim: i64, prepend: Option<T>, append: Option<T> ) -> Tensor

pub fn digamma(&self) -> Tensor

pub fn digamma_(&mut self) -> Tensor

pub fn digamma_out(&self, out: &Tensor) -> Tensor

pub fn dist(&self, other: &Tensor) -> Tensor

pub fn dist_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn g_div(&self, other: &Tensor) -> Tensor

pub fn g_div_(&mut self, other: &Tensor) -> Tensor

pub fn div_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn div_out_mode( &self, out: &Tensor, other: &Tensor, rounding_mode: &str ) -> Tensor

pub fn g_div_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_div_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn g_div_scalar_mode<S: Into<Scalar>>( &self, other: S, rounding_mode: &str ) -> Tensor

pub fn g_div_scalar_mode_<S: Into<Scalar>>( &mut self, other: S, rounding_mode: &str ) -> Tensor

pub fn div_scalar_mode_out<S: Into<Scalar>>( &self, out: &Tensor, other: S, rounding_mode: &str ) -> Tensor

pub fn div_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn g_div_tensor_mode(&self, other: &Tensor, rounding_mode: &str) -> Tensor

pub fn g_div_tensor_mode_( &mut self, other: &Tensor, rounding_mode: &str ) -> Tensor

pub fn divide(&self, other: &Tensor) -> Tensor

pub fn divide_(&mut self, other: &Tensor) -> Tensor

pub fn divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn divide_out_mode( &self, out: &Tensor, other: &Tensor, rounding_mode: &str ) -> Tensor

pub fn divide_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn divide_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn divide_scalar_mode<S: Into<Scalar>>( &self, other: S, rounding_mode: &str ) -> Tensor

pub fn divide_scalar_mode_<S: Into<Scalar>>( &mut self, other: S, rounding_mode: &str ) -> Tensor

pub fn divide_tensor_mode(&self, other: &Tensor, rounding_mode: &str) -> Tensor

pub fn divide_tensor_mode_( &mut self, other: &Tensor, rounding_mode: &str ) -> Tensor

pub fn dot(&self, tensor: &Tensor) -> Tensor

pub fn dot_out(&self, out: &Tensor, tensor: &Tensor) -> Tensor

pub fn dropout(&self, p: f64, train: bool) -> Tensor

pub fn dropout_(&mut self, p: f64, train: bool) -> Tensor

pub fn dsplit(&self, sections: i64) -> Vec<Tensor>

pub fn dsplit_array(&self, indices: impl IntList) -> Vec<Tensor>

pub fn dstack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn dstack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor

pub fn einsum<T: Borrow<Tensor>>( equation: &str, tensors: &[T], path: impl IntListOption ) -> Tensor

pub fn elu(&self) -> Tensor

pub fn elu_(&mut self) -> Tensor

pub fn elu_backward<S: Into<Scalar>>( grad_output: &Tensor, alpha: S, scale: S, input_scale: S, is_result: bool, self_or_result: &Tensor ) -> Tensor

pub fn elu_backward_grad_input<S: Into<Scalar>>( grad_input: &Tensor, grad_output: &Tensor, alpha: S, scale: S, input_scale: S, is_result: bool, self_or_result: &Tensor ) -> Tensor

pub fn elu_out(&self, out: &Tensor) -> Tensor

pub fn embedding( weight: &Tensor, indices: &Tensor, padding_idx: i64, scale_grad_by_freq: bool, sparse: bool ) -> Tensor

pub fn embedding_backward( grad: &Tensor, indices: &Tensor, num_weights: i64, padding_idx: i64, scale_grad_by_freq: bool, sparse: bool ) -> Tensor

pub fn embedding_bag<T: Borrow<Tensor>>( weight: &Tensor, indices: &Tensor, offsets: &Tensor, scale_grad_by_freq: bool, mode: i64, sparse: bool, per_sample_weights: Option<T>, include_last_offset: bool ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn embedding_bag_padding_idx<T: Borrow<Tensor>>( weight: &Tensor, indices: &Tensor, offsets: &Tensor, scale_grad_by_freq: bool, mode: i64, sparse: bool, per_sample_weights: Option<T>, include_last_offset: bool, padding_idx: impl Into<Option<i64>> ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn embedding_dense_backward( grad_output: &Tensor, indices: &Tensor, num_weights: i64, padding_idx: i64, scale_grad_by_freq: bool ) -> Tensor

pub fn embedding_dense_backward_out( out: &Tensor, grad_output: &Tensor, indices: &Tensor, num_weights: i64, padding_idx: i64, scale_grad_by_freq: bool ) -> Tensor

pub fn embedding_out( out: &Tensor, weight: &Tensor, indices: &Tensor, padding_idx: i64, scale_grad_by_freq: bool, sparse: bool ) -> Tensor

pub fn embedding_renorm( &self, indices: &Tensor, max_norm: f64, norm_type: f64 ) -> Tensor

pub fn embedding_renorm_( &mut self, indices: &Tensor, max_norm: f64, norm_type: f64 ) -> Tensor

pub fn embedding_renorm_out( &self, out: &Tensor, 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: impl IntList, options: (Kind, Device)) -> Tensor

pub fn empty_like(&self) -> Tensor

pub fn empty_like_out(&self, out: &Tensor) -> Tensor

pub fn empty_out(out: &Tensor, size: impl IntList) -> Tensor

pub fn empty_permuted( size: impl IntList, physical_layout: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn empty_permuted_out( out: &Tensor, size: impl IntList, physical_layout: impl IntList ) -> Tensor

pub fn empty_quantized( size: impl IntList, qtensor: &Tensor, options: (Kind, Device) ) -> Tensor

pub fn empty_quantized_out( out: &Tensor, size: impl IntList, qtensor: &Tensor ) -> Tensor

pub fn empty_strided( size: impl IntList, stride: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn empty_strided_out( out: &Tensor, size: impl IntList, stride: impl IntList ) -> Tensor

pub fn eq<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn eq_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn eq_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn eq_tensor(&self, other: &Tensor) -> Tensor

pub fn eq_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn eq_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn equal(&self, other: &Tensor) -> bool

pub fn erf(&self) -> Tensor

pub fn erf_(&mut self) -> Tensor

pub fn erf_out(&self, out: &Tensor) -> Tensor

pub fn erfc(&self) -> Tensor

pub fn erfc_(&mut self) -> Tensor

pub fn erfc_out(&self, out: &Tensor) -> Tensor

pub fn erfinv(&self) -> Tensor

pub fn erfinv_(&mut self) -> Tensor

pub fn erfinv_out(&self, out: &Tensor) -> Tensor

pub fn exp(&self) -> Tensor

pub fn exp2(&self) -> Tensor

pub fn exp2_(&mut self) -> Tensor

pub fn exp2_out(&self, out: &Tensor) -> Tensor

pub fn exp_(&mut self) -> Tensor

pub fn exp_out(&self, out: &Tensor) -> Tensor

pub fn expand(&self, size: impl IntList, implicit: bool) -> Tensor

pub fn expand_as(&self, other: &Tensor) -> Tensor

pub fn expand_copy(&self, size: impl IntList, implicit: bool) -> Tensor

pub fn expand_copy_out( &self, out: &Tensor, size: impl IntList, implicit: bool ) -> Tensor

pub fn expm1(&self) -> Tensor

pub fn expm1_(&mut self) -> Tensor

pub fn expm1_out(&self, out: &Tensor) -> Tensor

pub fn exponential(&self, lambd: f64) -> Tensor

pub fn exponential_(&mut self, lambd: f64) -> Tensor

pub fn exponential_out(&self, out: &Tensor, lambd: f64) -> Tensor

pub fn eye(n: i64, options: (Kind, Device)) -> Tensor

pub fn eye_m(n: i64, m: i64, options: (Kind, Device)) -> Tensor

pub fn eye_m_out(out: &Tensor, n: i64, m: i64) -> Tensor

pub fn eye_out(out: &Tensor, n: i64) -> Tensor

pub fn fake_quantize_per_channel_affine( &self, scale: &Tensor, zero_point: &Tensor, axis: i64, quant_min: i64, quant_max: i64 ) -> Tensor

pub fn fake_quantize_per_channel_affine_cachemask( &self, scale: &Tensor, zero_point: &Tensor, axis: i64, quant_min: i64, quant_max: i64 ) -> (Tensor, Tensor)

pub fn fake_quantize_per_channel_affine_cachemask_backward( grad: &Tensor, mask: &Tensor ) -> Tensor

pub fn fake_quantize_per_channel_affine_cachemask_out( &self, out0: &Tensor, out1: &Tensor, scale: &Tensor, zero_point: &Tensor, axis: i64, quant_min: i64, quant_max: i64 ) -> (Tensor, Tensor)

pub fn fake_quantize_per_tensor_affine( &self, scale: f64, zero_point: i64, quant_min: i64, quant_max: i64 ) -> Tensor

pub fn fake_quantize_per_tensor_affine_cachemask( &self, scale: f64, zero_point: i64, quant_min: i64, quant_max: i64 ) -> (Tensor, Tensor)

pub fn fake_quantize_per_tensor_affine_cachemask_backward( grad: &Tensor, mask: &Tensor ) -> Tensor

pub fn fake_quantize_per_tensor_affine_cachemask_out( &self, out0: &Tensor, out1: &Tensor, scale: f64, zero_point: i64, quant_min: i64, quant_max: i64 ) -> (Tensor, Tensor)

pub fn fake_quantize_per_tensor_affine_tensor_qparams( &self, scale: &Tensor, zero_point: &Tensor, 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_matrix_kn(&self, k: i64, n: i64) -> Tensor

pub fn feature_alpha_dropout(&self, p: f64, train: bool) -> Tensor

pub fn feature_alpha_dropout_(&mut self, p: f64, train: bool) -> Tensor

pub fn feature_dropout(&self, p: f64, train: bool) -> Tensor

pub fn feature_dropout_(&mut self, p: f64, train: bool) -> Tensor

pub fn fft_fft(&self, n: impl Into<Option<i64>>, dim: i64, norm: &str) -> Tensor

pub fn fft_fft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_fft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_fft_out( &self, out: &Tensor, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_fftfreq(n: i64, d: f64, options: (Kind, Device)) -> Tensor

pub fn fft_fftfreq_out(out: &Tensor, n: i64, d: f64) -> Tensor

pub fn fft_fftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_fftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_fftshift(&self, dim: impl IntListOption) -> Tensor

pub fn fft_hfft( &self, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_hfft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_hfft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_hfft_out( &self, out: &Tensor, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_hfftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_hfftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_ifft( &self, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_ifft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_ifft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_ifft_out( &self, out: &Tensor, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_ifftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_ifftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_ifftshift(&self, dim: impl IntListOption) -> Tensor

pub fn fft_ihfft( &self, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_ihfft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_ihfft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_ihfft_out( &self, out: &Tensor, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_ihfftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_ihfftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_irfft( &self, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_irfft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_irfft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_irfft_out( &self, out: &Tensor, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_irfftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_irfftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_rfft( &self, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_rfft2( &self, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_rfft2_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntList, norm: &str ) -> Tensor

pub fn fft_rfft_out( &self, out: &Tensor, n: impl Into<Option<i64>>, dim: i64, norm: &str ) -> Tensor

pub fn fft_rfftfreq(n: i64, d: f64, options: (Kind, Device)) -> Tensor

pub fn fft_rfftfreq_out(out: &Tensor, n: i64, d: f64) -> Tensor

pub fn fft_rfftn( &self, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fft_rfftn_out( &self, out: &Tensor, s: impl IntListOption, dim: impl IntListOption, norm: &str ) -> Tensor

pub fn fill<S: Into<Scalar>>(&self, value: S) -> Tensor

pub fn fill_<S: Into<Scalar>>(&mut self, value: S) -> Tensor

pub fn fill_diagonal_<S: Into<Scalar>>( &mut self, fill_value: S, wrap: bool ) -> Tensor

pub fn fill_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, value: S) -> Tensor

pub fn fill_tensor(&self, value: &Tensor) -> Tensor

pub fn fill_tensor_(&mut self, value: &Tensor) -> Tensor

pub fn fill_tensor_out(&self, out: &Tensor, value: &Tensor) -> Tensor

pub fn fix(&self) -> Tensor

pub fn fix_(&mut self) -> Tensor

pub fn fix_out(&self, out: &Tensor) -> Tensor

pub fn flatten(&self, start_dim: i64, end_dim: i64) -> Tensor

pub fn flatten_dense_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn flip(&self, dims: impl IntList) -> Tensor

pub fn flip_out(&self, out: &Tensor, dims: impl IntList) -> Tensor

pub fn fliplr(&self) -> Tensor

pub fn flipud(&self) -> Tensor

pub fn float_power(&self, exponent: &Tensor) -> Tensor

pub fn float_power_<S: Into<Scalar>>(&mut self, exponent: S) -> Tensor

pub fn float_power_scalar<S: Into<Scalar>>( self_scalar: S, exponent: &Tensor ) -> Tensor

pub fn float_power_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, exponent: &Tensor ) -> Tensor

pub fn float_power_tensor_(&mut self, exponent: &Tensor) -> Tensor

pub fn float_power_tensor_scalar<S: Into<Scalar>>(&self, exponent: S) -> Tensor

pub fn float_power_tensor_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, exponent: S ) -> Tensor

pub fn float_power_tensor_tensor_out( &self, out: &Tensor, exponent: &Tensor ) -> Tensor

pub fn floor(&self) -> Tensor

pub fn floor_(&mut self) -> Tensor

pub fn floor_divide(&self, other: &Tensor) -> Tensor

pub fn floor_divide_(&mut self, other: &Tensor) -> Tensor

pub fn floor_divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn floor_divide_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn floor_divide_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn floor_out(&self, out: &Tensor) -> Tensor

pub fn fmax(&self, other: &Tensor) -> Tensor

pub fn fmax_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn fmin(&self, other: &Tensor) -> Tensor

pub fn fmin_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn fmod<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn fmod_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn fmod_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn fmod_tensor(&self, other: &Tensor) -> Tensor

pub fn fmod_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn fmod_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn frac(&self) -> Tensor

pub fn frac_(&mut self) -> Tensor

pub fn frac_out(&self, out: &Tensor) -> Tensor

pub fn fractional_max_pool2d( &self, kernel_size: impl IntList, output_size: impl IntList, random_samples: &Tensor ) -> (Tensor, Tensor)

pub fn fractional_max_pool2d_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, output_size: impl IntList, indices: &Tensor ) -> Tensor

pub fn fractional_max_pool2d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, output_size: impl IntList, indices: &Tensor ) -> Tensor

pub fn fractional_max_pool2d_output( &self, output: &Tensor, indices: &Tensor, kernel_size: impl IntList, output_size: impl IntList, random_samples: &Tensor ) -> (Tensor, Tensor)

pub fn fractional_max_pool3d( &self, kernel_size: impl IntList, output_size: impl IntList, random_samples: &Tensor ) -> (Tensor, Tensor)

pub fn fractional_max_pool3d_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, output_size: impl IntList, indices: &Tensor ) -> Tensor

pub fn fractional_max_pool3d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, output_size: impl IntList, indices: &Tensor ) -> Tensor

pub fn fractional_max_pool3d_output( &self, output: &Tensor, indices: &Tensor, kernel_size: impl IntList, output_size: impl IntList, random_samples: &Tensor ) -> (Tensor, Tensor)

pub fn frexp(&self) -> (Tensor, Tensor)

pub fn frexp_tensor_out( &self, mantissa: &Tensor, exponent: &Tensor ) -> (Tensor, Tensor)

pub fn frobenius_norm(&self, dim: impl IntList, keepdim: bool) -> Tensor

pub fn frobenius_norm_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool ) -> Tensor

pub fn from_file( filename: &str, shared: bool, size: impl Into<Option<i64>>, options: (Kind, Device) ) -> Tensor

pub fn from_file_out( out: &Tensor, filename: &str, shared: bool, size: impl Into<Option<i64>> ) -> Tensor

pub fn full<S: Into<Scalar>>( size: impl IntList, fill_value: S, options: (Kind, Device) ) -> Tensor

pub fn full_like<S: Into<Scalar>>(&self, fill_value: S) -> Tensor

pub fn full_like_out<S: Into<Scalar>>( &self, out: &Tensor, fill_value: S ) -> Tensor

pub fn full_out<S: Into<Scalar>>( out: &Tensor, size: impl IntList, fill_value: S ) -> Tensor

pub fn fused_moving_avg_obs_fake_quant( &self, observer_on: &Tensor, fake_quant_on: &Tensor, running_min: &Tensor, running_max: &Tensor, scale: &Tensor, zero_point: &Tensor, averaging_const: f64, quant_min: i64, quant_max: i64, ch_axis: i64, per_row_fake_quant: bool, symmetric_quant: bool ) -> Tensor

pub fn gather(&self, dim: i64, index: &Tensor, sparse_grad: bool) -> Tensor

pub fn gather_backward( &self, grad: &Tensor, dim: i64, index: &Tensor, sparse_grad: bool ) -> Tensor

pub fn gather_out( &self, out: &Tensor, dim: i64, index: &Tensor, sparse_grad: bool ) -> Tensor

pub fn gcd(&self, other: &Tensor) -> Tensor

pub fn gcd_(&mut self, other: &Tensor) -> Tensor

pub fn gcd_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn ge<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn ge_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn ge_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn ge_tensor(&self, other: &Tensor) -> Tensor

pub fn ge_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn ge_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn gelu(&self, approximate: &str) -> Tensor

pub fn gelu_(&mut self, approximate: &str) -> Tensor

pub fn gelu_backward(&self, grad_output: &Tensor, approximate: &str) -> Tensor

pub fn gelu_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, approximate: &str ) -> Tensor

pub fn gelu_out(&self, out: &Tensor, approximate: &str) -> Tensor

pub fn geometric(&self, p: f64) -> Tensor

pub fn geometric_(&mut self, p: f64) -> Tensor

pub fn geometric_out(&self, out: &Tensor, p: f64) -> Tensor

pub fn geqrf(&self) -> (Tensor, Tensor)

pub fn geqrf_a(&self, a: &Tensor, tau: &Tensor) -> (Tensor, Tensor)

pub fn ger(&self, vec2: &Tensor) -> Tensor

pub fn ger_out(&self, out: &Tensor, vec2: &Tensor) -> Tensor

pub fn glu(&self, dim: i64) -> Tensor

pub fn glu_backward(&self, grad_output: &Tensor, dim: i64) -> Tensor

pub fn glu_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, dim: i64 ) -> Tensor

pub fn glu_backward_jvp( grad_x: &Tensor, grad_glu: &Tensor, x: &Tensor, dgrad_glu: &Tensor, dx: &Tensor, dim: i64 ) -> Tensor

pub fn glu_backward_jvp_out( out: &Tensor, grad_x: &Tensor, grad_glu: &Tensor, x: &Tensor, dgrad_glu: &Tensor, dx: &Tensor, dim: i64 ) -> Tensor

pub fn glu_jvp(glu: &Tensor, x: &Tensor, dx: &Tensor, dim: i64) -> Tensor

pub fn glu_jvp_out( out: &Tensor, glu: &Tensor, x: &Tensor, dx: &Tensor, dim: i64 ) -> Tensor

pub fn glu_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn grad(&self) -> Tensor

pub fn greater<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn greater_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn greater_equal<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn greater_equal_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn greater_equal_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn greater_equal_tensor(&self, other: &Tensor) -> Tensor

pub fn greater_equal_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn greater_equal_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn greater_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn greater_tensor(&self, other: &Tensor) -> Tensor

pub fn greater_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn greater_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn grid_sampler( &self, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> Tensor

pub fn grid_sampler_2d( &self, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> Tensor

pub fn grid_sampler_2d_out( &self, out: &Tensor, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> Tensor

pub fn grid_sampler_3d( &self, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> Tensor

pub fn grid_sampler_3d_out( &self, out: &Tensor, grid: &Tensor, interpolation_mode: i64, padding_mode: i64, align_corners: bool ) -> Tensor

pub fn group_norm<T: Borrow<Tensor>>( &self, num_groups: i64, weight: Option<T>, bias: Option<T>, eps: f64, cudnn_enabled: bool ) -> Tensor

pub fn gru<T: Borrow<Tensor>>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> (Tensor, Tensor)

pub fn gru_cell<T: Borrow<Tensor>>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Tensor

pub fn gru_data<T: Borrow<Tensor>>( data: &Tensor, batch_sizes: &Tensor, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool ) -> (Tensor, Tensor)

pub fn gt<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn gt_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn gt_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn gt_tensor(&self, other: &Tensor) -> Tensor

pub fn gt_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn gt_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn hamming_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn hamming_window_out(out: &Tensor, window_length: i64) -> Tensor

pub fn hamming_window_periodic( window_length: i64, periodic: bool, options: (Kind, Device) ) -> Tensor

pub fn hamming_window_periodic_alpha( window_length: i64, periodic: bool, alpha: f64, options: (Kind, Device) ) -> Tensor

pub fn hamming_window_periodic_alpha_beta( window_length: i64, periodic: bool, alpha: f64, beta: f64, options: (Kind, Device) ) -> Tensor

pub fn hamming_window_periodic_alpha_beta_out( out: &Tensor, window_length: i64, periodic: bool, alpha: f64, beta: f64 ) -> Tensor

pub fn hamming_window_periodic_alpha_out( out: &Tensor, window_length: i64, periodic: bool, alpha: f64 ) -> Tensor

pub fn hamming_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> Tensor

pub fn hann_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn hann_window_out(out: &Tensor, window_length: i64) -> Tensor

pub fn hann_window_periodic( window_length: i64, periodic: bool, options: (Kind, Device) ) -> Tensor

pub fn hann_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> Tensor

pub fn hardshrink(&self) -> Tensor

pub fn hardshrink_backward<S: Into<Scalar>>( &self, grad_out: &Tensor, lambd: S ) -> Tensor

pub fn hardshrink_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_out: &Tensor, lambd: S ) -> Tensor

pub fn hardshrink_out(&self, out: &Tensor) -> Tensor

pub fn hardsigmoid(&self) -> Tensor

pub fn hardsigmoid_(&mut self) -> Tensor

pub fn hardsigmoid_backward(&self, grad_output: &Tensor) -> Tensor

pub fn hardsigmoid_backward_grad_input( &self, grad_input: &Tensor, 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_backward_out( &self, out: &Tensor, grad_output: &Tensor ) -> Tensor

pub fn hardswish_out(&self, out: &Tensor) -> Tensor

pub fn hardtanh(&self) -> Tensor

pub fn hardtanh_(&mut self) -> Tensor

pub fn hardtanh_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, min_val: S, max_val: S ) -> Tensor

pub fn hardtanh_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, min_val: S, max_val: S ) -> Tensor

pub fn hardtanh_out(&self, out: &Tensor) -> Tensor

pub fn heaviside(&self, values: &Tensor) -> Tensor

pub fn heaviside_(&mut self, values: &Tensor) -> Tensor

pub fn heaviside_out(&self, out: &Tensor, values: &Tensor) -> Tensor

pub fn hinge_embedding_loss( &self, target: &Tensor, margin: f64, reduction: Reduction ) -> Tensor

pub fn histc(&self, bins: i64) -> Tensor

pub fn histc_out(&self, out: &Tensor, bins: i64) -> Tensor

pub fn histogram<T: Borrow<Tensor>>( &self, bins: &Tensor, weight: Option<T>, density: bool ) -> (Tensor, Tensor)

pub fn histogram_bin_ct<T: Borrow<Tensor>>( &self, bins: i64, range: impl DoubleList, weight: Option<T>, density: bool ) -> (Tensor, Tensor)

pub fn histogram_bin_ct_out<T: Borrow<Tensor>>( &self, hist: &Tensor, bin_edges: &Tensor, bins: i64, range: impl DoubleList, weight: Option<T>, density: bool ) -> (Tensor, Tensor)

pub fn histogram_bins_tensor_out<T: Borrow<Tensor>>( &self, hist: &Tensor, bin_edges: &Tensor, bins: &Tensor, weight: Option<T>, density: bool ) -> (Tensor, Tensor)

pub fn hsplit(&self, sections: i64) -> Vec<Tensor>

pub fn hsplit_array(&self, indices: impl IntList) -> Vec<Tensor>

pub fn hspmm(mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn hspmm_out(out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn hstack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn hstack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor

pub fn huber_loss( &self, target: &Tensor, reduction: Reduction, delta: f64 ) -> Tensor

pub fn huber_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction, delta: f64 ) -> Tensor

pub fn huber_loss_backward_out( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction, delta: f64 ) -> Tensor

pub fn huber_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction, delta: f64 ) -> Tensor

pub fn hypot(&self, other: &Tensor) -> Tensor

pub fn hypot_(&mut self, other: &Tensor) -> Tensor

pub fn hypot_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn i0(&self) -> Tensor

pub fn i0_(&mut self) -> Tensor

pub fn i0_out(&self, out: &Tensor) -> Tensor

pub fn igamma(&self, other: &Tensor) -> Tensor

pub fn igamma_(&mut self, other: &Tensor) -> Tensor

pub fn igamma_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn igammac(&self, other: &Tensor) -> Tensor

pub fn igammac_(&mut self, other: &Tensor) -> Tensor

pub fn igammac_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn im2col( &self, kernel_size: impl IntList, dilation: impl IntList, padding: impl IntList, stride: impl IntList ) -> Tensor

pub fn im2col_out( &self, out: &Tensor, kernel_size: impl IntList, dilation: impl IntList, padding: impl IntList, stride: impl IntList ) -> Tensor

pub fn imag(&self) -> Tensor

pub fn index<T: Borrow<Tensor>>(&self, indices: &[Option<T>]) -> Tensor

pub fn index_add(&self, dim: i64, index: &Tensor, source: &Tensor) -> Tensor

pub fn index_add_( &mut self, dim: i64, index: &Tensor, source: &Tensor ) -> Tensor

pub fn index_add_out( &self, out: &Tensor, 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_copy_out( &self, out: &Tensor, dim: i64, index: &Tensor, source: &Tensor ) -> Tensor

pub fn index_fill<S: Into<Scalar>>( &self, dim: i64, index: &Tensor, value: S ) -> Tensor

pub fn index_fill_<S: Into<Scalar>>( &mut self, dim: i64, index: &Tensor, value: S ) -> Tensor

pub fn index_fill_int_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S ) -> Tensor

pub fn index_fill_int_tensor( &self, dim: i64, index: &Tensor, value: &Tensor ) -> Tensor

pub fn index_fill_int_tensor_( &mut self, dim: i64, index: &Tensor, value: &Tensor ) -> Tensor

pub fn index_fill_int_tensor_out( &self, out: &Tensor, dim: i64, index: &Tensor, value: &Tensor ) -> Tensor

pub fn index_put<T: Borrow<Tensor>>( &self, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Tensor

pub fn index_put_<T: Borrow<Tensor>>( &mut self, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Tensor

pub fn index_put_out<T: Borrow<Tensor>>( &self, out: &Tensor, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Tensor

pub fn index_reduce( &self, dim: i64, index: &Tensor, source: &Tensor, reduce: &str, include_self: bool ) -> Tensor

pub fn index_reduce_( &mut self, dim: i64, index: &Tensor, source: &Tensor, reduce: &str, include_self: bool ) -> Tensor

pub fn index_reduce_out( &self, out: &Tensor, dim: i64, index: &Tensor, source: &Tensor, reduce: &str, include_self: bool ) -> Tensor

pub fn index_select(&self, dim: i64, index: &Tensor) -> Tensor

pub fn index_select_backward( grad: &Tensor, self_sizes: impl IntList, dim: i64, index: &Tensor ) -> Tensor

pub fn index_select_out(&self, out: &Tensor, dim: i64, index: &Tensor) -> Tensor

pub fn index_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, indices: &[Option<T>] ) -> Tensor

pub fn indices(&self) -> Tensor

pub fn indices_copy(&self) -> Tensor

pub fn indices_copy_out(&self, out: &Tensor) -> Tensor

pub fn infinitely_differentiable_gelu_backward(&self, grad: &Tensor) -> Tensor

pub fn inner(&self, other: &Tensor) -> Tensor

pub fn inner_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn instance_norm<T: Borrow<Tensor>>( &self, weight: Option<T>, bias: Option<T>, running_mean: Option<T>, running_var: Option<T>, use_input_stats: bool, momentum: f64, eps: f64, cudnn_enabled: bool ) -> Tensor

pub fn int_repr(&self) -> Tensor

pub fn int_repr_out(&self, out: &Tensor) -> Tensor

pub fn inverse(&self) -> Tensor

pub fn inverse_out(&self, out: &Tensor) -> Tensor

pub fn is_coalesced(&self) -> bool

pub fn is_complex(&self) -> bool

pub fn is_conj(&self) -> bool

pub fn is_distributed(&self) -> bool

pub fn is_floating_point(&self) -> bool

pub fn is_inference(&self) -> bool

pub fn is_leaf(&self) -> bool

pub fn is_neg(&self) -> bool

pub fn is_nonzero(&self) -> bool

pub fn is_pinned(&self, device: Device) -> bool

pub fn is_same_size(&self, other: &Tensor) -> bool

pub fn is_set_to(&self, tensor: &Tensor) -> bool

pub fn is_signed(&self) -> bool

pub fn is_vulkan_available() -> bool

pub fn isclose( &self, other: &Tensor, rtol: f64, atol: f64, equal_nan: bool ) -> Tensor

pub fn isfinite(&self) -> Tensor

pub fn isin( elements: &Tensor, test_elements: &Tensor, assume_unique: bool, invert: bool ) -> Tensor

pub fn isin_scalar_tensor<S: Into<Scalar>>( element: S, test_elements: &Tensor, assume_unique: bool, invert: bool ) -> Tensor

pub fn isin_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, element: S, test_elements: &Tensor, assume_unique: bool, invert: bool ) -> Tensor

pub fn isin_tensor_scalar<S: Into<Scalar>>( elements: &Tensor, test_element: S, assume_unique: bool, invert: bool ) -> Tensor

pub fn isin_tensor_scalar_out<S: Into<Scalar>>( out: &Tensor, elements: &Tensor, test_element: S, assume_unique: bool, invert: bool ) -> Tensor

pub fn isin_tensor_tensor_out( out: &Tensor, elements: &Tensor, test_elements: &Tensor, assume_unique: bool, invert: bool ) -> Tensor

pub fn isinf(&self) -> Tensor

pub fn isinf_out(&self, out: &Tensor) -> Tensor

pub fn isnan(&self) -> Tensor

pub fn isnan_out(&self, out: &Tensor) -> Tensor

pub fn isneginf(&self) -> Tensor

pub fn isneginf_out(&self, out: &Tensor) -> Tensor

pub fn isposinf(&self) -> Tensor

pub fn isposinf_out(&self, out: &Tensor) -> Tensor

pub fn isreal(&self) -> Tensor

pub fn istft<T: Borrow<Tensor>>( &self, n_fft: i64, hop_length: impl Into<Option<i64>>, win_length: impl Into<Option<i64>>, window: Option<T>, center: bool, normalized: bool, onesided: bool, length: impl Into<Option<i64>>, return_complex: bool ) -> Tensor

pub fn kaiser_window(window_length: i64, options: (Kind, Device)) -> Tensor

pub fn kaiser_window_beta( window_length: i64, periodic: bool, beta: f64, options: (Kind, Device) ) -> Tensor

pub fn kaiser_window_beta_out( out: &Tensor, window_length: i64, periodic: bool, beta: f64 ) -> Tensor

pub fn kaiser_window_out(out: &Tensor, window_length: i64) -> Tensor

pub fn kaiser_window_periodic( window_length: i64, periodic: bool, options: (Kind, Device) ) -> Tensor

pub fn kaiser_window_periodic_out( out: &Tensor, window_length: i64, periodic: bool ) -> Tensor

pub fn kl_div( &self, target: &Tensor, reduction: Reduction, log_target: bool ) -> Tensor

pub fn kron(&self, other: &Tensor) -> Tensor

pub fn kron_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn kthvalue(&self, k: i64, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn kthvalue_values( &self, values: &Tensor, indices: &Tensor, k: i64, dim: i64, keepdim: bool ) -> (Tensor, Tensor)

pub fn l1_loss(&self, target: &Tensor, reduction: Reduction) -> Tensor

pub fn layer_norm<T: Borrow<Tensor>>( &self, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64, cudnn_enable: bool ) -> Tensor

pub fn lcm(&self, other: &Tensor) -> Tensor

pub fn lcm_(&mut self, other: &Tensor) -> Tensor

pub fn lcm_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn ldexp(&self, other: &Tensor) -> Tensor

pub fn ldexp_(&mut self, other: &Tensor) -> Tensor

pub fn ldexp_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn le<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn le_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn le_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn le_tensor(&self, other: &Tensor) -> Tensor

pub fn le_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn le_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn leaky_relu(&self) -> Tensor

pub fn leaky_relu_(&mut self) -> Tensor

pub fn leaky_relu_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, negative_slope: S, self_is_result: bool ) -> Tensor

pub fn leaky_relu_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, negative_slope: S, self_is_result: bool ) -> Tensor

pub fn leaky_relu_out(&self, out: &Tensor) -> Tensor

pub fn lerp<S: Into<Scalar>>(&self, end: &Tensor, weight: S) -> Tensor

pub fn lerp_<S: Into<Scalar>>(&mut self, end: &Tensor, weight: S) -> Tensor

pub fn lerp_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, end: &Tensor, weight: S ) -> Tensor

pub fn lerp_tensor(&self, end: &Tensor, weight: &Tensor) -> Tensor

pub fn lerp_tensor_(&mut self, end: &Tensor, weight: &Tensor) -> Tensor

pub fn lerp_tensor_out( &self, out: &Tensor, end: &Tensor, weight: &Tensor ) -> Tensor

pub fn less<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn less_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn less_equal<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn less_equal_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn less_equal_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn less_equal_tensor(&self, other: &Tensor) -> Tensor

pub fn less_equal_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn less_equal_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn less_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn less_tensor(&self, other: &Tensor) -> Tensor

pub fn less_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn less_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn lgamma(&self) -> Tensor

pub fn lgamma_(&mut self) -> Tensor

pub fn lgamma_out(&self, out: &Tensor) -> Tensor

pub fn lift(&self) -> Tensor

pub fn lift_fresh(&self) -> Tensor

pub fn lift_fresh_copy(&self) -> Tensor

pub fn lift_fresh_copy_out(&self, out: &Tensor) -> Tensor

pub fn lift_out(&self, out: &Tensor) -> Tensor

pub fn linalg_cholesky(&self, upper: bool) -> Tensor

pub fn linalg_cholesky_ex( &self, upper: bool, check_errors: bool ) -> (Tensor, Tensor)

pub fn linalg_cholesky_ex_l( &self, l: &Tensor, info: &Tensor, upper: bool, check_errors: bool ) -> (Tensor, Tensor)

pub fn linalg_cholesky_out(&self, out: &Tensor, upper: bool) -> Tensor

pub fn linalg_cond<S: Into<Scalar>>(&self, p: S) -> Tensor

pub fn linalg_cond_out<S: Into<Scalar>>(&self, out: &Tensor, p: S) -> Tensor

pub fn linalg_cond_p_str(&self, p: &str) -> Tensor

pub fn linalg_cond_p_str_out(&self, out: &Tensor, p: &str) -> Tensor

pub fn linalg_cross(&self, other: &Tensor, dim: i64) -> Tensor

pub fn linalg_cross_out(&self, out: &Tensor, other: &Tensor, dim: i64) -> Tensor

pub fn linalg_det(a: &Tensor) -> Tensor

pub fn linalg_det_out(out: &Tensor, a: &Tensor) -> Tensor

pub fn linalg_diagonal(a: &Tensor, offset: i64, dim1: i64, dim2: i64) -> Tensor

pub fn linalg_eig(&self) -> (Tensor, Tensor)

pub fn linalg_eig_out( &self, eigenvalues: &Tensor, eigenvectors: &Tensor ) -> (Tensor, Tensor)

pub fn linalg_eigh(&self, uplo: &str) -> (Tensor, Tensor)

pub fn linalg_eigh_eigvals( &self, eigvals: &Tensor, eigvecs: &Tensor, uplo: &str ) -> (Tensor, Tensor)

pub fn linalg_eigvals(&self) -> Tensor

pub fn linalg_eigvals_out(&self, out: &Tensor) -> Tensor

pub fn linalg_eigvalsh(&self, uplo: &str) -> Tensor

pub fn linalg_eigvalsh_out(&self, out: &Tensor, uplo: &str) -> Tensor

pub fn linalg_householder_product(&self, tau: &Tensor) -> Tensor

pub fn linalg_householder_product_out( &self, out: &Tensor, tau: &Tensor ) -> Tensor

pub fn linalg_inv(a: &Tensor) -> Tensor

pub fn linalg_inv_ex(a: &Tensor, check_errors: bool) -> (Tensor, Tensor)

pub fn linalg_inv_ex_inverse( inverse: &Tensor, info: &Tensor, a: &Tensor, check_errors: bool ) -> (Tensor, Tensor)

pub fn linalg_inv_out(out: &Tensor, a: &Tensor) -> Tensor

pub fn linalg_ldl_factor(&self, hermitian: bool) -> (Tensor, Tensor)

pub fn linalg_ldl_factor_ex( &self, hermitian: bool, check_errors: bool ) -> (Tensor, Tensor, Tensor)

pub fn linalg_ldl_factor_ex_out( &self, ld: &Tensor, pivots: &Tensor, info: &Tensor, hermitian: bool, check_errors: bool ) -> (Tensor, Tensor, Tensor)

pub fn linalg_ldl_factor_out( &self, ld: &Tensor, pivots: &Tensor, hermitian: bool ) -> (Tensor, Tensor)

pub fn linalg_ldl_solve( ld: &Tensor, pivots: &Tensor, b: &Tensor, hermitian: bool ) -> Tensor

pub fn linalg_ldl_solve_out( out: &Tensor, ld: &Tensor, pivots: &Tensor, b: &Tensor, hermitian: bool ) -> Tensor

pub fn linalg_lstsq( &self, b: &Tensor, rcond: impl Into<Option<f64>>, driver: &str ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn linalg_lstsq_out( &self, solution: &Tensor, residuals: &Tensor, rank: &Tensor, singular_values: &Tensor, b: &Tensor, rcond: impl Into<Option<f64>>, driver: &str ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn linalg_lu(a: &Tensor, pivot: bool) -> (Tensor, Tensor, Tensor)

pub fn linalg_lu_factor(a: &Tensor, pivot: bool) -> (Tensor, Tensor)

pub fn linalg_lu_factor_ex( a: &Tensor, pivot: bool, check_errors: bool ) -> (Tensor, Tensor, Tensor)

pub fn linalg_lu_factor_ex_out( lu: &Tensor, pivots: &Tensor, info: &Tensor, a: &Tensor, pivot: bool, check_errors: bool ) -> (Tensor, Tensor, Tensor)

pub fn linalg_lu_factor_out( lu: &Tensor, pivots: &Tensor, a: &Tensor, pivot: bool ) -> (Tensor, Tensor)

pub fn linalg_lu_out( p: &Tensor, l: &Tensor, u: &Tensor, a: &Tensor, pivot: bool ) -> (Tensor, Tensor, Tensor)

pub fn linalg_lu_solve( lu: &Tensor, pivots: &Tensor, b: &Tensor, left: bool, adjoint: bool ) -> Tensor

pub fn linalg_lu_solve_out( out: &Tensor, lu: &Tensor, pivots: &Tensor, b: &Tensor, left: bool, adjoint: bool ) -> Tensor

pub fn linalg_matmul(&self, other: &Tensor) -> Tensor

pub fn linalg_matmul_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn linalg_matrix_exp(&self) -> Tensor

pub fn linalg_matrix_exp_out(&self, out: &Tensor) -> Tensor

pub fn linalg_matrix_power(&self, n: i64) -> Tensor

pub fn linalg_matrix_power_out(&self, out: &Tensor, n: i64) -> Tensor

pub fn linalg_matrix_rank(&self, tol: f64, hermitian: bool) -> Tensor

pub fn linalg_matrix_rank_atol_rtol_float( &self, atol: impl Into<Option<f64>>, rtol: impl Into<Option<f64>>, hermitian: bool ) -> Tensor

pub fn linalg_matrix_rank_atol_rtol_float_out( &self, out: &Tensor, atol: impl Into<Option<f64>>, rtol: impl Into<Option<f64>>, hermitian: bool ) -> Tensor

pub fn linalg_matrix_rank_atol_rtol_tensor<T: Borrow<Tensor>>( &self, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Tensor

pub fn linalg_matrix_rank_atol_rtol_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Tensor

pub fn linalg_matrix_rank_out( &self, out: &Tensor, tol: f64, hermitian: bool ) -> Tensor

pub fn linalg_matrix_rank_out_tol_tensor( &self, out: &Tensor, tol: &Tensor, hermitian: bool ) -> Tensor

pub fn linalg_matrix_rank_tol_tensor( &self, tol: &Tensor, hermitian: bool ) -> Tensor

pub fn linalg_multi_dot<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn linalg_multi_dot_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T] ) -> Tensor

pub fn linalg_norm<S: Into<Scalar>>( &self, ord: S, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn linalg_norm_ord_str( &self, ord: &str, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn linalg_norm_ord_str_out( &self, out: &Tensor, ord: &str, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn linalg_norm_out<S: Into<Scalar>>( &self, out: &Tensor, ord: S, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn linalg_pinv(&self, rcond: f64, hermitian: bool) -> Tensor

pub fn linalg_pinv_atol_rtol_float( &self, atol: impl Into<Option<f64>>, rtol: impl Into<Option<f64>>, hermitian: bool ) -> Tensor

pub fn linalg_pinv_atol_rtol_float_out( &self, out: &Tensor, atol: impl Into<Option<f64>>, rtol: impl Into<Option<f64>>, hermitian: bool ) -> Tensor

pub fn linalg_pinv_atol_rtol_tensor<T: Borrow<Tensor>>( &self, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Tensor

pub fn linalg_pinv_atol_rtol_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Tensor

pub fn linalg_pinv_out( &self, out: &Tensor, rcond: f64, hermitian: bool ) -> Tensor

pub fn linalg_pinv_out_rcond_tensor( &self, out: &Tensor, rcond: &Tensor, hermitian: bool ) -> Tensor

pub fn linalg_pinv_rcond_tensor( &self, rcond: &Tensor, hermitian: bool ) -> Tensor

pub fn linalg_qr(a: &Tensor, mode: &str) -> (Tensor, Tensor)

pub fn linalg_qr_out( q: &Tensor, r: &Tensor, a: &Tensor, mode: &str ) -> (Tensor, Tensor)

pub fn linalg_slogdet(a: &Tensor) -> (Tensor, Tensor)

pub fn linalg_slogdet_out( sign: &Tensor, logabsdet: &Tensor, a: &Tensor ) -> (Tensor, Tensor)

pub fn linalg_solve(a: &Tensor, b: &Tensor, left: bool) -> Tensor

pub fn linalg_solve_ex( a: &Tensor, b: &Tensor, left: bool, check_errors: bool ) -> (Tensor, Tensor)

pub fn linalg_solve_ex_out( result: &Tensor, info: &Tensor, a: &Tensor, b: &Tensor, left: bool, check_errors: bool ) -> (Tensor, Tensor)

pub fn linalg_solve_out( out: &Tensor, a: &Tensor, b: &Tensor, left: bool ) -> Tensor

pub fn linalg_solve_triangular( &self, b: &Tensor, upper: bool, left: bool, unitriangular: bool ) -> Tensor

pub fn linalg_solve_triangular_out( &self, out: &Tensor, b: &Tensor, upper: bool, left: bool, unitriangular: bool ) -> Tensor

pub fn linalg_svd( a: &Tensor, full_matrices: bool, driver: &str ) -> (Tensor, Tensor, Tensor)

pub fn linalg_svd_u( u: &Tensor, s: &Tensor, vh: &Tensor, a: &Tensor, full_matrices: bool, driver: &str ) -> (Tensor, Tensor, Tensor)

pub fn linalg_svdvals(a: &Tensor, driver: &str) -> Tensor

pub fn linalg_svdvals_out(out: &Tensor, a: &Tensor, driver: &str) -> Tensor

pub fn linalg_tensorinv(&self, ind: i64) -> Tensor

pub fn linalg_tensorinv_out(&self, out: &Tensor, ind: i64) -> Tensor

pub fn linalg_tensorsolve( &self, other: &Tensor, dims: impl IntListOption ) -> Tensor

pub fn linalg_tensorsolve_out( &self, out: &Tensor, other: &Tensor, dims: impl IntListOption ) -> Tensor

pub fn linalg_vander(x: &Tensor, n: impl Into<Option<i64>>) -> Tensor

pub fn linalg_vecdot(x: &Tensor, y: &Tensor, dim: i64) -> Tensor

pub fn linalg_vecdot_out( out: &Tensor, x: &Tensor, y: &Tensor, dim: i64 ) -> Tensor

pub fn linear<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T> ) -> Tensor

pub fn linear_out<T: Borrow<Tensor>>( &self, out: &Tensor, 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(&self, mean: f64, std: f64) -> Tensor

pub fn log_normal_(&mut self, mean: f64, std: f64) -> Tensor

pub fn log_normal_out(&self, out: &Tensor, mean: f64, std: f64) -> Tensor

pub fn log_out(&self, out: &Tensor) -> Tensor

pub fn log_sigmoid(&self) -> Tensor

pub fn log_sigmoid_backward( &self, grad_output: &Tensor, buffer: &Tensor ) -> Tensor

pub fn log_sigmoid_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, buffer: &Tensor ) -> Tensor

pub fn log_sigmoid_out(&self, out: &Tensor) -> Tensor

pub fn log_softmax(&self, dim: i64, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn log_softmax_int_out( &self, out: &Tensor, dim: i64, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn logaddexp(&self, other: &Tensor) -> Tensor

pub fn logaddexp2(&self, other: &Tensor) -> Tensor

pub fn logaddexp2_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logaddexp_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logcumsumexp(&self, dim: i64) -> Tensor

pub fn logcumsumexp_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn logdet(&self) -> Tensor

pub fn logical_and(&self, other: &Tensor) -> Tensor

pub fn logical_and_(&mut self, other: &Tensor) -> Tensor

pub fn logical_and_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logical_not(&self) -> Tensor

pub fn logical_not_(&mut self) -> Tensor

pub fn logical_not_out(&self, out: &Tensor) -> Tensor

pub fn logical_or(&self, other: &Tensor) -> Tensor

pub fn logical_or_(&mut self, other: &Tensor) -> Tensor

pub fn logical_or_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logical_xor(&self, other: &Tensor) -> Tensor

pub fn logical_xor_(&mut self, other: &Tensor) -> Tensor

pub fn logical_xor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn logit(&self, eps: impl Into<Option<f64>>) -> Tensor

pub fn logit_(&mut self, eps: impl Into<Option<f64>>) -> Tensor

pub fn logit_backward( &self, grad_output: &Tensor, eps: impl Into<Option<f64>> ) -> Tensor

pub fn logit_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, eps: impl Into<Option<f64>> ) -> Tensor

pub fn logit_out(&self, out: &Tensor, eps: impl Into<Option<f64>>) -> Tensor

pub fn logspace<S: Into<Scalar>>( start: S, end: S, steps: 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: impl IntList, keepdim: bool) -> Tensor

pub fn logsumexp_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool ) -> Tensor

pub fn lstm<T: Borrow<Tensor>>( &self, hx: &[T], params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> (Tensor, Tensor, Tensor)

pub fn lstm_cell<T: Borrow<Tensor>>( &self, hx: &[T], w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> (Tensor, Tensor)

pub fn lstm_data<T: Borrow<Tensor>>( data: &Tensor, batch_sizes: &Tensor, hx: &[T], params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool ) -> (Tensor, Tensor, Tensor)

pub fn lstm_mps_backward<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &[T], out2: &[T], grad_y: Option<T>, grad_hy: Option<T>, grad_cy: Option<T>, z_state: &Tensor, cell_state_fwd: &Tensor, layersoutputs: &Tensor, hx: &[T], params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool )

pub fn lt<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn lt_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn lt_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn lt_tensor(&self, other: &Tensor) -> Tensor

pub fn lt_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn lt_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn lu_solve(&self, lu_data: &Tensor, lu_pivots: &Tensor) -> Tensor

pub fn lu_solve_out( &self, out: &Tensor, lu_data: &Tensor, lu_pivots: &Tensor ) -> Tensor

pub fn lu_unpack( lu_data: &Tensor, lu_pivots: &Tensor, unpack_data: bool, unpack_pivots: bool ) -> (Tensor, Tensor, Tensor)

pub fn lu_unpack_out( p: &Tensor, l: &Tensor, u: &Tensor, lu_data: &Tensor, lu_pivots: &Tensor, unpack_data: bool, unpack_pivots: bool ) -> (Tensor, Tensor, Tensor)

pub fn margin_ranking_loss( input1: &Tensor, input2: &Tensor, target: &Tensor, margin: f64, reduction: Reduction ) -> Tensor

pub fn masked_fill<S: Into<Scalar>>(&self, mask: &Tensor, value: S) -> Tensor

pub fn masked_fill_<S: Into<Scalar>>( &mut self, mask: &Tensor, value: S ) -> Tensor

pub fn masked_fill_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, mask: &Tensor, value: S ) -> Tensor

pub fn masked_fill_tensor(&self, mask: &Tensor, value: &Tensor) -> Tensor

pub fn masked_fill_tensor_(&mut self, mask: &Tensor, value: &Tensor) -> Tensor

pub fn masked_fill_tensor_out( &self, out: &Tensor, 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_scatter_out( &self, out: &Tensor, mask: &Tensor, source: &Tensor ) -> Tensor

pub fn masked_select(&self, mask: &Tensor) -> Tensor

pub fn masked_select_backward(&self, grad: &Tensor, mask: &Tensor) -> Tensor

pub fn masked_select_out(&self, out: &Tensor, mask: &Tensor) -> Tensor

pub fn matmul(&self, other: &Tensor) -> Tensor

pub fn matmul_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn matrix_exp(&self) -> Tensor

pub fn matrix_exp_backward(&self, grad: &Tensor) -> Tensor

pub fn matrix_h(&self) -> Tensor

pub fn matrix_power(&self, n: i64) -> Tensor

pub fn matrix_power_out(&self, out: &Tensor, n: i64) -> Tensor

pub fn max(&self) -> Tensor

pub fn max_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn max_dim_max( &self, max: &Tensor, max_values: &Tensor, dim: i64, keepdim: bool ) -> (Tensor, Tensor)

pub fn max_other(&self, other: &Tensor) -> Tensor

pub fn max_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn max_pool1d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn max_pool1d_with_indices( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> (Tensor, Tensor)

pub fn max_pool2d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn max_pool2d_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn max_pool2d_backward_out( &self, out: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn max_pool2d_with_indices( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> (Tensor, Tensor)

pub fn max_pool2d_with_indices_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool, indices: &Tensor ) -> Tensor

pub fn max_pool2d_with_indices_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool, indices: &Tensor ) -> Tensor

pub fn max_pool2d_with_indices_out( &self, out: &Tensor, indices: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> (Tensor, Tensor)

pub fn max_pool3d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn max_pool3d_with_indices( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> (Tensor, Tensor)

pub fn max_pool3d_with_indices_backward( &self, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool, indices: &Tensor ) -> Tensor

pub fn max_pool3d_with_indices_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool, indices: &Tensor ) -> Tensor

pub fn max_pool3d_with_indices_out( &self, out: &Tensor, indices: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> (Tensor, Tensor)

pub fn max_unary_out(&self, out: &Tensor) -> Tensor

pub fn max_unpool2d( &self, indices: &Tensor, output_size: impl IntList ) -> Tensor

pub fn max_unpool2d_out( &self, out: &Tensor, indices: &Tensor, output_size: impl IntList ) -> Tensor

pub fn max_unpool3d( &self, indices: &Tensor, output_size: impl IntList, stride: impl IntList, padding: impl IntList ) -> Tensor

pub fn max_unpool3d_out( &self, out: &Tensor, indices: &Tensor, output_size: impl IntList, stride: impl IntList, padding: impl IntList ) -> Tensor

pub fn maximum(&self, other: &Tensor) -> Tensor

pub fn maximum_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn mean(&self, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn mean_dim( &self, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn mean_out( &self, out: &Tensor, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn median(&self) -> Tensor

pub fn median_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn median_dim_values( &self, values: &Tensor, indices: &Tensor, dim: i64, keepdim: bool ) -> (Tensor, Tensor)

pub fn median_out(&self, out: &Tensor) -> Tensor

pub fn meshgrid<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>

pub fn meshgrid_indexing<T: Borrow<Tensor>>( tensors: &[T], indexing: &str ) -> Vec<Tensor>

pub fn mh(&self) -> Tensor

pub fn min(&self) -> Tensor

pub fn min_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn min_dim_min( &self, min: &Tensor, min_indices: &Tensor, dim: i64, keepdim: bool ) -> (Tensor, Tensor)

pub fn min_other(&self, other: &Tensor) -> Tensor

pub fn min_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn min_unary_out(&self, out: &Tensor) -> Tensor

pub fn minimum(&self, other: &Tensor) -> Tensor

pub fn minimum_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn miopen_batch_norm<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, running_mean: Option<T>, running_var: Option<T>, training: bool, exponential_average_factor: f64, epsilon: f64 ) -> (Tensor, Tensor, Tensor)

pub fn miopen_batch_norm_backward<T: Borrow<Tensor>>( &self, grad_output: &Tensor, weight: &Tensor, running_mean: Option<T>, running_var: Option<T>, save_mean: Option<T>, save_var: Option<T>, epsilon: f64 ) -> (Tensor, Tensor, Tensor)

pub fn miopen_batch_norm_backward_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, 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_batch_norm_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, 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_convolution<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Tensor

pub fn miopen_convolution_add_relu<T: Borrow<Tensor>, S: Into<Scalar>>( &self, weight: &Tensor, z: &Tensor, alpha: S, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn miopen_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Tensor

pub fn miopen_convolution_relu<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn miopen_convolution_transpose<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Tensor

pub fn miopen_convolution_transpose_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, output_padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Tensor

pub fn miopen_depthwise_convolution<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Tensor

pub fn miopen_depthwise_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, 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: impl IntList, dropout_state: Option<T> ) -> (Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn miopen_rnn_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, out4: &Tensor, 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: impl IntList, dropout_state: Option<T> ) -> (Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn mish(&self) -> Tensor

pub fn mish_(&mut self) -> Tensor

pub fn mish_backward(&self, grad_output: &Tensor) -> Tensor

pub fn mish_out(&self, out: &Tensor) -> Tensor

pub fn mkldnn_adaptive_avg_pool2d(&self, output_size: impl IntList) -> Tensor

pub fn mkldnn_adaptive_avg_pool2d_backward( &self, grad_output: &Tensor ) -> Tensor

pub fn mkldnn_adaptive_avg_pool2d_backward_out( &self, out: &Tensor, grad_output: &Tensor ) -> Tensor

pub fn mkldnn_adaptive_avg_pool2d_out( &self, out: &Tensor, output_size: impl IntList ) -> Tensor

pub fn mkldnn_convolution<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn mkldnn_convolution_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn mkldnn_linear<T: Borrow<Tensor>>( &self, weight: &Tensor, bias: Option<T> ) -> Tensor

pub fn mkldnn_linear_backward_input( input_size: impl IntList, grad_output: &Tensor, weight: &Tensor ) -> Tensor

pub fn mkldnn_linear_backward_input_out( out: &Tensor, input_size: impl IntList, grad_output: &Tensor, weight: &Tensor ) -> Tensor

pub fn mkldnn_linear_backward_weights( &self, grad_output: &Tensor, weight: &Tensor, bias_defined: bool ) -> (Tensor, Tensor)

pub fn mkldnn_linear_backward_weights_out( &self, out0: &Tensor, out1: &Tensor, grad_output: &Tensor, weight: &Tensor, bias_defined: bool ) -> (Tensor, Tensor)

pub fn mkldnn_linear_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, bias: Option<T> ) -> Tensor

pub fn mkldnn_max_pool2d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn mkldnn_max_pool2d_backward( &self, grad_output: &Tensor, output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn mkldnn_max_pool2d_backward_out( &self, out: &Tensor, grad_output: &Tensor, output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn mkldnn_max_pool2d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn mkldnn_max_pool3d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn mkldnn_max_pool3d_backward( &self, grad_output: &Tensor, output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn mkldnn_max_pool3d_backward_out( &self, out: &Tensor, grad_output: &Tensor, output: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn mkldnn_max_pool3d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn mkldnn_reorder_conv2d_weight( &self, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, input_size: impl IntListOption ) -> Tensor

pub fn mkldnn_reorder_conv2d_weight_out( &self, out: &Tensor, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, input_size: impl IntListOption ) -> Tensor

pub fn mkldnn_reorder_conv3d_weight( &self, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn mkldnn_reorder_conv3d_weight_out( &self, out: &Tensor, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensor

pub fn mkldnn_rnn_layer( &self, weight0: &Tensor, weight1: &Tensor, weight2: &Tensor, weight3: &Tensor, hx_: &Tensor, cx_: &Tensor, reverse: bool, batch_sizes: impl IntList, mode: i64, hidden_size: i64, num_layers: i64, has_biases: bool, bidirectional: bool, batch_first: bool, train: bool ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn mkldnn_rnn_layer_backward<T: Borrow<Tensor>>( &self, weight1: &Tensor, weight2: &Tensor, weight3: &Tensor, weight4: &Tensor, hx_: &Tensor, cx_tmp: &Tensor, output: &Tensor, hy_: &Tensor, cy_: &Tensor, grad_output: Option<T>, grad_hy: Option<T>, grad_cy: Option<T>, reverse: bool, mode: i64, hidden_size: i64, num_layers: i64, has_biases: bool, train: bool, bidirectional: bool, batch_sizes: impl IntList, batch_first: bool, workspace: &Tensor ) -> (Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn mkldnn_rnn_layer_backward_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, out4: &Tensor, out5: &Tensor, out6: &Tensor, weight1: &Tensor, weight2: &Tensor, weight3: &Tensor, weight4: &Tensor, hx_: &Tensor, cx_tmp: &Tensor, output: &Tensor, hy_: &Tensor, cy_: &Tensor, grad_output: Option<T>, grad_hy: Option<T>, grad_cy: Option<T>, reverse: bool, mode: i64, hidden_size: i64, num_layers: i64, has_biases: bool, train: bool, bidirectional: bool, batch_sizes: impl IntList, batch_first: bool, workspace: &Tensor ) -> (Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor)

pub fn mkldnn_rnn_layer_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, out3: &Tensor, weight0: &Tensor, weight1: &Tensor, weight2: &Tensor, weight3: &Tensor, hx_: &Tensor, cx_: &Tensor, reverse: bool, batch_sizes: impl IntList, mode: i64, hidden_size: i64, num_layers: i64, has_biases: bool, bidirectional: bool, batch_first: bool, train: bool ) -> (Tensor, Tensor, Tensor, Tensor)

pub fn mm(&self, mat2: &Tensor) -> Tensor

pub fn mm_out(&self, out: &Tensor, mat2: &Tensor) -> Tensor

pub fn mode(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn mode_values( &self, values: &Tensor, indices: &Tensor, dim: i64, keepdim: bool ) -> (Tensor, Tensor)

pub fn moveaxis( &self, source: impl IntList, destination: impl IntList ) -> Tensor

pub fn moveaxis_int(&self, source: i64, destination: i64) -> Tensor

pub fn movedim(&self, source: impl IntList, destination: impl IntList) -> Tensor

pub fn movedim_int(&self, source: i64, destination: i64) -> Tensor

pub fn mse_loss(&self, target: &Tensor, reduction: Reduction) -> Tensor

pub fn mse_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction ) -> Tensor

pub fn mse_loss_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction ) -> Tensor

pub fn mse_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction ) -> Tensor

pub fn msort(&self) -> Tensor

pub fn msort_out(&self, out: &Tensor) -> Tensor

pub fn mt(&self) -> Tensor

pub fn g_mul(&self, other: &Tensor) -> Tensor

pub fn g_mul_(&mut self, other: &Tensor) -> Tensor

pub fn mul_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn g_mul_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_mul_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn mul_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn multi_margin_loss_backward<T: Borrow<Tensor>, S: Into<Scalar>>( &self, grad_output: &Tensor, target: &Tensor, p: S, margin: S, weight: Option<T>, reduction: Reduction ) -> Tensor

pub fn multi_margin_loss_backward_grad_input<T: Borrow<Tensor>, S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, p: S, margin: S, weight: Option<T>, reduction: Reduction ) -> Tensor

pub fn multilabel_margin_loss( &self, target: &Tensor, reduction: Reduction ) -> Tensor

pub fn multilabel_margin_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction, is_target: &Tensor ) -> Tensor

pub fn multilabel_margin_loss_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction, is_target: &Tensor ) -> Tensor

pub fn multilabel_margin_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction ) -> Tensor

pub fn multinomial(&self, num_samples: i64, replacement: bool) -> Tensor

pub fn multinomial_out( &self, out: &Tensor, num_samples: i64, replacement: bool ) -> Tensor

pub fn multiply(&self, other: &Tensor) -> Tensor

pub fn multiply_(&mut self, other: &Tensor) -> Tensor

pub fn multiply_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn multiply_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn multiply_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn mv(&self, vec: &Tensor) -> Tensor

pub fn mv_out(&self, out: &Tensor, vec: &Tensor) -> Tensor

pub fn mvlgamma(&self, p: i64) -> Tensor

pub fn mvlgamma_(&mut self, p: i64) -> Tensor

pub fn mvlgamma_out(&self, out: &Tensor, p: i64) -> Tensor

pub fn nan_to_num( &self, nan: impl Into<Option<f64>>, posinf: impl Into<Option<f64>>, neginf: impl Into<Option<f64>> ) -> Tensor

pub fn nan_to_num_( &mut self, nan: impl Into<Option<f64>>, posinf: impl Into<Option<f64>>, neginf: impl Into<Option<f64>> ) -> Tensor

pub fn nan_to_num_out( &self, out: &Tensor, nan: impl Into<Option<f64>>, posinf: impl Into<Option<f64>>, neginf: impl Into<Option<f64>> ) -> Tensor

pub fn nanmean( &self, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn nanmean_out( &self, out: &Tensor, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn nanmedian(&self) -> Tensor

pub fn nanmedian_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)

pub fn nanmedian_dim_values( &self, values: &Tensor, indices: &Tensor, dim: i64, keepdim: bool ) -> (Tensor, Tensor)

pub fn nanmedian_out(&self, out: &Tensor) -> Tensor

pub fn nanquantile( &self, q: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Tensor

pub fn nanquantile_out( &self, out: &Tensor, q: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Tensor

pub fn nanquantile_scalar( &self, q: f64, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Tensor

pub fn nanquantile_scalar_out( &self, out: &Tensor, q: f64, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Tensor

pub fn nansum( &self, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn nansum_out( &self, out: &Tensor, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn narrow(&self, dim: i64, start: i64, length: i64) -> Tensor

pub fn narrow_copy(&self, dim: i64, start: i64, length: i64) -> Tensor

pub fn narrow_copy_out( &self, out: &Tensor, dim: i64, start: i64, length: i64 ) -> Tensor

pub fn narrow_tensor(&self, dim: i64, start: &Tensor, length: i64) -> Tensor

pub fn native_batch_norm<T: Borrow<Tensor>>( &self, weight: Option<T>, bias: Option<T>, running_mean: Option<T>, running_var: Option<T>, training: bool, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn native_batch_norm_out<T: Borrow<Tensor>>( &self, out: &Tensor, save_mean: &Tensor, save_invstd: &Tensor, weight: Option<T>, bias: Option<T>, running_mean: Option<T>, running_var: Option<T>, training: bool, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn native_channel_shuffle(&self, groups: i64) -> Tensor

pub fn native_dropout(&self, p: f64, train: bool) -> (Tensor, Tensor)

pub fn native_dropout_backward( grad_output: &Tensor, mask: &Tensor, scale: f64 ) -> Tensor

pub fn native_dropout_backward_out( out: &Tensor, grad_output: &Tensor, mask: &Tensor, scale: f64 ) -> Tensor

pub fn native_dropout_out( &self, out0: &Tensor, out1: &Tensor, p: f64, train: bool ) -> (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_group_norm_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, weight: Option<T>, bias: Option<T>, n: i64, c: i64, hxw: i64, group: i64, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn native_layer_norm<T: Borrow<Tensor>>( &self, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn native_layer_norm_out<T: Borrow<Tensor>>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64 ) -> (Tensor, Tensor, Tensor)

pub fn native_norm(&self) -> Tensor

pub fn native_norm_out(&self, out: &Tensor) -> Tensor

pub fn native_norm_scalaropt_dim_dtype<S: Into<Scalar>>( &self, p: S, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn native_norm_scalaropt_dim_dtype_out<S: Into<Scalar>>( &self, out: &Tensor, p: S, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn ne<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn ne_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn ne_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn ne_tensor(&self, other: &Tensor) -> Tensor

pub fn ne_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn ne_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn neg(&self) -> Tensor

pub fn neg_(&mut self) -> Tensor

pub fn neg_out(&self, out: &Tensor) -> Tensor

pub fn negative(&self) -> Tensor

pub fn negative_(&mut self) -> Tensor

pub fn negative_out(&self, out: &Tensor) -> Tensor

pub fn nested_to_padded_tensor( &self, padding: f64, output_size: impl IntListOption ) -> Tensor

pub fn new_empty(&self, size: impl IntList, options: (Kind, Device)) -> Tensor

pub fn new_empty_out(&self, out: &Tensor, size: impl IntList) -> Tensor

pub fn new_empty_strided( &self, size: impl IntList, stride: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn new_empty_strided_out( &self, out: &Tensor, size: impl IntList, stride: impl IntList ) -> Tensor

pub fn new_full<S: Into<Scalar>>( &self, size: impl IntList, fill_value: S, options: (Kind, Device) ) -> Tensor

pub fn new_full_out<S: Into<Scalar>>( &self, out: &Tensor, size: impl IntList, fill_value: S ) -> Tensor

pub fn new_ones(&self, size: impl IntList, options: (Kind, Device)) -> Tensor

pub fn new_ones_out(&self, out: &Tensor, size: impl IntList) -> Tensor

pub fn new_zeros(&self, size: impl IntList, options: (Kind, Device)) -> Tensor

pub fn new_zeros_out(&self, out: &Tensor, size: impl IntList) -> Tensor

pub fn nextafter(&self, other: &Tensor) -> Tensor

pub fn nextafter_(&mut self, other: &Tensor) -> Tensor

pub fn nextafter_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn g_nll_loss<T: Borrow<Tensor>>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Tensor

pub fn nll_loss2d<T: Borrow<Tensor>>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Tensor

pub fn nll_loss2d_backward<T: Borrow<Tensor>>( &self, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Tensor

pub fn nll_loss2d_backward_grad_input<T: Borrow<Tensor>>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Tensor

pub fn nll_loss2d_out<T: Borrow<Tensor>>( &self, out: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Tensor

pub fn nll_loss_backward<T: Borrow<Tensor>>( &self, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Tensor

pub fn nll_loss_backward_grad_input<T: Borrow<Tensor>>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Tensor

pub fn nll_loss_nd<T: Borrow<Tensor>>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Tensor

pub fn nll_loss_out<T: Borrow<Tensor>>( &self, out: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Tensor

pub fn nonzero(&self) -> Tensor

pub fn nonzero_numpy(&self) -> Vec<Tensor>

pub fn nonzero_out(&self, out: &Tensor) -> Tensor

pub fn nonzero_static(&self, size: i64, fill_value: i64) -> Tensor

pub fn nonzero_static_out( &self, out: &Tensor, size: i64, fill_value: i64 ) -> Tensor

pub fn norm(&self) -> Tensor

pub fn norm_dtype_out<S: Into<Scalar>>( &self, out: &Tensor, p: S, dim: impl IntList, 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: impl IntList, keepdim: bool ) -> Tensor

pub fn norm_scalar_out(&self, out: &Tensor) -> Tensor

pub fn norm_scalaropt_dim<S: Into<Scalar>>( &self, p: S, dim: impl IntList, keepdim: bool ) -> Tensor

pub fn norm_scalaropt_dim_dtype<S: Into<Scalar>>( &self, p: S, dim: impl IntList, keepdim: bool, dtype: Kind ) -> Tensor

pub fn norm_scalaropt_dtype<S: Into<Scalar>>(&self, p: S, dtype: Kind) -> Tensor

pub fn norm_scalaropt_dtype_out<S: Into<Scalar>>( &self, out: &Tensor, p: S, dtype: Kind ) -> Tensor

pub fn normal_(&mut self, mean: f64, std: f64) -> Tensor

pub fn normal_functional(&self, mean: f64, std: f64) -> Tensor

pub fn not_equal<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn not_equal_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn not_equal_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn not_equal_tensor(&self, other: &Tensor) -> Tensor

pub fn not_equal_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn not_equal_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn nuclear_norm(&self, keepdim: bool) -> Tensor

pub fn nuclear_norm_dim(&self, dim: impl IntList, keepdim: bool) -> Tensor

pub fn nuclear_norm_dim_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool ) -> Tensor

pub fn nuclear_norm_out(&self, out: &Tensor, keepdim: bool) -> Tensor

pub fn numpy_t(&self) -> Tensor

pub fn one_hot(&self, num_classes: i64) -> Tensor

pub fn ones(size: impl IntList, options: (Kind, Device)) -> Tensor

pub fn ones_like(&self) -> Tensor

pub fn ones_like_out(&self, out: &Tensor) -> Tensor

pub fn ones_out(out: &Tensor, size: impl IntList) -> Tensor

pub fn orgqr(&self, input2: &Tensor) -> Tensor

pub fn orgqr_out(&self, out: &Tensor, input2: &Tensor) -> Tensor

pub fn ormqr( &self, input2: &Tensor, input3: &Tensor, left: bool, transpose: bool ) -> Tensor

pub fn ormqr_out( &self, out: &Tensor, input2: &Tensor, input3: &Tensor, left: bool, transpose: bool ) -> Tensor

pub fn outer(&self, vec2: &Tensor) -> Tensor

pub fn outer_out(&self, out: &Tensor, vec2: &Tensor) -> Tensor

pub fn output_nr(&self) -> i64

pub fn pad( &self, pad: impl IntList, mode: &str, value: impl Into<Option<f64>> ) -> Tensor

pub fn pad_sequence<T: Borrow<Tensor>>( sequences: &[T], batch_first: bool, padding_value: f64 ) -> Tensor

pub fn pairwise_distance( x1: &Tensor, x2: &Tensor, p: f64, eps: f64, keepdim: bool ) -> Tensor

pub fn pdist(&self, p: f64) -> Tensor

pub fn permute(&self, dims: impl IntList) -> Tensor

pub fn permute_copy(&self, dims: impl IntList) -> Tensor

pub fn permute_copy_out(&self, out: &Tensor, dims: impl IntList) -> Tensor

pub fn pin_memory(&self, device: Device) -> Tensor

pub fn pinverse(&self, rcond: f64) -> Tensor

pub fn pixel_shuffle(&self, upscale_factor: i64) -> Tensor

pub fn pixel_shuffle_out(&self, out: &Tensor, upscale_factor: i64) -> Tensor

pub fn pixel_unshuffle(&self, downscale_factor: i64) -> Tensor

pub fn pixel_unshuffle_out(&self, out: &Tensor, downscale_factor: i64) -> Tensor

pub fn poisson(&self) -> Tensor

pub fn poisson_nll_loss( &self, target: &Tensor, log_input: bool, full: bool, eps: f64, reduction: Reduction ) -> Tensor

pub fn poisson_out(&self, out: &Tensor) -> Tensor

pub fn polar(abs: &Tensor, angle: &Tensor) -> Tensor

pub fn polar_out(out: &Tensor, abs: &Tensor, angle: &Tensor) -> Tensor

pub fn polygamma(&self, n: i64) -> Tensor

pub fn polygamma_(&mut self, n: i64) -> Tensor

pub fn polygamma_out(&self, out: &Tensor, n: i64) -> Tensor

pub fn positive(&self) -> Tensor

pub fn pow(&self, exponent: &Tensor) -> Tensor

pub fn pow_<S: Into<Scalar>>(&mut self, exponent: S) -> Tensor

pub fn pow_scalar<S: Into<Scalar>>(self_scalar: S, exponent: &Tensor) -> Tensor

pub fn pow_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, exponent: &Tensor ) -> Tensor

pub fn pow_tensor_(&mut self, exponent: &Tensor) -> Tensor

pub fn pow_tensor_scalar<S: Into<Scalar>>(&self, exponent: S) -> Tensor

pub fn pow_tensor_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, exponent: S ) -> Tensor

pub fn pow_tensor_tensor_out(&self, out: &Tensor, exponent: &Tensor) -> Tensor

pub fn prelu(&self, weight: &Tensor) -> Tensor

pub fn prod(&self, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn prod_dim_int( &self, dim: i64, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn prod_int_out( &self, out: &Tensor, dim: i64, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn prod_out(&self, out: &Tensor, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn put(&self, index: &Tensor, source: &Tensor, accumulate: bool) -> Tensor

pub fn put_( &mut self, index: &Tensor, source: &Tensor, accumulate: bool ) -> Tensor

pub fn put_out( &self, out: &Tensor, index: &Tensor, source: &Tensor, accumulate: bool ) -> Tensor

pub fn q_per_channel_axis(&self) -> i64

pub fn q_per_channel_scales(&self) -> Tensor

pub fn q_per_channel_scales_out(&self, out: &Tensor) -> Tensor

pub fn q_per_channel_zero_points(&self) -> Tensor

pub fn q_per_channel_zero_points_out(&self, out: &Tensor) -> Tensor

pub fn q_scale(&self) -> f64

pub fn q_zero_point(&self) -> i64

pub fn qr(&self, some: bool) -> (Tensor, Tensor)

pub fn qr_q(&self, q: &Tensor, r: &Tensor, some: bool) -> (Tensor, Tensor)

pub fn quantile( &self, q: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Tensor

pub fn quantile_out( &self, out: &Tensor, q: &Tensor, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Tensor

pub fn quantile_scalar( &self, q: f64, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Tensor

pub fn quantile_scalar_out( &self, out: &Tensor, q: f64, dim: impl Into<Option<i64>>, keepdim: bool, interpolation: &str ) -> Tensor

pub fn quantize_per_channel( &self, scales: &Tensor, zero_points: &Tensor, axis: i64, dtype: Kind ) -> Tensor

pub fn quantize_per_channel_out( &self, out: &Tensor, scales: &Tensor, zero_points: &Tensor, axis: i64, dtype: Kind ) -> Tensor

pub fn quantize_per_tensor( &self, scale: f64, zero_point: i64, dtype: Kind ) -> Tensor

pub fn quantize_per_tensor_dynamic( &self, dtype: Kind, reduce_range: bool ) -> Tensor

pub fn quantize_per_tensor_dynamic_out( &self, out: &Tensor, dtype: Kind, reduce_range: bool ) -> Tensor

pub fn quantize_per_tensor_out( &self, out: &Tensor, scale: f64, zero_point: i64, dtype: Kind ) -> Tensor

pub fn quantize_per_tensor_tensor_qparams( &self, scale: &Tensor, zero_point: &Tensor, dtype: Kind ) -> Tensor

pub fn quantize_per_tensor_tensor_qparams_out( &self, out: &Tensor, scale: &Tensor, zero_point: &Tensor, dtype: Kind ) -> Tensor

pub fn quantize_per_tensor_tensors<T: Borrow<Tensor>>( tensors: &[T], scales: &Tensor, zero_points: &Tensor, dtype: Kind ) -> Vec<Tensor>

pub fn quantize_per_tensor_tensors_out<T: Borrow<Tensor>>( out: &[T], tensors: &[T], scales: &Tensor, zero_points: &Tensor, dtype: Kind )

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_batch_norm_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: Option<T>, bias: Option<T>, mean: &Tensor, var: &Tensor, eps: f64, output_scale: f64, output_zero_point: i64 ) -> Tensor

pub fn quantized_gru_cell<S: Into<Scalar>>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: &Tensor, b_hh: &Tensor, packed_ih: &Tensor, packed_hh: &Tensor, col_offsets_ih: &Tensor, col_offsets_hh: &Tensor, scale_ih: S, scale_hh: S, zero_point_ih: S, zero_point_hh: S ) -> Tensor

pub fn quantized_lstm_cell<T: Borrow<Tensor>, S: Into<Scalar>>( &self, hx: &[T], w_ih: &Tensor, w_hh: &Tensor, b_ih: &Tensor, b_hh: &Tensor, packed_ih: &Tensor, packed_hh: &Tensor, col_offsets_ih: &Tensor, col_offsets_hh: &Tensor, scale_ih: S, scale_hh: S, zero_point_ih: S, zero_point_hh: S ) -> (Tensor, Tensor)

pub fn quantized_max_pool1d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn quantized_max_pool1d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn quantized_max_pool2d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn quantized_max_pool2d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn quantized_max_pool3d( &self, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, ceil_mode: bool ) -> Tensor

pub fn quantized_max_pool3d_out( &self, out: &Tensor, kernel_size: impl IntList, stride: impl IntList, padding: impl IntList, dilation: impl IntList, 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: impl IntList, options: (Kind, Device)) -> Tensor

pub fn rand_like(&self) -> Tensor

pub fn rand_like_out(&self, out: &Tensor) -> Tensor

pub fn rand_out(out: &Tensor, size: impl IntList) -> Tensor

pub fn randint(high: i64, size: impl IntList, options: (Kind, Device)) -> Tensor

pub fn randint_like(&self, high: i64) -> Tensor

pub fn randint_like_low_dtype(&self, low: i64, high: i64) -> Tensor

pub fn randint_like_low_dtype_out( &self, out: &Tensor, low: i64, high: i64 ) -> Tensor

pub fn randint_like_out(&self, out: &Tensor, high: i64) -> Tensor

pub fn randint_low( low: i64, high: i64, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn randint_low_out( out: &Tensor, low: i64, high: i64, size: impl IntList ) -> Tensor

pub fn randint_out(out: &Tensor, high: i64, size: impl IntList) -> Tensor

pub fn randn(size: impl IntList, options: (Kind, Device)) -> Tensor

pub fn randn_like(&self) -> Tensor

pub fn randn_like_out(&self, out: &Tensor) -> Tensor

pub fn randn_out(out: &Tensor, size: impl IntList) -> Tensor

pub fn random(&self) -> Tensor

pub fn random_(&mut self) -> Tensor

pub fn random_from(&self, from: i64, to: impl Into<Option<i64>>) -> Tensor

pub fn random_from_(&mut self, from: i64, to: impl Into<Option<i64>>) -> Tensor

pub fn random_from_out( &self, out: &Tensor, from: i64, to: impl Into<Option<i64>> ) -> Tensor

pub fn random_out(&self, out: &Tensor) -> Tensor

pub fn random_to(&self, to: i64) -> Tensor

pub fn random_to_(&mut self, to: i64) -> Tensor

pub fn random_to_out(&self, out: &Tensor, to: i64) -> Tensor

pub fn randperm(n: i64, options: (Kind, Device)) -> Tensor

pub fn randperm_out(out: &Tensor, n: i64) -> Tensor

pub fn range<S: Into<Scalar>>( start: S, end: S, options: (Kind, Device) ) -> Tensor

pub fn range_out<S: Into<Scalar>>(out: &Tensor, start: S, end: S) -> Tensor

pub fn range_out_<S: Into<Scalar>>(out: &Tensor, start: S, end: S) -> Tensor

pub fn range_step<S: Into<Scalar>>( start: S, end: S, options: (Kind, Device) ) -> Tensor

pub fn ravel(&self) -> Tensor

pub fn real(&self) -> Tensor

pub fn reciprocal(&self) -> Tensor

pub fn reciprocal_(&mut self) -> Tensor

pub fn reciprocal_out(&self, out: &Tensor) -> Tensor

pub fn reflection_pad1d(&self, padding: impl IntList) -> Tensor

pub fn reflection_pad1d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn reflection_pad1d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn reflection_pad1d_out( &self, out: &Tensor, padding: impl IntList ) -> Tensor

pub fn reflection_pad2d(&self, padding: impl IntList) -> Tensor

pub fn reflection_pad2d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn reflection_pad2d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn reflection_pad2d_out( &self, out: &Tensor, padding: impl IntList ) -> Tensor

pub fn reflection_pad3d(&self, padding: impl IntList) -> Tensor

pub fn reflection_pad3d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn reflection_pad3d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn reflection_pad3d_out( &self, out: &Tensor, padding: impl IntList ) -> Tensor

pub fn relu(&self) -> Tensor

pub fn relu6(&self) -> Tensor

pub fn relu6_(&mut self) -> Tensor

pub fn relu_(&mut self) -> Tensor

pub fn relu_out(&self, out: &Tensor) -> Tensor

pub fn remainder<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn remainder_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn remainder_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn remainder_scalar_tensor<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn remainder_scalar_tensor_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn remainder_tensor(&self, other: &Tensor) -> Tensor

pub fn remainder_tensor_(&mut self, other: &Tensor) -> Tensor

pub fn remainder_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn renorm<S: Into<Scalar>>(&self, p: S, dim: i64, maxnorm: S) -> Tensor

pub fn renorm_<S: Into<Scalar>>(&mut self, p: S, dim: i64, maxnorm: S) -> Tensor

pub fn renorm_out<S: Into<Scalar>>( &self, out: &Tensor, p: S, dim: i64, maxnorm: S ) -> Tensor

pub fn repeat(&self, repeats: impl IntList) -> Tensor

pub fn repeat_interleave( repeats: &Tensor, output_size: impl Into<Option<i64>> ) -> Tensor

pub fn repeat_interleave_self_int( &self, repeats: i64, dim: impl Into<Option<i64>>, output_size: impl Into<Option<i64>> ) -> Tensor

pub fn repeat_interleave_self_tensor( &self, repeats: &Tensor, dim: impl Into<Option<i64>>, output_size: impl Into<Option<i64>> ) -> Tensor

pub fn repeat_interleave_tensor_out( out: &Tensor, repeats: &Tensor, output_size: impl Into<Option<i64>> ) -> Tensor

pub fn repeat_out(&self, out: &Tensor, repeats: impl IntList) -> Tensor

pub fn replication_pad1d(&self, padding: impl IntList) -> Tensor

pub fn replication_pad1d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn replication_pad1d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn replication_pad1d_out( &self, out: &Tensor, padding: impl IntList ) -> Tensor

pub fn replication_pad2d(&self, padding: impl IntList) -> Tensor

pub fn replication_pad2d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn replication_pad2d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn replication_pad2d_out( &self, out: &Tensor, padding: impl IntList ) -> Tensor

pub fn replication_pad3d(&self, padding: impl IntList) -> Tensor

pub fn replication_pad3d_backward( &self, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn replication_pad3d_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, padding: impl IntList ) -> Tensor

pub fn replication_pad3d_out( &self, out: &Tensor, padding: impl IntList ) -> Tensor

pub fn requires_grad_(&mut self, requires_grad: bool) -> Tensor

pub fn reshape(&self, shape: impl IntList) -> Tensor

pub fn reshape_as(&self, other: &Tensor) -> Tensor

pub fn resize(&self, size: impl IntList) -> Tensor

pub fn resize_(&mut self, size: impl IntList) -> Tensor

pub fn resize_as(&self, the_template: &Tensor) -> Tensor

pub fn resize_as_(&mut self, the_template: &Tensor) -> Tensor

pub fn resize_as_out(&self, out: &Tensor, the_template: &Tensor) -> Tensor

pub fn resize_as_sparse(&self, the_template: &Tensor) -> Tensor

pub fn resize_as_sparse_(&mut self, the_template: &Tensor) -> Tensor

pub fn resize_as_sparse_out( &self, out: &Tensor, the_template: &Tensor ) -> Tensor

pub fn resize_out(&self, out: &Tensor, size: impl IntList) -> Tensor

pub fn resolve_conj(&self) -> Tensor

pub fn resolve_neg(&self) -> Tensor

pub fn retains_grad(&self) -> bool

pub fn rnn_relu<T: Borrow<Tensor>>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> (Tensor, Tensor)

pub fn rnn_relu_cell<T: Borrow<Tensor>>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Tensor

pub fn rnn_relu_data<T: Borrow<Tensor>>( data: &Tensor, batch_sizes: &Tensor, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool ) -> (Tensor, Tensor)

pub fn rnn_tanh<T: Borrow<Tensor>>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> (Tensor, Tensor)

pub fn rnn_tanh_cell<T: Borrow<Tensor>>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Tensor

pub fn rnn_tanh_data<T: Borrow<Tensor>>( data: &Tensor, batch_sizes: &Tensor, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool ) -> (Tensor, Tensor)

pub fn roll(&self, shifts: impl IntList, dims: impl IntList) -> Tensor

pub fn roll_out( &self, out: &Tensor, shifts: impl IntList, dims: impl IntList ) -> Tensor

pub fn rot90(&self, k: i64, dims: impl IntList) -> Tensor

pub fn rot90_out(&self, out: &Tensor, k: i64, dims: impl IntList) -> Tensor

pub fn round(&self) -> Tensor

pub fn round_(&mut self) -> Tensor

pub fn round_decimals(&self, decimals: i64) -> Tensor

pub fn round_decimals_(&mut self, decimals: i64) -> Tensor

pub fn round_decimals_out(&self, out: &Tensor, decimals: i64) -> Tensor

pub fn round_out(&self, out: &Tensor) -> Tensor

pub fn row_indices(&self) -> Tensor

pub fn row_indices_copy(&self) -> Tensor

pub fn row_indices_copy_out(&self, out: &Tensor) -> Tensor

pub fn row_stack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn row_stack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor

pub fn rrelu(&self, training: bool) -> Tensor

pub fn rrelu_(&mut self, training: bool) -> Tensor

pub fn rrelu_with_noise(&self, noise: &Tensor, training: bool) -> Tensor

pub fn rrelu_with_noise_(&mut self, noise: &Tensor, training: bool) -> Tensor

pub fn rrelu_with_noise_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, noise: &Tensor, lower: S, upper: S, training: bool, self_is_result: bool ) -> Tensor

pub fn rrelu_with_noise_backward_out<S: Into<Scalar>>( &self, out: &Tensor, grad_output: &Tensor, noise: &Tensor, lower: S, upper: S, training: bool, self_is_result: bool ) -> Tensor

pub fn rrelu_with_noise_out( &self, out: &Tensor, noise: &Tensor, training: bool ) -> Tensor

pub fn rsqrt(&self) -> Tensor

pub fn rsqrt_(&mut self) -> Tensor

pub fn rsqrt_out(&self, out: &Tensor) -> Tensor

pub fn rsub(&self, other: &Tensor) -> Tensor

pub fn rsub_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn rsub_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn rsub_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn scalar_tensor<S: Into<Scalar>>(s: S, options: (Kind, Device)) -> Tensor

pub fn scalar_tensor_out<S: Into<Scalar>>(out: &Tensor, s: S) -> Tensor

pub fn scaled_dot_product_attention<T: Borrow<Tensor>>( query: &Tensor, key: &Tensor, value: &Tensor, attn_mask: Option<T>, dropout_p: f64, is_causal: bool, scale: impl Into<Option<f64>> ) -> Tensor

pub fn scatter(&self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor

pub fn scatter_(&mut self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor

pub fn scatter_add(&self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor

pub fn scatter_add_(&mut self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor

pub fn scatter_add_out( &self, out: &Tensor, dim: i64, index: &Tensor, src: &Tensor ) -> Tensor

pub fn scatter_reduce( &self, dim: i64, index: &Tensor, src: &Tensor, reduce: &str ) -> Tensor

pub fn scatter_reduce_( &mut self, dim: i64, index: &Tensor, src: &Tensor, reduce: &str ) -> Tensor

pub fn scatter_reduce_out( &self, out: &Tensor, dim: i64, index: &Tensor, src: &Tensor, reduce: &str ) -> Tensor

pub fn scatter_src_out( &self, out: &Tensor, dim: i64, index: &Tensor, src: &Tensor ) -> Tensor

pub fn scatter_value<S: Into<Scalar>>( &self, dim: i64, index: &Tensor, value: S ) -> Tensor

pub fn scatter_value_<S: Into<Scalar>>( &mut self, dim: i64, index: &Tensor, value: S ) -> Tensor

pub fn scatter_value_out<S: Into<Scalar>>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S ) -> Tensor

pub fn scatter_value_reduce<S: Into<Scalar>>( &self, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Tensor

pub fn scatter_value_reduce_<S: Into<Scalar>>( &mut self, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Tensor

pub fn scatter_value_reduce_out<S: Into<Scalar>>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Tensor

pub fn searchsorted<T: Borrow<Tensor>>( &self, sorted_sequence: &Tensor, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Tensor

pub fn searchsorted_scalar<T: Borrow<Tensor>, S: Into<Scalar>>( sorted_sequence: &Tensor, self_scalar: S, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Tensor

pub fn searchsorted_scalar_out<T: Borrow<Tensor>, S: Into<Scalar>>( out: &Tensor, sorted_sequence: &Tensor, self_scalar: S, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Tensor

pub fn searchsorted_tensor_out<T: Borrow<Tensor>>( &self, out: &Tensor, sorted_sequence: &Tensor, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Tensor

pub fn segment_reduce<T: Borrow<Tensor>, S: Into<Scalar>>( data: &Tensor, reduce: &str, lengths: Option<T>, indices: Option<T>, offsets: Option<T>, axis: i64, unsafe_: bool, initial: S ) -> Tensor

pub fn segment_reduce_out<T: Borrow<Tensor>, S: Into<Scalar>>( out: &Tensor, data: &Tensor, reduce: &str, lengths: Option<T>, indices: Option<T>, offsets: Option<T>, axis: i64, unsafe_: bool, initial: S ) -> Tensor

pub fn select(&self, dim: i64, index: i64) -> Tensor

pub fn select_backward( grad_output: &Tensor, input_sizes: impl IntList, dim: i64, index: i64 ) -> Tensor

pub fn select_backward_out( out: &Tensor, grad_output: &Tensor, input_sizes: impl IntList, dim: i64, index: i64 ) -> Tensor

pub fn select_copy(&self, dim: i64, index: i64) -> Tensor

pub fn select_copy_int_out(&self, out: &Tensor, dim: i64, index: i64) -> Tensor

pub fn select_scatter(&self, src: &Tensor, dim: i64, index: i64) -> Tensor

pub fn select_scatter_out( &self, out: &Tensor, src: &Tensor, dim: i64, index: i64 ) -> Tensor

pub fn selu(&self) -> Tensor

pub fn selu_(&mut self) -> Tensor

pub fn set(&self) -> Tensor

pub fn set_(&mut self) -> Tensor

pub fn set_data(&mut self, new_data: &Tensor)

pub fn set_out(&self, out: &Tensor) -> Tensor

pub fn set_requires_grad(&self, r: bool) -> Tensor

pub fn set_source_tensor(&self, source: &Tensor) -> Tensor

pub fn set_source_tensor_(&mut self, source: &Tensor) -> Tensor

pub fn set_source_tensor_out(&self, out: &Tensor, source: &Tensor) -> Tensor

pub fn set_source_tensor_storage_offset_( &mut self, source: &Tensor, storage_offset: i64, size: impl IntList, stride: impl IntList ) -> Tensor

pub fn sgn(&self) -> Tensor

pub fn sgn_(&mut self) -> Tensor

pub fn sgn_out(&self, out: &Tensor) -> Tensor

pub fn sigmoid(&self) -> Tensor

pub fn sigmoid_(&mut self) -> Tensor

pub fn sigmoid_backward(grad_output: &Tensor, output: &Tensor) -> Tensor

pub fn sigmoid_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output: &Tensor ) -> Tensor

pub fn sigmoid_out(&self, out: &Tensor) -> Tensor

pub fn sign(&self) -> Tensor

pub fn sign_(&mut self) -> Tensor

pub fn sign_out(&self, out: &Tensor) -> Tensor

pub fn signbit(&self) -> Tensor

pub fn signbit_out(&self, out: &Tensor) -> Tensor

pub fn silu(&self) -> Tensor

pub fn silu_(&mut self) -> Tensor

pub fn silu_backward(&self, grad_output: &Tensor) -> Tensor

pub fn silu_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor ) -> Tensor

pub fn silu_out(&self, out: &Tensor) -> Tensor

pub fn sin(&self) -> Tensor

pub fn sin_(&mut self) -> Tensor

pub fn sin_out(&self, out: &Tensor) -> Tensor

pub fn sinc(&self) -> Tensor

pub fn sinc_(&mut self) -> Tensor

pub fn sinc_out(&self, out: &Tensor) -> Tensor

pub fn sinh(&self) -> Tensor

pub fn sinh_(&mut self) -> Tensor

pub fn sinh_out(&self, out: &Tensor) -> Tensor

pub fn slice( &self, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Tensor

pub fn slice_backward( grad_output: &Tensor, input_sizes: impl IntList, dim: i64, start: i64, end: i64, step: i64 ) -> Tensor

pub fn slice_backward_out( out: &Tensor, grad_output: &Tensor, input_sizes: impl IntList, dim: i64, start: i64, end: i64, step: i64 ) -> Tensor

pub fn slice_copy( &self, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Tensor

pub fn slice_copy_tensor_out( &self, out: &Tensor, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Tensor

pub fn slice_scatter( &self, src: &Tensor, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Tensor

pub fn slice_scatter_out( &self, out: &Tensor, src: &Tensor, dim: i64, start: impl Into<Option<i64>>, end: impl Into<Option<i64>>, step: i64 ) -> Tensor

pub fn slogdet(&self) -> (Tensor, Tensor)

pub fn slogdet_out(&self, sign: &Tensor, logabsdet: &Tensor) -> (Tensor, Tensor)

pub fn slow_conv3d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList ) -> Tensor

pub fn slow_conv3d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList ) -> Tensor

pub fn slow_conv_dilated2d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn slow_conv_dilated2d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn slow_conv_dilated3d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn slow_conv_dilated3d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn slow_conv_transpose2d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn slow_conv_transpose2d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn slow_conv_transpose3d<T: Borrow<Tensor>>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn slow_conv_transpose3d_out<T: Borrow<Tensor>>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Tensor

pub fn smm(&self, mat2: &Tensor) -> Tensor

pub fn smooth_l1_loss( &self, target: &Tensor, reduction: Reduction, beta: f64 ) -> Tensor

pub fn smooth_l1_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction, beta: f64 ) -> Tensor

pub fn smooth_l1_loss_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction, beta: f64 ) -> Tensor

pub fn smooth_l1_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction, beta: f64 ) -> Tensor

pub fn soft_margin_loss(&self, target: &Tensor, reduction: Reduction) -> Tensor

pub fn soft_margin_loss_backward( &self, grad_output: &Tensor, target: &Tensor, reduction: Reduction ) -> Tensor

pub fn soft_margin_loss_backward_grad_input( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, reduction: Reduction ) -> Tensor

pub fn soft_margin_loss_out( &self, out: &Tensor, target: &Tensor, reduction: Reduction ) -> Tensor

pub fn softmax(&self, dim: i64, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn softmax_int_out( &self, out: &Tensor, dim: i64, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn softplus(&self) -> Tensor

pub fn softplus_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, beta: S, threshold: S ) -> Tensor

pub fn softplus_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, beta: S, threshold: S ) -> Tensor

pub fn softplus_out(&self, out: &Tensor) -> Tensor

pub fn softshrink(&self) -> Tensor

pub fn softshrink_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, lambd: S ) -> Tensor

pub fn softshrink_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, lambd: S ) -> Tensor

pub fn softshrink_out(&self, out: &Tensor) -> Tensor

pub fn sort(&self, dim: i64, descending: bool) -> (Tensor, Tensor)

pub fn sort_stable( &self, stable: bool, dim: i64, descending: bool ) -> (Tensor, Tensor)

pub fn sort_values( &self, values: &Tensor, indices: &Tensor, dim: i64, descending: bool ) -> (Tensor, Tensor)

pub fn sort_values_stable( &self, values: &Tensor, indices: &Tensor, stable: bool, dim: i64, descending: bool ) -> (Tensor, Tensor)

pub fn sparse_bsc_tensor( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Tensor

pub fn sparse_bsc_tensor_ccol_row_value_size( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn sparse_bsr_tensor( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Tensor

pub fn sparse_bsr_tensor_crow_col_value_size( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn sparse_compressed_tensor( compressed_indices: &Tensor, plain_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Tensor

pub fn sparse_compressed_tensor_comp_plain_value_size( compressed_indices: &Tensor, plain_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn sparse_coo_tensor(size: impl IntList, options: (Kind, Device)) -> Tensor

pub fn sparse_coo_tensor_indices( indices: &Tensor, values: &Tensor, options: (Kind, Device), is_coalesced: bool ) -> Tensor

pub fn sparse_coo_tensor_indices_size( indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device), is_coalesced: bool ) -> Tensor

pub fn sparse_coo_tensor_size_out(out: &Tensor, size: impl IntList) -> Tensor

pub fn sparse_csc_tensor( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Tensor

pub fn sparse_csc_tensor_ccol_row_value_size( ccol_indices: &Tensor, row_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn sparse_csr_tensor( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, options: (Kind, Device) ) -> Tensor

pub fn sparse_csr_tensor_crow_col_value_size( crow_indices: &Tensor, col_indices: &Tensor, values: &Tensor, size: impl IntList, options: (Kind, Device) ) -> Tensor

pub fn sparse_dim(&self) -> i64

pub fn sparse_mask(&self, mask: &Tensor) -> Tensor

pub fn sparse_mask_out(&self, out: &Tensor, mask: &Tensor) -> Tensor

pub fn sparse_resize( &self, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Tensor

pub fn sparse_resize_( &mut self, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Tensor

pub fn sparse_resize_and_clear( &self, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Tensor

pub fn sparse_resize_and_clear_( &mut self, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Tensor

pub fn sparse_resize_and_clear_out( &self, out: &Tensor, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Tensor

pub fn sparse_resize_out( &self, out: &Tensor, size: impl IntList, sparse_dim: i64, dense_dim: i64 ) -> Tensor

pub fn sparse_sampled_addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn sparse_sampled_addmm_out( &self, out: &Tensor, mat1: &Tensor, mat2: &Tensor ) -> Tensor

pub fn special_airy_ai(x: &Tensor) -> Tensor

pub fn special_airy_ai_out(out: &Tensor, x: &Tensor) -> Tensor

pub fn special_bessel_j0(&self) -> Tensor

pub fn special_bessel_j0_out(&self, out: &Tensor) -> Tensor

pub fn special_bessel_j1(&self) -> Tensor

pub fn special_bessel_j1_out(&self, out: &Tensor) -> Tensor

pub fn special_bessel_y0(&self) -> Tensor

pub fn special_bessel_y0_out(&self, out: &Tensor) -> Tensor

pub fn special_bessel_y1(&self) -> Tensor

pub fn special_bessel_y1_out(&self, out: &Tensor) -> Tensor

pub fn special_chebyshev_polynomial_t(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_chebyshev_polynomial_t_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_chebyshev_polynomial_t_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_chebyshev_polynomial_t_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_t_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_t_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_u(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_chebyshev_polynomial_u_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_chebyshev_polynomial_u_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_chebyshev_polynomial_u_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_u_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_u_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_v(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_chebyshev_polynomial_v_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_chebyshev_polynomial_v_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_chebyshev_polynomial_v_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_v_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_v_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_w(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_chebyshev_polynomial_w_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_chebyshev_polynomial_w_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_chebyshev_polynomial_w_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_w_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_chebyshev_polynomial_w_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_digamma(&self) -> Tensor

pub fn special_digamma_out(&self, out: &Tensor) -> Tensor

pub fn special_entr(&self) -> Tensor

pub fn special_entr_out(&self, out: &Tensor) -> Tensor

pub fn special_erf(&self) -> Tensor

pub fn special_erf_out(&self, out: &Tensor) -> Tensor

pub fn special_erfc(&self) -> Tensor

pub fn special_erfc_out(&self, out: &Tensor) -> Tensor

pub fn special_erfcx(&self) -> Tensor

pub fn special_erfcx_out(&self, out: &Tensor) -> Tensor

pub fn special_erfinv(&self) -> Tensor

pub fn special_erfinv_out(&self, out: &Tensor) -> Tensor

pub fn special_exp2(&self) -> Tensor

pub fn special_exp2_out(&self, out: &Tensor) -> Tensor

pub fn special_expit(&self) -> Tensor

pub fn special_expit_out(&self, out: &Tensor) -> Tensor

pub fn special_expm1(&self) -> Tensor

pub fn special_expm1_out(&self, out: &Tensor) -> Tensor

pub fn special_gammainc(&self, other: &Tensor) -> Tensor

pub fn special_gammainc_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn special_gammaincc(&self, other: &Tensor) -> Tensor

pub fn special_gammaincc_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn special_gammaln(&self) -> Tensor

pub fn special_gammaln_out(&self, out: &Tensor) -> Tensor

pub fn special_hermite_polynomial_h(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_hermite_polynomial_h_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_hermite_polynomial_h_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_hermite_polynomial_h_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_hermite_polynomial_h_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_hermite_polynomial_h_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_hermite_polynomial_he(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_hermite_polynomial_he_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_hermite_polynomial_he_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_hermite_polynomial_he_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_hermite_polynomial_he_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_hermite_polynomial_he_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_i0(&self) -> Tensor

pub fn special_i0_out(&self, out: &Tensor) -> Tensor

pub fn special_i0e(&self) -> Tensor

pub fn special_i0e_out(&self, out: &Tensor) -> Tensor

pub fn special_i1(&self) -> Tensor

pub fn special_i1_out(&self, out: &Tensor) -> Tensor

pub fn special_i1e(&self) -> Tensor

pub fn special_i1e_out(&self, out: &Tensor) -> Tensor

pub fn special_laguerre_polynomial_l(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_laguerre_polynomial_l_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_laguerre_polynomial_l_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_laguerre_polynomial_l_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_laguerre_polynomial_l_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_laguerre_polynomial_l_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_legendre_polynomial_p(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_legendre_polynomial_p_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_legendre_polynomial_p_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_legendre_polynomial_p_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_legendre_polynomial_p_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_legendre_polynomial_p_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_log1p(&self) -> Tensor

pub fn special_log1p_out(&self, out: &Tensor) -> Tensor

pub fn special_log_ndtr(&self) -> Tensor

pub fn special_log_ndtr_out(&self, out: &Tensor) -> Tensor

pub fn special_log_softmax( &self, dim: i64, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn special_logit(&self, eps: impl Into<Option<f64>>) -> Tensor

pub fn special_logit_out( &self, out: &Tensor, eps: impl Into<Option<f64>> ) -> Tensor

pub fn special_logsumexp(&self, dim: impl IntList, keepdim: bool) -> Tensor

pub fn special_logsumexp_out( &self, out: &Tensor, dim: impl IntList, keepdim: bool ) -> Tensor

pub fn special_modified_bessel_i0(&self) -> Tensor

pub fn special_modified_bessel_i0_out(&self, out: &Tensor) -> Tensor

pub fn special_modified_bessel_i1(&self) -> Tensor

pub fn special_modified_bessel_i1_out(&self, out: &Tensor) -> Tensor

pub fn special_modified_bessel_k0(&self) -> Tensor

pub fn special_modified_bessel_k0_out(&self, out: &Tensor) -> Tensor

pub fn special_modified_bessel_k1(&self) -> Tensor

pub fn special_modified_bessel_k1_out(&self, out: &Tensor) -> Tensor

pub fn special_multigammaln(&self, p: i64) -> Tensor

pub fn special_multigammaln_out(&self, out: &Tensor, p: i64) -> Tensor

pub fn special_ndtr(&self) -> Tensor

pub fn special_ndtr_out(&self, out: &Tensor) -> Tensor

pub fn special_ndtri(&self) -> Tensor

pub fn special_ndtri_out(&self, out: &Tensor) -> Tensor

pub fn special_polygamma(&self, n: i64) -> Tensor

pub fn special_polygamma_out(&self, out: &Tensor, n: i64) -> Tensor

pub fn special_psi(&self) -> Tensor

pub fn special_psi_out(&self, out: &Tensor) -> Tensor

pub fn special_round(&self, decimals: i64) -> Tensor

pub fn special_round_out(&self, out: &Tensor, decimals: i64) -> Tensor

pub fn special_scaled_modified_bessel_k0(x: &Tensor) -> Tensor

pub fn special_scaled_modified_bessel_k0_out(out: &Tensor, x: &Tensor) -> Tensor

pub fn special_scaled_modified_bessel_k1(x: &Tensor) -> Tensor

pub fn special_scaled_modified_bessel_k1_out(out: &Tensor, x: &Tensor) -> Tensor

pub fn special_shifted_chebyshev_polynomial_t(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_shifted_chebyshev_polynomial_t_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_t_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_t_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_t_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_t_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_u(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_shifted_chebyshev_polynomial_u_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_u_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_u_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_u_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_u_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_v(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_shifted_chebyshev_polynomial_v_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_v_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_v_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_v_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_v_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_w(x: &Tensor, n: &Tensor) -> Tensor

pub fn special_shifted_chebyshev_polynomial_w_n_scalar<S: Into<Scalar>>( x: &Tensor, n: S ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_w_n_scalar_out<S: Into<Scalar>>( out: &Tensor, x: &Tensor, n: S ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_w_out( out: &Tensor, x: &Tensor, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_w_x_scalar<S: Into<Scalar>>( x: S, n: &Tensor ) -> Tensor

pub fn special_shifted_chebyshev_polynomial_w_x_scalar_out<S: Into<Scalar>>( out: &Tensor, x: S, n: &Tensor ) -> Tensor

pub fn special_sinc(&self) -> Tensor

pub fn special_sinc_out(&self, out: &Tensor) -> Tensor

pub fn special_softmax( &self, dim: i64, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn special_spherical_bessel_j0(x: &Tensor) -> Tensor

pub fn special_spherical_bessel_j0_out(out: &Tensor, x: &Tensor) -> Tensor

pub fn special_xlog1py(&self, other: &Tensor) -> Tensor

pub fn special_xlog1py_other_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn special_xlog1py_other_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn special_xlog1py_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn special_xlog1py_self_scalar<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn special_xlog1py_self_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn special_xlogy(&self, other: &Tensor) -> Tensor

pub fn special_xlogy_other_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn special_xlogy_other_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn special_xlogy_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn special_xlogy_self_scalar<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn special_xlogy_self_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn special_zeta(&self, other: &Tensor) -> Tensor

pub fn special_zeta_other_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn special_zeta_other_scalar_out<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn special_zeta_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn special_zeta_self_scalar<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn special_zeta_self_scalar_out<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn split(&self, split_size: i64, dim: i64) -> Vec<Tensor>

pub fn split_copy(&self, split_size: i64, dim: i64) -> Vec<Tensor>

pub fn split_copy_tensor_out<T: Borrow<Tensor>>( &self, out: &[T], split_size: i64, dim: i64 )

pub fn split_sizes(&self, split_size: impl IntList, dim: i64) -> Vec<Tensor>

pub fn split_with_sizes( &self, split_sizes: impl IntList, dim: i64 ) -> Vec<Tensor>

pub fn split_with_sizes_copy( &self, split_sizes: impl IntList, dim: i64 ) -> Vec<Tensor>

pub fn split_with_sizes_copy_out<T: Borrow<Tensor>>( &self, out: &[T], split_sizes: impl IntList, dim: i64 )

pub fn sqrt(&self) -> Tensor

pub fn sqrt_(&mut self) -> Tensor

pub fn sqrt_out(&self, out: &Tensor) -> Tensor

pub fn square(&self) -> Tensor

pub fn square_(&mut self) -> Tensor

pub fn square_out(&self, out: &Tensor) -> Tensor

pub fn squeeze(&self) -> Tensor

pub fn squeeze_(&mut self) -> Tensor

pub fn squeeze_copy(&self) -> Tensor

pub fn squeeze_copy_dim(&self, dim: i64) -> Tensor

pub fn squeeze_copy_dim_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn squeeze_copy_dims(&self, dim: impl IntList) -> Tensor

pub fn squeeze_copy_dims_out(&self, out: &Tensor, dim: impl IntList) -> Tensor

pub fn squeeze_copy_out(&self, out: &Tensor) -> Tensor

pub fn squeeze_dim(&self, dim: i64) -> Tensor

pub fn squeeze_dim_(&mut self, dim: i64) -> Tensor

pub fn squeeze_dims(&self, dim: impl IntList) -> Tensor

pub fn squeeze_dims_(&mut self, dim: impl IntList) -> Tensor

pub fn sspaddmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn sspaddmm_out(&self, out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor

pub fn stack<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor

pub fn stack_out<T: Borrow<Tensor>>( out: &Tensor, tensors: &[T], dim: i64 ) -> Tensor

pub fn std(&self, unbiased: bool) -> Tensor

pub fn std_correction<S: Into<Scalar>>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Tensor

pub fn std_correction_out<S: Into<Scalar>>( &self, out: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Tensor

pub fn std_dim( &self, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Tensor

pub fn std_mean(&self, unbiased: bool) -> (Tensor, Tensor)

pub fn std_mean_correction<S: Into<Scalar>>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> (Tensor, Tensor)

pub fn std_mean_correction_out<S: Into<Scalar>>( &self, out0: &Tensor, out1: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> (Tensor, Tensor)

pub fn std_mean_dim( &self, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> (Tensor, Tensor)

pub fn std_out( &self, out: &Tensor, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Tensor

pub fn stft<T: Borrow<Tensor>>( &self, n_fft: i64, hop_length: impl Into<Option<i64>>, win_length: impl Into<Option<i64>>, window: Option<T>, normalized: bool, onesided: bool, return_complex: bool ) -> Tensor

pub fn stft_center<T: Borrow<Tensor>>( &self, n_fft: i64, hop_length: impl Into<Option<i64>>, win_length: impl Into<Option<i64>>, window: Option<T>, center: bool, pad_mode: &str, normalized: bool, onesided: bool, return_complex: bool ) -> Tensor

pub fn g_sub(&self, other: &Tensor) -> Tensor

pub fn g_sub_(&mut self, other: &Tensor) -> Tensor

pub fn sub_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn g_sub_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn g_sub_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn sub_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor

pub fn subtract(&self, other: &Tensor) -> Tensor

pub fn subtract_(&mut self, other: &Tensor) -> Tensor

pub fn subtract_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn subtract_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn subtract_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn sum(&self, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn sum_dim_intlist( &self, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn sum_intlist_out( &self, out: &Tensor, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn sum_out(&self, out: &Tensor, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn sum_to_size(&self, size: impl IntList) -> Tensor

pub fn svd(&self, some: bool, compute_uv: bool) -> (Tensor, Tensor, Tensor)

pub fn svd_u( &self, u: &Tensor, s: &Tensor, v: &Tensor, some: bool, compute_uv: bool ) -> (Tensor, Tensor, Tensor)

pub fn swapaxes(&self, axis0: i64, axis1: i64) -> Tensor

pub fn swapaxes_(&mut self, axis0: i64, axis1: i64) -> Tensor

pub fn swapdims(&self, dim0: i64, dim1: i64) -> Tensor

pub fn swapdims_(&mut self, dim0: i64, dim1: i64) -> Tensor

pub fn tr(&self) -> Tensor

pub fn t_(&mut self) -> Tensor

pub fn t_copy(&self) -> Tensor

pub fn t_copy_out(&self, out: &Tensor) -> Tensor

pub fn take(&self, index: &Tensor) -> Tensor

pub fn take_along_dim( &self, indices: &Tensor, dim: impl Into<Option<i64>> ) -> Tensor

pub fn take_along_dim_out( &self, out: &Tensor, indices: &Tensor, dim: impl Into<Option<i64>> ) -> Tensor

pub fn take_out(&self, out: &Tensor, index: &Tensor) -> Tensor

pub fn tan(&self) -> Tensor

pub fn tan_(&mut self) -> Tensor

pub fn tan_out(&self, out: &Tensor) -> Tensor

pub fn tanh(&self) -> Tensor

pub fn tanh_(&mut self) -> Tensor

pub fn tanh_backward(grad_output: &Tensor, output: &Tensor) -> Tensor

pub fn tanh_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output: &Tensor ) -> Tensor

pub fn tanh_out(&self, out: &Tensor) -> Tensor

pub fn tensor_split(&self, sections: i64, dim: i64) -> Vec<Tensor>

pub fn tensor_split_indices( &self, indices: impl IntList, dim: i64 ) -> Vec<Tensor>

pub fn tensor_split_tensor_indices_or_sections( &self, tensor_indices_or_sections: &Tensor, dim: i64 ) -> Vec<Tensor>

pub fn tensordot( &self, other: &Tensor, dims_self: impl IntList, dims_other: impl IntList ) -> Tensor

pub fn tensordot_out( &self, out: &Tensor, other: &Tensor, dims_self: impl IntList, dims_other: impl IntList ) -> Tensor

pub fn threshold<S: Into<Scalar>>(&self, threshold: S, value: S) -> Tensor

pub fn threshold_<S: Into<Scalar>>(&mut self, threshold: S, value: S) -> Tensor

pub fn threshold_backward<S: Into<Scalar>>( &self, grad_output: &Tensor, threshold: S ) -> Tensor

pub fn threshold_backward_grad_input<S: Into<Scalar>>( &self, grad_input: &Tensor, grad_output: &Tensor, threshold: S ) -> Tensor

pub fn threshold_out<S: Into<Scalar>>( &self, out: &Tensor, threshold: S, value: S ) -> Tensor

pub fn tile(&self, dims: impl IntList) -> Tensor

pub fn to(&self, device: Device) -> Tensor

pub fn to_dense( &self, dtype: impl Into<Option<Kind>>, masked_grad: bool ) -> Tensor

pub fn to_dense_backward(&self, grad: &Tensor, masked_grad: bool) -> Tensor

pub fn to_device_( &self, device: Device, dtype: Kind, non_blocking: bool, copy: bool ) -> Tensor

pub fn to_dtype(&self, dtype: Kind, non_blocking: bool, copy: bool) -> Tensor

pub fn to_dtype_layout( &self, options: (Kind, Device), non_blocking: bool, copy: bool ) -> Tensor

pub fn g_to_mkldnn(&self, dtype: impl Into<Option<Kind>>) -> Tensor

pub fn to_mkldnn_backward(&self, grad: &Tensor) -> Tensor

pub fn to_mkldnn_out( &self, out: &Tensor, dtype: impl Into<Option<Kind>> ) -> Tensor

pub fn to_other(&self, other: &Tensor, non_blocking: bool, copy: bool) -> Tensor

pub fn to_padded_tensor( &self, padding: f64, output_size: impl IntListOption ) -> Tensor

pub fn to_padded_tensor_out( &self, out: &Tensor, padding: f64, output_size: impl IntListOption ) -> Tensor

pub fn to_sparse( &self, layout: Option<Layout>, blocksize: impl IntListOption, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn to_sparse_bsc( &self, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn to_sparse_bsr( &self, blocksize: impl IntList, dense_dim: impl Into<Option<i64>> ) -> Tensor

pub fn to_sparse_csc(&self, dense_dim: impl Into<Option<i64>>) -> Tensor

pub fn to_sparse_csr(&self, dense_dim: impl Into<Option<i64>>) -> Tensor

pub fn to_sparse_sparse_dim(&self, sparse_dim: i64) -> Tensor

pub fn topk( &self, k: i64, dim: i64, largest: bool, sorted: bool ) -> (Tensor, Tensor)

pub fn topk_values( &self, values: &Tensor, indices: &Tensor, k: i64, dim: i64, largest: bool, sorted: bool ) -> (Tensor, Tensor)

pub fn totype(&self, scalar_type: Kind) -> Tensor

pub fn trace(&self) -> Tensor

pub fn trace_backward(grad: &Tensor, sizes: impl IntList) -> Tensor

pub fn trace_out(&self, out: &Tensor) -> Tensor

pub fn transpose(&self, dim0: i64, dim1: i64) -> Tensor

pub fn transpose_(&mut self, dim0: i64, dim1: i64) -> Tensor

pub fn transpose_copy(&self, dim0: i64, dim1: i64) -> Tensor

pub fn transpose_copy_int_out( &self, out: &Tensor, dim0: i64, dim1: i64 ) -> Tensor

pub fn trapezoid(y: &Tensor, dim: i64) -> Tensor

pub fn trapezoid_x(y: &Tensor, x: &Tensor, dim: i64) -> Tensor

pub fn trapz(y: &Tensor, x: &Tensor, dim: i64) -> Tensor

pub fn trapz_dx(y: &Tensor, dx: f64, dim: i64) -> Tensor

pub fn triangular_solve( &self, a: &Tensor, upper: bool, transpose: bool, unitriangular: bool ) -> (Tensor, Tensor)

pub fn triangular_solve_x( &self, x: &Tensor, m: &Tensor, a: &Tensor, upper: bool, transpose: bool, unitriangular: bool ) -> (Tensor, Tensor)

pub fn tril(&self, diagonal: i64) -> Tensor

pub fn tril_(&mut self, diagonal: i64) -> Tensor

pub fn tril_indices( row: i64, col: i64, offset: i64, options: (Kind, Device) ) -> Tensor

pub fn tril_indices_out(out: &Tensor, row: i64, col: i64, offset: i64) -> 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_indices_out(out: &Tensor, row: i64, col: i64, offset: i64) -> Tensor

pub fn triu_out(&self, out: &Tensor, diagonal: i64) -> Tensor

pub fn true_divide(&self, other: &Tensor) -> Tensor

pub fn true_divide_(&mut self, other: &Tensor) -> Tensor

pub fn true_divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn true_divide_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn true_divide_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn trunc(&self) -> Tensor

pub fn trunc_(&mut self) -> Tensor

pub fn trunc_out(&self, out: &Tensor) -> Tensor

pub fn type_as(&self, other: &Tensor) -> Tensor

pub fn unbind(&self, dim: i64) -> Vec<Tensor>

pub fn unbind_copy(&self, dim: i64) -> Vec<Tensor>

pub fn unbind_copy_int_out<T: Borrow<Tensor>>(&self, out: &[T], dim: i64)

pub fn unflatten(&self, dim: i64, sizes: impl IntList) -> Tensor

pub fn unflatten_dense_tensors<T: Borrow<Tensor>>( flat: &Tensor, tensors: &[T] ) -> Vec<Tensor>

pub fn unfold(&self, dimension: i64, size: i64, step: i64) -> Tensor

pub fn unfold_backward( grad_in: &Tensor, input_sizes: impl IntList, dim: i64, size: i64, step: i64 ) -> Tensor

pub fn unfold_backward_out( out: &Tensor, grad_in: &Tensor, input_sizes: impl IntList, dim: i64, size: i64, step: i64 ) -> Tensor

pub fn unfold_copy(&self, dimension: i64, size: i64, step: i64) -> Tensor

pub fn unfold_copy_out( &self, out: &Tensor, dimension: i64, size: i64, step: i64 ) -> Tensor

pub fn uniform(&self, from: f64, to: f64) -> Tensor

pub fn uniform_(&mut self, from: f64, to: f64) -> Tensor

pub fn uniform_out(&self, out: &Tensor, 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_consecutive_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, 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 unique_dim_consecutive_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, dim: i64, return_inverse: bool, return_counts: bool ) -> (Tensor, Tensor, Tensor)

pub fn unique_dim_out( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, dim: i64, sorted: bool, return_inverse: bool, return_counts: bool ) -> (Tensor, Tensor, Tensor)

pub fn unsafe_chunk(&self, chunks: i64, dim: i64) -> Vec<Tensor>

pub fn unsafe_split(&self, split_size: i64, dim: i64) -> Vec<Tensor>

pub fn unsafe_split_tensor_out<T: Borrow<Tensor>>( &self, out: &[T], split_size: i64, dim: i64 )

pub fn unsafe_split_with_sizes( &self, split_sizes: impl IntList, dim: i64 ) -> Vec<Tensor>

pub fn unsafe_split_with_sizes_out<T: Borrow<Tensor>>( &self, out: &[T], split_sizes: impl IntList, dim: i64 )

pub fn unsqueeze(&self, dim: i64) -> Tensor

pub fn unsqueeze_(&mut self, dim: i64) -> Tensor

pub fn unsqueeze_copy(&self, dim: i64) -> Tensor

pub fn unsqueeze_copy_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn upsample_bicubic2d( &self, output_size: impl IntList, 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: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_bicubic2d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, 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: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_bicubic2d_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Tensor

pub fn upsample_bilinear2d( &self, output_size: impl IntList, 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: impl IntList, input_size: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_bilinear2d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, 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: impl IntList, align_corners: bool, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_bilinear2d_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Tensor

pub fn upsample_linear1d( &self, output_size: impl IntList, align_corners: bool, scales: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_linear1d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_linear1d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, align_corners: bool, scales: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_linear1d_out( &self, out: &Tensor, output_size: impl IntList, align_corners: bool, scales: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_linear1d_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Tensor

pub fn upsample_nearest1d( &self, output_size: impl IntList, scales: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest1d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest1d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest1d_out( &self, out: &Tensor, output_size: impl IntList, scales: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest1d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Tensor

pub fn upsample_nearest2d( &self, output_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest2d_backward( grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest2d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest2d_out( &self, out: &Tensor, output_size: impl IntList, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest2d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Tensor

pub fn upsample_nearest3d( &self, output_size: impl IntList, 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: impl IntList, input_size: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest3d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, 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: impl IntList, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_nearest3d_vec( &self, output_size: impl IntListOption, scale_factors: impl DoubleList ) -> Tensor

pub fn upsample_trilinear3d( &self, output_size: impl IntList, 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: impl IntList, input_size: impl IntList, align_corners: bool, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_trilinear3d_backward_grad_input( grad_input: &Tensor, grad_output: &Tensor, output_size: impl IntList, input_size: impl IntList, 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: impl IntList, align_corners: bool, scales_d: impl Into<Option<f64>>, scales_h: impl Into<Option<f64>>, scales_w: impl Into<Option<f64>> ) -> Tensor

pub fn upsample_trilinear3d_vec( &self, output_size: impl IntListOption, align_corners: bool, scale_factors: impl DoubleList ) -> Tensor

pub fn value_selecting_reduction_backward( grad: &Tensor, dim: i64, indices: &Tensor, sizes: impl IntList, keepdim: bool ) -> Tensor

pub fn values(&self) -> Tensor

pub fn values_copy(&self) -> Tensor

pub fn values_copy_out(&self, out: &Tensor) -> Tensor

pub fn vander(x: &Tensor, n: impl Into<Option<i64>>, increasing: bool) -> Tensor

pub fn var(&self, unbiased: bool) -> Tensor

pub fn var_correction<S: Into<Scalar>>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Tensor

pub fn var_correction_out<S: Into<Scalar>>( &self, out: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Tensor

pub fn var_dim( &self, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Tensor

pub fn var_mean(&self, unbiased: bool) -> (Tensor, Tensor)

pub fn var_mean_correction<S: Into<Scalar>>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> (Tensor, Tensor)

pub fn var_mean_correction_out<S: Into<Scalar>>( &self, out0: &Tensor, out1: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> (Tensor, Tensor)

pub fn var_mean_dim( &self, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> (Tensor, Tensor)

pub fn var_out( &self, out: &Tensor, dim: impl IntListOption, unbiased: bool, keepdim: bool ) -> Tensor

pub fn vdot(&self, other: &Tensor) -> Tensor

pub fn vdot_out(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn view_(&self, size: impl IntList) -> Tensor

pub fn view_as(&self, other: &Tensor) -> Tensor

pub fn view_as_complex(&self) -> Tensor

pub fn view_as_complex_copy(&self) -> Tensor

pub fn view_as_complex_copy_out(&self, out: &Tensor) -> Tensor

pub fn view_as_real(&self) -> Tensor

pub fn view_as_real_copy(&self) -> Tensor

pub fn view_as_real_copy_out(&self, out: &Tensor) -> Tensor

pub fn view_copy(&self, size: impl IntList) -> Tensor

pub fn view_copy_dtype(&self, dtype: Kind) -> Tensor

pub fn view_copy_dtype_out(&self, out: &Tensor, dtype: Kind) -> Tensor

pub fn view_copy_out(&self, out: &Tensor, size: impl IntList) -> Tensor

pub fn view_dtype(&self, dtype: Kind) -> Tensor

pub fn vsplit(&self, sections: i64) -> Vec<Tensor>

pub fn vsplit_array(&self, indices: impl IntList) -> Vec<Tensor>

pub fn vstack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor

pub fn vstack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor

pub fn where_(condition: &Tensor) -> Vec<Tensor>

pub fn where_scalar<S: Into<Scalar>>( condition: &Tensor, self_scalar: S, other: S ) -> Tensor

pub fn where_scalarother<S: Into<Scalar>>( &self, condition: &Tensor, other: S ) -> Tensor

pub fn where_scalarself<S: Into<Scalar>>( condition: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn where_self(&self, condition: &Tensor, other: &Tensor) -> Tensor

pub fn where_self_out( &self, out: &Tensor, condition: &Tensor, other: &Tensor ) -> Tensor

pub fn xlogy(&self, other: &Tensor) -> Tensor

pub fn xlogy_(&mut self, other: &Tensor) -> Tensor

pub fn xlogy_outscalar_other<S: Into<Scalar>>( &self, out: &Tensor, other: S ) -> Tensor

pub fn xlogy_outscalar_self<S: Into<Scalar>>( out: &Tensor, self_scalar: S, other: &Tensor ) -> Tensor

pub fn xlogy_outtensor(&self, out: &Tensor, other: &Tensor) -> Tensor

pub fn xlogy_scalar_other<S: Into<Scalar>>(&self, other: S) -> Tensor

pub fn xlogy_scalar_other_<S: Into<Scalar>>(&mut self, other: S) -> Tensor

pub fn xlogy_scalar_self<S: Into<Scalar>>( self_scalar: S, other: &Tensor ) -> Tensor

pub fn zero(&self) -> Tensor

pub fn zero_(&mut self) -> Tensor

pub fn zero_out(&self, out: &Tensor) -> Tensor

pub fn zeros(size: impl IntList, options: (Kind, Device)) -> Tensor

pub fn zeros_like(&self) -> Tensor

pub fn zeros_like_out(&self, out: &Tensor) -> Tensor

pub fn zeros_out(out: &Tensor, size: impl IntList) -> 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 read_safetensors<T: AsRef<Path>>( path: T ) -> Result<Vec<(String, Tensor)>, TchError>

Reads a safetensors file and returns some named tensors.

pub fn write_safetensors<S: AsRef<str>, T: AsRef<Tensor>, P: AsRef<Path>>( tensors: &[(S, T)], path: P ) -> Result<(), TchError>

Writes a tensor in the safetensors format.

impl Tensor

pub fn f_view<T: Shape>(&self, s: T) -> Result<Tensor, TchError>

pub fn view<T: Shape>(&self, s: T) -> Tensor

pub fn f_zero_pad1d(&self, left: i64, right: i64) -> Result<Tensor, TchError>

pub fn zero_pad1d(&self, left: i64, right: i64) -> Tensor

pub fn f_zero_pad2d( &self, left: i64, right: i64, top: i64, bottom: i64 ) -> Result<Tensor, TchError>

pub fn zero_pad2d(&self, left: i64, right: i64, top: i64, bottom: i64) -> Tensor

impl Tensor

pub fn to_kind(&self, kind: Kind) -> Tensor

Casts a tensor to a specified kind.

pub fn f_to_kind(&self, kind: Kind) -> Result<Tensor, TchError>

pub fn nll_loss(&self, targets: &Tensor) -> Tensor

impl Tensor

pub fn cross_entropy_for_logits(&self, targets: &Tensor) -> Tensor

Computes the cross-entropy loss based on some logits and targets.

pub fn accuracy_for_logits(&self, targets: &Tensor) -> Tensor

Returns the average accuracy for some given logits assuming that targets represent ground-truth.

pub fn random_batch(&self, batch_size: i64) -> Tensor

pub fn random_batch2( t1: &Tensor, t2: &Tensor, batch_size: i64 ) -> (Tensor, Tensor)

pub fn to_device(&self, device: Device) -> Tensor

Moves a tensor to a specified device.

pub fn f_to_device(&self, device: Device) -> Result<Tensor, TchError>

pub fn avg_pool2d_default(&self, ksize: i64) -> Tensor

pub fn max_pool2d_default(&self, ksize: i64) -> Tensor

pub fn flat_view(&self) -> Tensor

Flattens a tensor.

This returns a flattened version of the given tensor. The first dimension is preserved as it is assumed to be the mini-batch dimension.

pub fn onehot(&self, labels: i64) -> Tensor

Converts a tensor to a one-hot encoded version.

If the input has a size [N1, N2, …, Nk], the returned tensor has a size [N1, …, Nk, labels]. The returned tensor uses float values. Elements of the input vector are expected to be between 0 and labels-1.

pub fn copy(&self) -> Tensor

Copies a tensor to a newly allocated tensor using the same shape and device.

pub fn from_slice2<T, U>(v: &[U]) -> Tensorwhere T: Element, U: AsRef<[T]>,

Copies the data from a two dimensional slice in a tensor object.

pub fn to_mkldnn(&self) -> Tensor

impl Tensor

pub fn init(&mut self, i: Init)

Re-initializes the tensor using the specified initialization.

impl Tensor

pub fn apply<M: Module>(&self, m: &M) -> Tensor

pub fn apply_t<M: ModuleT>(&self, m: &M, train: bool) -> Tensor

pub fn apply_opt<M: Module>(&self, m: &Option<M>) -> Tensor

pub fn apply_opt_t<M: ModuleT>(&self, m: &Option<M>, train: bool) -> Tensor

Trait Implementations

impl<'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 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 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 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<S> Add<S> for &Tensorwhere 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 Tensorwhere 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 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 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 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

Converts this type into a shared reference of the (usually inferred) input type.

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 Display for Tensor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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 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 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 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<S> Div<S> for &Tensorwhere 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 Tensorwhere 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 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 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 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

Converts to this type from the input type.

impl From<&Tensor> for TensorIndexer

fn from(tensor: &Tensor) -> Self

Converts to this type from the input type.

impl<T: Element> From<T> for Tensor

fn from(v: T) -> Tensor

Converts to this type from the input type.

impl From<Tensor> for IValue

fn from(v: Tensor) -> Self

Converts to this type from the input type.

impl<A> IndexOp<(A,)> for Tensorwhere A: Into<TensorIndexer>,

fn i(&self, index: (A,)) -> Tensor

impl<A, B> IndexOp<(A, B)> for Tensorwhere A: Into<TensorIndexer>, B: Into<TensorIndexer>,

fn i(&self, index: (A, B)) -> Tensor

impl<A, B, C> IndexOp<(A, B, C)> for Tensorwhere A: Into<TensorIndexer>, B: Into<TensorIndexer>, C: Into<TensorIndexer>,

fn i(&self, index: (A, B, C)) -> Tensor

impl<A, B, C, D> IndexOp<(A, B, C, D)> for Tensorwhere 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, D, E> IndexOp<(A, B, C, D, E)> for Tensorwhere 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, E, F> IndexOp<(A, B, C, D, E, F)> for Tensorwhere 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, F, G> IndexOp<(A, B, C, D, E, F, G)> for Tensorwhere 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> IndexOp<A> for Tensorwhere A: Into<TensorIndexer>,

fn i(&self, index: A) -> Tensor

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 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 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 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<S> Mul<S> for &Tensorwhere 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 Tensorwhere 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 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 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 MulAssign<&Tensor> for Tensor

fn mul_assign(&mut self, rhs: &Tensor)

Performs the *= operation.

impl MulAssign<Tensor> for Tensor

fn mul_assign(&mut self, rhs: Tensor)

Performs the *= operation.

impl MulAssign<f32> for Tensor

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign<f64> for Tensor

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl MulAssign<i32> for Tensor

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i64> for Tensor

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl Neg for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn neg(self) -> Tensor

Performs the unary - operation.

impl Neg for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn neg(self) -> Tensor

Performs the unary - operation.

impl PartialEq<Tensor> for Tensor

fn eq(&self, other: &Tensor) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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 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 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 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<S> Sub<S> for &Tensorwhere 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 Tensorwhere 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 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 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 SubAssign<&Tensor> for Tensor

fn sub_assign(&mut self, rhs: &Tensor)

Performs the -= operation.

impl SubAssign<Tensor> for Tensor

fn sub_assign(&mut self, rhs: Tensor)

Performs the -= operation.

impl SubAssign<f32> for Tensor

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl SubAssign<f64> for Tensor

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl SubAssign<i32> for Tensor

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for Tensor

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<'a> Sum<&'a Tensor> for Tensor

fn sum<I: Iterator<Item = &'a Tensor>>(iter: I) -> Tensor

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum<Tensor> for Tensor

fn sum<I: Iterator<Item = Tensor>>(iter: I) -> Tensor

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, D> TryFrom<&ArrayBase<T, D>> for Tensorwhere T: Data, T::Elem: Element, D: Dimension,

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: &ArrayBase<T, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element + Copy> TryFrom<&Tensor> for Vec<T>

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element + Copy> TryFrom<&Tensor> for Vec<Vec<T>>

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element + Copy> TryFrom<&Tensor> for Vec<Vec<Vec<T>>>

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for bf16

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for bool

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for f16

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for f32

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for f64

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for i16

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for i32

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for i64

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for i8

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for u8

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element> TryFrom<&Vec<T, Global>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: &Vec<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, D> TryFrom<ArrayBase<T, D>> for Tensorwhere T: Data, T::Elem: Element, D: Dimension,

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: ArrayBase<T, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<IValue> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: IValue) -> Result<Tensor, TchError>

Performs the conversion.

impl<T: Element + Copy> TryFrom<Tensor> for Vec<T>

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element + Copy> TryFrom<Tensor> for Vec<Vec<T>>

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element + Copy> TryFrom<Tensor> for Vec<Vec<Vec<T>>>

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for bf16

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for bool

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for f16

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for f32

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for f64

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for i16

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for i32

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for i64

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for i8

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for u8

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<TensorView<'a>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(view: TensorView<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element> TryFrom<Vec<T, Global>> for Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_from(value: Vec<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Element + Copy> TryInto<ArrayBase<OwnedRepr<T>, Dim<IxDynImpl>>> for &Tensor

type Error = TchError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ArrayD<T>, Self::Error>

Performs the conversion.

impl Send for Tensor