Struct cv_convert::OpenCvMatAsTchTensor

pub struct OpenCvMatAsTchTensor<'a> { /* private fields */ }

A Tensor which data reference borrows from a Mat. It can be dereferenced to a Tensor.

Methods from Deref<Target = Tensor>

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_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>( &self, dst: &mut [T], numel: usize ) -> Result<(), TchError>where T: Element,

Copies numel elements from self to dst.

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

Copies numel elements from self to dst.

pub fn numel(&self) -> usize

Returns the total number of elements stored in a tensor.

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 save<T>(&self, path: T) -> Result<(), TchError>where T: AsRef<Path>,

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

Saves a tensor to a stream.

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>( &self, other: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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_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_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>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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_convolution<T>( &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>where T: Borrow<Tensor>,

pub fn f_internal_convolution_deprecated<T>( &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>where T: Borrow<Tensor>,

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

pub fn f_internal_convolution_out<T>( &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>where T: Borrow<Tensor>,

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_cudnn_rnn<T>( &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>where T: Borrow<Tensor>,

pub fn f_internal_cudnn_rnn_out<T>( &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>where T: Borrow<Tensor>,

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

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

pub fn f_internal_dimv(&self) -> Result<i64, 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_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_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_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>( &self, bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool ) -> Result<Vec<Tensor>, TchError>where T: Borrow<Tensor>,

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

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

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

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

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

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

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

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

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_log_softmax( &self, dim: i64, half_to_float: bool ) -> 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>( &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>where T: Borrow<Tensor>,

pub fn f_internal_lstm_mps_out<T>( &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>where T: Borrow<Tensor>,

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

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

pub fn f_internal_make_per_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_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>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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>( &self, weight: Option<T>, bias: Option<T>, running_mean: &Tensor, running_var: &Tensor, training: bool, momentum: f64, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>where T: Borrow<Tensor>,

pub fn f_internal_native_batch_norm_legit_functional<T>( &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>where T: Borrow<Tensor>,

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

pub fn f_internal_native_batch_norm_legit_no_stats_out<T>( &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>where T: Borrow<Tensor>,

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

pub fn f_internal_native_batch_norm_legit_no_training_out<T>( &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>where T: Borrow<Tensor>,

pub fn f_internal_native_batch_norm_legit_out<T>( &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>where T: Borrow<Tensor>,

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_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_spatial_convolution<T>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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_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_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_sample_dirichlet(&self) -> Result<Tensor, TchError>

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

pub fn f_internal_scaled_mm<T>( &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>where T: Borrow<Tensor>,

pub fn f_internal_scaled_mm_out<T>( &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>where T: Borrow<Tensor>,

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_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_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_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_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_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_reduce_impl( &self, other: &Tensor, reduce: &str ) -> Result<(Tensor, Tensor), TchError>

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

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_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_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_serialization_subcmul( &self, other: &Tensor ) -> 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_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_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_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_unsafe_index<T>( &self, indices: &[Option<T>] ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

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

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

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_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_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_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_2d(&self) -> Result<Tensor, TchError>

pub fn f_atleast_3d(&self) -> Result<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>( &self, batch1: &Tensor, batch2: &Tensor, beta: S, alpha: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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_batch_norm<T>( &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>where T: Borrow<Tensor>,

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

pub fn f_batch_norm_backward_elemt_out<T>( &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>where T: Borrow<Tensor>,

pub fn f_batch_norm_backward_reduce<T>( &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>where T: Borrow<Tensor>,

pub fn f_batch_norm_backward_reduce_out<T>( &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>where T: Borrow<Tensor>,

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

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

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

pub fn f_batch_norm_gather_stats_out<T>( &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>where T: Borrow<Tensor>,

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

pub fn f_batch_norm_gather_stats_with_counts_out<T>( &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>where T: Borrow<Tensor>,

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>( &self, running_mean: Option<T>, running_var: Option<T>, momentum: f64 ) -> Result<(Tensor, Tensor), TchError>where T: Borrow<Tensor>,

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

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_binary_cross_entropy<T>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

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

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

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

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

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

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

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

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

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_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

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

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

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

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Result<Tensor, TchError>

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

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

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

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

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

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

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_bmm(&self, mat2: &Tensor) -> Result<Tensor, TchError>

pub fn f_bmm_out(&self, out: &Tensor, mat2: &Tensor) -> Result<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_tensor_out( &self, out: &Tensor, boundaries: &Tensor, out_int32: bool, right: bool ) -> 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_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_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>(&self, min: S, max: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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

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>(&self, min: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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>( &self, out: &Tensor, min: S, max: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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

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

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

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

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

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

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_combinations( &self, r: i64, with_replacement: bool ) -> 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>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

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

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

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

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

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

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>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, groups: i64, dilation: impl IntList ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

pub fn f_convolution<T>( &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>where T: Borrow<Tensor>,

pub fn f_convolution_out<T>( &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>where T: Borrow<Tensor>,

pub fn f_convolution_overrideable<T>( &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>where T: Borrow<Tensor>,

pub fn f_convolution_overrideable_out<T>( &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>where T: Borrow<Tensor>,

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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_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>( &self, correction: i64, fweights: Option<T>, aweights: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

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_cudnn_batch_norm<T>( &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>where T: Borrow<Tensor>,

pub fn f_cudnn_batch_norm_backward<T>( &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>where T: Borrow<Tensor>,

pub fn f_cudnn_batch_norm_backward_out<T>( &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>where T: Borrow<Tensor>,

pub fn f_cudnn_batch_norm_out<T>( &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>where T: Borrow<Tensor>,

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, S>( &self, weight: &Tensor, z: &Tensor, alpha: S, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>where T: Borrow<Tensor>, S: Into<Scalar>,

pub fn f_cudnn_convolution_add_relu_out<T, S>( &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>where T: Borrow<Tensor>, S: Into<Scalar>,

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>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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_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_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_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>( &self, n: i64, dim: i64, prepend: Option<T>, append: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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

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

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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_elu(&self) -> Result<Tensor, TchError>

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

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

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

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

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

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

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_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_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_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>( &self, weight: &Tensor, packed: &Tensor, col_offsets: &Tensor, weight_scale: S, weight_zero_point: S, bias: &Tensor ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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_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_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>(&self, value: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

pub fn f_fill_scalar_out<S>( &self, out: &Tensor, value: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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_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>(&mut self, exponent: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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_full_like<S>(&self, fill_value: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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_out(&self, out: &Tensor, dim: i64) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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>( &self, num_groups: i64, weight: Option<T>, bias: Option<T>, eps: f64, cudnn_enabled: bool ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

pub fn f_gru<T>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> Result<(Tensor, Tensor), TchError>where T: Borrow<Tensor>,

pub fn f_gru_cell<T>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

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

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_hardshrink(&self) -> Result<Tensor, TchError>

pub fn f_hardshrink_backward<S>( &self, grad_out: &Tensor, lambd: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_hardshrink_backward_grad_input<S>( &self, grad_input: &Tensor, grad_out: &Tensor, lambd: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>( &self, grad_output: &Tensor, min_val: S, max_val: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_hardtanh_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, min_val: S, max_val: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>( &self, bins: &Tensor, weight: Option<T>, density: bool ) -> Result<(Tensor, Tensor), TchError>where T: Borrow<Tensor>,

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

pub fn f_histogram_bin_ct_out<T>( &self, hist: &Tensor, bin_edges: &Tensor, bins: i64, range: impl DoubleList, weight: Option<T>, density: bool ) -> Result<(Tensor, Tensor), TchError>where T: Borrow<Tensor>,

pub fn f_histogram_bins_tensor_out<T>( &self, hist: &Tensor, bin_edges: &Tensor, bins: &Tensor, weight: Option<T>, density: bool ) -> Result<(Tensor, Tensor), TchError>where T: Borrow<Tensor>,

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_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>(&self, indices: &[Option<T>]) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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>( &self, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

pub fn f_index_fill_int_scalar_out<S>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>( &self, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

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

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

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>( &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>where T: Borrow<Tensor>,

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_isclose( &self, other: &Tensor, rtol: f64, atol: f64, equal_nan: bool ) -> Result<Tensor, TchError>

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

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

pub fn f_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>( &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>where T: Borrow<Tensor>,

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>( &self, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64, cudnn_enable: bool ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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>( &self, grad_output: &Tensor, negative_slope: S, self_is_result: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_leaky_relu_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, negative_slope: S, self_is_result: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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

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

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>(&self, p: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_linalg_cond_out<S>( &self, out: &Tensor, p: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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_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_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_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_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>( &self, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

pub fn f_linalg_matrix_rank_atol_rtol_tensor_out<T>( &self, out: &Tensor, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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_norm<S>( &self, ord: S, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>( &self, out: &Tensor, ord: S, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>( &self, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

pub fn f_linalg_pinv_atol_rtol_tensor_out<T>( &self, out: &Tensor, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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_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_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_linear<T>( &self, weight: &Tensor, bias: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

pub fn f_linear_out<T>( &self, out: &Tensor, weight: &Tensor, bias: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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_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>( &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>where T: Borrow<Tensor>,

pub fn f_lstm_cell<T>( &self, hx: &[T], w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Result<(Tensor, Tensor), TchError>where T: Borrow<Tensor>,

pub fn f_lstm_mps_backward<T>( &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>where T: Borrow<Tensor>,

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

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

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

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_masked_fill<S>( &self, mask: &Tensor, value: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

pub fn f_masked_fill_scalar_out<S>( &self, out: &Tensor, mask: &Tensor, value: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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_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>( &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>where T: Borrow<Tensor>,

pub fn f_miopen_batch_norm_backward<T>( &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>where T: Borrow<Tensor>,

pub fn f_miopen_batch_norm_backward_out<T>( &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>where T: Borrow<Tensor>,

pub fn f_miopen_batch_norm_out<T>( &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>where T: Borrow<Tensor>,

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

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

pub fn f_miopen_convolution_out<T>( &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>where T: Borrow<Tensor>,

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

pub fn f_miopen_convolution_transpose<T>( &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>where T: Borrow<Tensor>,

pub fn f_miopen_convolution_transpose_out<T>( &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>where T: Borrow<Tensor>,

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

pub fn f_miopen_depthwise_convolution_out<T>( &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>where T: Borrow<Tensor>,

pub fn f_miopen_rnn<T>( &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>where T: Borrow<Tensor>,

pub fn f_miopen_rnn_out<T>( &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>where T: Borrow<Tensor>,

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>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

pub fn f_mkldnn_linear<T>( &self, weight: &Tensor, bias: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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>( &self, out: &Tensor, weight: &Tensor, bias: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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>( &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>where T: Borrow<Tensor>,

pub fn f_mkldnn_rnn_layer_backward_out<T>( &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>where T: Borrow<Tensor>,

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

pub fn f_multi_margin_loss_backward<T, S>( &self, grad_output: &Tensor, target: &Tensor, p: S, margin: S, weight: Option<T>, reduction: Reduction ) -> Result<Tensor, TchError>where T: Borrow<Tensor>, S: Into<Scalar>,

pub fn f_multi_margin_loss_backward_grad_input<T, S>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, p: S, margin: S, weight: Option<T>, reduction: Reduction ) -> Result<Tensor, TchError>where T: Borrow<Tensor>, S: Into<Scalar>,

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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>( &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>where T: Borrow<Tensor>,

pub fn f_native_batch_norm_out<T>( &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>where T: Borrow<Tensor>,

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_out( &self, out0: &Tensor, out1: &Tensor, p: f64, train: bool ) -> Result<(Tensor, Tensor), TchError>

pub fn f_native_group_norm<T>( &self, weight: Option<T>, bias: Option<T>, n: i64, c: i64, hxw: i64, group: i64, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>where T: Borrow<Tensor>,

pub fn f_native_group_norm_out<T>( &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>where T: Borrow<Tensor>,

pub fn f_native_layer_norm<T>( &self, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>where T: Borrow<Tensor>,

pub fn f_native_layer_norm_out<T>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64 ) -> Result<(Tensor, Tensor, Tensor), TchError>where T: Borrow<Tensor>,

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>( &self, p: S, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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

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>( &self, size: impl IntList, fill_value: S, options: (Kind, Device) ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_new_full_out<S>( &self, out: &Tensor, size: impl IntList, fill_value: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

pub fn f_nll_loss2d_backward_grad_input<T>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

pub fn f_nll_loss_backward_grad_input<T>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

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>( &self, out: &Tensor, p: S, dim: impl IntList, keepdim: bool, dtype: Kind ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_norm_out<S>( &self, out: &Tensor, p: S, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

pub fn f_norm_scalaropt_dim<S>( &self, p: S, dim: impl IntList, keepdim: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_norm_scalaropt_dim_dtype<S>( &self, p: S, dim: impl IntList, keepdim: bool, dtype: Kind ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_norm_scalaropt_dtype<S>( &self, p: S, dtype: Kind ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_norm_scalaropt_dtype_out<S>( &self, out: &Tensor, p: S, dtype: Kind ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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_like(&self) -> Result<Tensor, TchError>

pub fn f_ones_like_out(&self, out: &Tensor) -> 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_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_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>(&mut self, exponent: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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_quantized_batch_norm<T>( &self, weight: Option<T>, bias: Option<T>, mean: &Tensor, var: &Tensor, eps: f64, output_scale: f64, output_zero_point: i64 ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

pub fn f_quantized_batch_norm_out<T>( &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>where T: Borrow<Tensor>,

pub fn f_quantized_gru_cell<S>( &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>where S: Into<Scalar>,

pub fn f_quantized_lstm_cell<T, S>( &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>where T: Borrow<Tensor>, S: Into<Scalar>,

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>( &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>where S: Into<Scalar>,

pub fn f_quantized_rnn_tanh_cell<S>( &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>where S: Into<Scalar>,

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_like(&self) -> Result<Tensor, TchError>

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

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

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

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

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>( &self, p: S, dim: i64, maxnorm: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_renorm_<S>( &mut self, p: S, dim: i64, maxnorm: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_renorm_out<S>( &self, out: &Tensor, p: S, dim: i64, maxnorm: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_repeat(&self, repeats: impl IntList) -> 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_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>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> Result<(Tensor, Tensor), TchError>where T: Borrow<Tensor>,

pub fn f_rnn_relu_cell<T>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

pub fn f_rnn_tanh<T>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> Result<(Tensor, Tensor), TchError>where T: Borrow<Tensor>,

pub fn f_rnn_tanh_cell<T>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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_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>( &self, grad_output: &Tensor, noise: &Tensor, lower: S, upper: S, training: bool, self_is_result: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_rrelu_with_noise_backward_out<S>( &self, out: &Tensor, grad_output: &Tensor, noise: &Tensor, lower: S, upper: S, training: bool, self_is_result: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

pub fn f_rsub_tensor_out( &self, out: &Tensor, other: &Tensor ) -> 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>( &self, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

pub fn f_scatter_value_out<S>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_scatter_value_reduce<S>( &self, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_scatter_value_reduce_<S>( &mut self, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_scatter_value_reduce_out<S>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_searchsorted<T>( &self, sorted_sequence: &Tensor, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

pub fn f_searchsorted_tensor_out<T>( &self, out: &Tensor, sorted_sequence: &Tensor, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

pub fn f_select(&self, 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_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_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>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList ) -> Result<Tensor, TchError>where T: Borrow<Tensor>,

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

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

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

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

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

pub fn f_slow_conv_transpose2d<T>( &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>where T: Borrow<Tensor>,

pub fn f_slow_conv_transpose2d_out<T>( &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>where T: Borrow<Tensor>,

pub fn f_slow_conv_transpose3d<T>( &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>where T: Borrow<Tensor>,

pub fn f_slow_conv_transpose3d_out<T>( &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>where T: Borrow<Tensor>,

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>( &self, grad_output: &Tensor, beta: S, threshold: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_softplus_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, beta: S, threshold: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>( &self, grad_output: &Tensor, lambd: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_softshrink_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, lambd: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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_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_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_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_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_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_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_xlog1py(&self, other: &Tensor) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

pub fn f_special_zeta_out( &self, out: &Tensor, 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>( &self, out: &[T], split_size: i64, dim: i64 ) -> Result<(), TchError>where T: Borrow<Tensor>,

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>( &self, out: &[T], split_sizes: impl IntList, dim: i64 ) -> Result<(), TchError>where T: Borrow<Tensor>,

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_std(&self, unbiased: bool) -> Result<Tensor, TchError>

pub fn f_std_correction<S>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_std_correction_out<S>( &self, out: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>where S: Into<Scalar>,

pub fn f_std_mean_correction_out<S>( &self, out0: &Tensor, out1: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>where S: Into<Scalar>,

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>( &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>where T: Borrow<Tensor>,

pub fn f_stft_center<T>( &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>where T: Borrow<Tensor>,

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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_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>(&self, threshold: S, value: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

pub fn f_threshold_backward<S>( &self, grad_output: &Tensor, threshold: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_threshold_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, threshold: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_threshold_out<S>( &self, out: &Tensor, threshold: S, value: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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_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_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_out( &self, out: &Tensor, diagonal: i64 ) -> 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_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>(&self, other: S) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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>( &self, out: &[T], dim: i64 ) -> Result<(), TchError>where T: Borrow<Tensor>,

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

pub fn f_unfold( &self, dimension: 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>( &self, out: &[T], split_size: i64, dim: i64 ) -> Result<(), TchError>where T: Borrow<Tensor>,

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>( &self, out: &[T], split_sizes: impl IntList, dim: i64 ) -> Result<(), TchError>where T: Borrow<Tensor>,

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_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_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_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_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_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_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_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_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_var(&self, unbiased: bool) -> Result<Tensor, TchError>

pub fn f_var_correction<S>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

pub fn f_var_correction_out<S>( &self, out: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>where S: Into<Scalar>,

pub fn f_var_mean_correction_out<S>( &self, out0: &Tensor, out1: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Result<(Tensor, Tensor), TchError>where S: Into<Scalar>,

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_where_scalarother<S>( &self, condition: &Tensor, other: S ) -> Result<Tensor, TchError>where S: Into<Scalar>,

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

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

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

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

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_like(&self) -> Result<Tensor, TchError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>(&mut self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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

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>(&mut self, other: S) -> Tensorwhere S: Into<Scalar>,

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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_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_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>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensorwhere T: Borrow<Tensor>,

pub fn internal_conv_depthwise2d_out<T>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensorwhere T: Borrow<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_convolution<T>( &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 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn internal_convolution_deprecated<T>( &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 ) -> Tensorwhere T: Borrow<Tensor>,

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

pub fn internal_convolution_out<T>( &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 ) -> Tensorwhere T: Borrow<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_cudnn_rnn<T>( &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)where T: Borrow<Tensor>,

pub fn internal_cudnn_rnn_out<T>( &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)where T: Borrow<Tensor>,

pub fn internal_debug_has_internal_overlap(&self) -> i64

pub fn internal_dimi(&self) -> i64

pub fn internal_dimv(&self) -> i64

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_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_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_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>( &self, bins: impl IntList, range: impl DoubleList, weight: Option<T>, density: bool ) -> Vec<Tensor>where T: Borrow<Tensor>,

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

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

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

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

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

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

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

pub fn internal_index_put_impl_out<T>( &self, out: &Tensor, indices: &[Option<T>], values: &Tensor, accumulate: bool, unsafe_: bool ) -> Tensorwhere T: Borrow<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_log_softmax(&self, dim: i64, half_to_float: bool) -> 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>( &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)where T: Borrow<Tensor>,

pub fn internal_lstm_mps_out<T>( &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)where T: Borrow<Tensor>,

pub fn internal_lu_with_info( &self, pivot: bool, check_errors: bool ) -> (Tensor, Tensor, Tensor)

pub fn internal_make_per_channel_quantized_tensor( &self, scale: &Tensor, zero_point: &Tensor, axis: i64 ) -> Tensor

pub fn internal_make_per_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_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>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn internal_mps_convolution_out<T>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensorwhere T: Borrow<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>( &self, weight: Option<T>, bias: Option<T>, running_mean: &Tensor, running_var: &Tensor, training: bool, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)where T: Borrow<Tensor>,

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

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

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

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

pub fn internal_native_batch_norm_legit_no_training_out<T>( &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)where T: Borrow<Tensor>,

pub fn internal_native_batch_norm_legit_out<T>( &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)where T: Borrow<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_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_spatial_convolution<T>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList ) -> Tensorwhere T: Borrow<Tensor>,

pub fn internal_nnpack_spatial_convolution_out<T>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList ) -> Tensorwhere T: Borrow<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_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_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_sample_dirichlet(&self) -> Tensor

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

pub fn internal_scaled_mm<T>( &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)where T: Borrow<Tensor>,

pub fn internal_scaled_mm_out<T>( &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)where T: Borrow<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_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_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_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_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_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_reduce_impl( &self, other: &Tensor, reduce: &str ) -> (Tensor, Tensor)

pub fn internal_sparse_semi_structured_linear<T>( &self, weight: &Tensor, meta: &Tensor, bias: Option<T>, activation: &str ) -> Tensorwhere T: Borrow<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_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_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_serialization_subcmul(&self, other: &Tensor) -> 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_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_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_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_unsafe_index<T>(&self, indices: &[Option<T>]) -> Tensorwhere T: Borrow<Tensor>,

pub fn internal_unsafe_index_put<T>( &self, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Tensorwhere T: Borrow<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_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_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_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_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_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_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 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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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

pub fn atleast_3d(&self) -> 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>( &self, batch1: &Tensor, batch2: &Tensor, beta: S, alpha: S ) -> Tensorwhere S: Into<Scalar>,

pub fn baddbmm_(&mut self, batch1: &Tensor, batch2: &Tensor) -> Tensor

pub fn baddbmm_out( &self, out: &Tensor, batch1: &Tensor, batch2: &Tensor ) -> Tensor

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

pub fn batch_norm_backward_elemt<T>( &self, grad_out: &Tensor, mean: &Tensor, invstd: &Tensor, weight: Option<T>, sum_dy: &Tensor, sum_dy_xmu: &Tensor, count: &Tensor ) -> Tensorwhere T: Borrow<Tensor>,

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

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

pub fn batch_norm_backward_reduce_out<T>( &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)where T: Borrow<Tensor>,

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

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

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

pub fn batch_norm_gather_stats_out<T>( &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)where T: Borrow<Tensor>,

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

pub fn batch_norm_gather_stats_with_counts_out<T>( &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)where T: Borrow<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>( &self, running_mean: Option<T>, running_var: Option<T>, momentum: f64 ) -> (Tensor, Tensor)where T: Borrow<Tensor>,

pub fn batch_norm_update_stats_out<T>( &self, out0: &Tensor, out1: &Tensor, running_mean: Option<T>, running_var: Option<T>, momentum: f64 ) -> (Tensor, Tensor)where T: Borrow<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 binary_cross_entropy<T>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction ) -> Tensorwhere T: Borrow<Tensor>,

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

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

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

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

pub fn binary_cross_entropy_with_logits_out<T>( &self, out: &Tensor, target: &Tensor, weight: Option<T>, pos_weight: Option<T>, reduction: Reduction ) -> Tensorwhere T: Borrow<Tensor>,

pub fn bincount<T>(&self, weights: Option<T>, minlength: i64) -> Tensorwhere T: Borrow<Tensor>,

pub fn bincount_out<T>( &self, out: &Tensor, weights: Option<T>, minlength: i64 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn bitwise_and<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Tensor

pub fn bitwise_left_shift_tensor_scalar<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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_tensor_out( &self, out: &Tensor, other: &Tensor ) -> Tensor

pub fn bitwise_right_shift_tensor_scalar<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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

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

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

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 bmm(&self, mat2: &Tensor) -> Tensor

pub fn bmm_out(&self, out: &Tensor, mat2: &Tensor) -> 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_tensor_out( &self, out: &Tensor, boundaries: &Tensor, out_int32: bool, right: bool ) -> 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 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 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>(&self, min: S, max: S) -> Tensorwhere S: Into<Scalar>,

pub fn clamp_<S>(&mut self, min: S, max: S) -> Tensorwhere S: Into<Scalar>,

pub fn clamp_max<S>(&self, max: S) -> Tensorwhere S: Into<Scalar>,

pub fn clamp_max_<S>(&mut self, max: S) -> Tensorwhere S: Into<Scalar>,

pub fn clamp_max_out<S>(&self, out: &Tensor, max: S) -> Tensorwhere S: Into<Scalar>,

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>(&self, min: S) -> Tensorwhere S: Into<Scalar>,

pub fn clamp_min_<S>(&mut self, min: S) -> Tensorwhere S: Into<Scalar>,

pub fn clamp_min_out<S>(&self, out: &Tensor, min: S) -> Tensorwhere S: Into<Scalar>,

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>(&self, out: &Tensor, min: S, max: S) -> Tensorwhere S: Into<Scalar>,

pub fn clamp_tensor<T>(&self, min: Option<T>, max: Option<T>) -> Tensorwhere T: Borrow<Tensor>,

pub fn clamp_tensor_<T>(&mut self, min: Option<T>, max: Option<T>) -> Tensorwhere T: Borrow<Tensor>,

pub fn clamp_tensor_out<T>( &self, out: &Tensor, min: Option<T>, max: Option<T> ) -> Tensorwhere T: Borrow<Tensor>,

pub fn clip<S>(&self, min: S, max: S) -> Tensorwhere S: Into<Scalar>,

pub fn clip_<S>(&mut self, min: S, max: S) -> Tensorwhere S: Into<Scalar>,

pub fn clip_out<S>(&self, out: &Tensor, min: S, max: S) -> Tensorwhere S: Into<Scalar>,

pub fn clip_tensor<T>(&self, min: Option<T>, max: Option<T>) -> Tensorwhere T: Borrow<Tensor>,

pub fn clip_tensor_<T>(&mut self, min: Option<T>, max: Option<T>) -> Tensorwhere T: Borrow<Tensor>,

pub fn clip_tensor_out<T>( &self, out: &Tensor, min: Option<T>, max: Option<T> ) -> Tensorwhere T: Borrow<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 combinations(&self, r: i64, with_replacement: bool) -> 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>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensorwhere T: Borrow<Tensor>,

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

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

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

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

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

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

pub fn conv_depthwise3d_out<T>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList ) -> Tensorwhere T: Borrow<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>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, groups: i64, dilation: impl IntList ) -> Tensorwhere T: Borrow<Tensor>,

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

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

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

pub fn convolution_out<T>( &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 ) -> Tensorwhere T: Borrow<Tensor>,

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

pub fn convolution_overrideable_out<T>( &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 ) -> Tensorwhere T: Borrow<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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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 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>( &self, correction: i64, fweights: Option<T>, aweights: Option<T> ) -> Tensorwhere T: Borrow<Tensor>,

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

pub fn cross_entropy_loss<T>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, label_smoothing: f64 ) -> Tensorwhere T: Borrow<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 cudnn_batch_norm<T>( &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)where T: Borrow<Tensor>,

pub fn cudnn_batch_norm_backward<T>( &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)where T: Borrow<Tensor>,

pub fn cudnn_batch_norm_backward_out<T>( &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)where T: Borrow<Tensor>,

pub fn cudnn_batch_norm_out<T>( &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)where T: Borrow<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, S>( &self, weight: &Tensor, z: &Tensor, alpha: S, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensorwhere T: Borrow<Tensor>, S: Into<Scalar>,

pub fn cudnn_convolution_add_relu_out<T, S>( &self, out: &Tensor, weight: &Tensor, z: &Tensor, alpha: S, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensorwhere T: Borrow<Tensor>, S: Into<Scalar>,

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>( &self, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn cudnn_convolution_relu_out<T>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensorwhere T: Borrow<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 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 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_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>( &self, n: i64, dim: i64, prepend: Option<T>, append: Option<T> ) -> Tensorwhere T: Borrow<Tensor>,

pub fn diff_out<T>( &self, out: &Tensor, n: i64, dim: i64, prepend: Option<T>, append: Option<T> ) -> Tensorwhere T: Borrow<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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn g_div_scalar_mode<S>(&self, other: S, rounding_mode: &str) -> Tensorwhere S: Into<Scalar>,

pub fn g_div_scalar_mode_<S>(&mut self, other: S, rounding_mode: &str) -> Tensorwhere S: Into<Scalar>,

pub fn div_scalar_mode_out<S>( &self, out: &Tensor, other: S, rounding_mode: &str ) -> Tensorwhere S: Into<Scalar>,

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

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn divide_scalar_mode<S>(&self, other: S, rounding_mode: &str) -> Tensorwhere S: Into<Scalar>,

pub fn divide_scalar_mode_<S>( &mut self, other: S, rounding_mode: &str ) -> Tensorwhere S: Into<Scalar>,

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

pub fn elu_(&mut self) -> Tensor

pub fn elu_out(&self, out: &Tensor) -> 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 empty_like(&self) -> Tensor

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

pub fn eq<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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 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_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_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>( &self, weight: &Tensor, packed: &Tensor, col_offsets: &Tensor, weight_scale: S, weight_zero_point: S, bias: &Tensor ) -> Tensorwhere S: Into<Scalar>,

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

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_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_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>(&self, value: S) -> Tensorwhere S: Into<Scalar>,

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

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

pub fn fill_scalar_out<S>(&self, out: &Tensor, value: S) -> Tensorwhere S: Into<Scalar>,

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 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>(&mut self, exponent: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn float_power_tensor_scalar<S>(&self, exponent: S) -> Tensorwhere S: Into<Scalar>,

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

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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 full_like<S>(&self, fill_value: S) -> Tensorwhere S: Into<Scalar>,

pub fn full_like_out<S>(&self, out: &Tensor, fill_value: S) -> Tensorwhere S: Into<Scalar>,

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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_out(&self, out: &Tensor, dim: i64) -> Tensor

pub fn grad(&self) -> Tensor

pub fn greater<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn greater_equal<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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

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>( &self, num_groups: i64, weight: Option<T>, bias: Option<T>, eps: f64, cudnn_enabled: bool ) -> Tensorwhere T: Borrow<Tensor>,

pub fn gru<T>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> (Tensor, Tensor)where T: Borrow<Tensor>,

pub fn gru_cell<T>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Tensorwhere T: Borrow<Tensor>,

pub fn gt<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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

pub fn hardshrink_backward<S>(&self, grad_out: &Tensor, lambd: S) -> Tensorwhere S: Into<Scalar>,

pub fn hardshrink_backward_grad_input<S>( &self, grad_input: &Tensor, grad_out: &Tensor, lambd: S ) -> Tensorwhere S: Into<Scalar>,

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>( &self, grad_output: &Tensor, min_val: S, max_val: S ) -> Tensorwhere S: Into<Scalar>,

pub fn hardtanh_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, min_val: S, max_val: S ) -> Tensorwhere S: Into<Scalar>,

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>( &self, bins: &Tensor, weight: Option<T>, density: bool ) -> (Tensor, Tensor)where T: Borrow<Tensor>,

pub fn histogram_bin_ct<T>( &self, bins: i64, range: impl DoubleList, weight: Option<T>, density: bool ) -> (Tensor, Tensor)where T: Borrow<Tensor>,

pub fn histogram_bin_ct_out<T>( &self, hist: &Tensor, bin_edges: &Tensor, bins: i64, range: impl DoubleList, weight: Option<T>, density: bool ) -> (Tensor, Tensor)where T: Borrow<Tensor>,

pub fn histogram_bins_tensor_out<T>( &self, hist: &Tensor, bin_edges: &Tensor, bins: &Tensor, weight: Option<T>, density: bool ) -> (Tensor, Tensor)where T: Borrow<Tensor>,

pub fn hsplit(&self, sections: i64) -> Vec<Tensor>

pub fn hsplit_array(&self, indices: impl IntList) -> Vec<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>(&self, indices: &[Option<T>]) -> Tensorwhere T: Borrow<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>(&self, dim: i64, index: &Tensor, value: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn index_fill_int_scalar_out<S>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S ) -> Tensorwhere S: Into<Scalar>,

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>( &self, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Tensorwhere T: Borrow<Tensor>,

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

pub fn index_put_out<T>( &self, out: &Tensor, indices: &[Option<T>], values: &Tensor, accumulate: bool ) -> Tensorwhere T: Borrow<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_out(&self, out: &Tensor, dim: i64, index: &Tensor) -> Tensor

pub fn index_tensor_out<T>(&self, out: &Tensor, indices: &[Option<T>]) -> Tensorwhere T: Borrow<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>( &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 ) -> Tensorwhere T: Borrow<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 isclose( &self, other: &Tensor, rtol: f64, atol: f64, equal_nan: bool ) -> Tensor

pub fn isfinite(&self) -> 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>( &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 ) -> Tensorwhere T: Borrow<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>( &self, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64, cudnn_enable: bool ) -> Tensorwhere T: Borrow<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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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>( &self, grad_output: &Tensor, negative_slope: S, self_is_result: bool ) -> Tensorwhere S: Into<Scalar>,

pub fn leaky_relu_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, negative_slope: S, self_is_result: bool ) -> Tensorwhere S: Into<Scalar>,

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

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

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

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

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn less_equal<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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

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>(&self, p: S) -> Tensorwhere S: Into<Scalar>,

pub fn linalg_cond_out<S>(&self, out: &Tensor, p: S) -> Tensorwhere S: Into<Scalar>,

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_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_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_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_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>( &self, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Tensorwhere T: Borrow<Tensor>,

pub fn linalg_matrix_rank_atol_rtol_tensor_out<T>( &self, out: &Tensor, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Tensorwhere T: Borrow<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_norm<S>( &self, ord: S, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensorwhere S: Into<Scalar>,

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>( &self, out: &Tensor, ord: S, dim: impl IntListOption, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensorwhere S: Into<Scalar>,

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>( &self, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Tensorwhere T: Borrow<Tensor>,

pub fn linalg_pinv_atol_rtol_tensor_out<T>( &self, out: &Tensor, atol: Option<T>, rtol: Option<T>, hermitian: bool ) -> Tensorwhere T: Borrow<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_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_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 linear<T>(&self, weight: &Tensor, bias: Option<T>) -> Tensorwhere T: Borrow<Tensor>,

pub fn linear_out<T>( &self, out: &Tensor, weight: &Tensor, bias: Option<T> ) -> Tensorwhere T: Borrow<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 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>( &self, hx: &[T], params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> (Tensor, Tensor, Tensor)where T: Borrow<Tensor>,

pub fn lstm_cell<T>( &self, hx: &[T], w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> (Tensor, Tensor)where T: Borrow<Tensor>,

pub fn lstm_mps_backward<T>( &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 )where T: Borrow<Tensor>,

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

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

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

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 masked_fill<S>(&self, mask: &Tensor, value: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn masked_fill_scalar_out<S>( &self, out: &Tensor, mask: &Tensor, value: S ) -> Tensorwhere S: Into<Scalar>,

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 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>( &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)where T: Borrow<Tensor>,

pub fn miopen_batch_norm_backward<T>( &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)where T: Borrow<Tensor>,

pub fn miopen_batch_norm_backward_out<T>( &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)where T: Borrow<Tensor>,

pub fn miopen_batch_norm_out<T>( &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)where T: Borrow<Tensor>,

pub fn miopen_convolution<T>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Tensorwhere T: Borrow<Tensor>,

pub fn miopen_convolution_add_relu<T, S>( &self, weight: &Tensor, z: &Tensor, alpha: S, bias: Option<T>, stride: impl IntList, padding: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensorwhere T: Borrow<Tensor>, S: Into<Scalar>,

pub fn miopen_convolution_out<T>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Tensorwhere T: Borrow<Tensor>,

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

pub fn miopen_convolution_transpose<T>( &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 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn miopen_convolution_transpose_out<T>( &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 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn miopen_depthwise_convolution<T>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Tensorwhere T: Borrow<Tensor>,

pub fn miopen_depthwise_convolution_out<T>( &self, out: &Tensor, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64, benchmark: bool, deterministic: bool ) -> Tensorwhere T: Borrow<Tensor>,

pub fn miopen_rnn<T>( &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)where T: Borrow<Tensor>,

pub fn miopen_rnn_out<T>( &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)where T: Borrow<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>( &self, weight: &Tensor, bias: Option<T>, padding: impl IntList, stride: impl IntList, dilation: impl IntList, groups: i64 ) -> Tensorwhere T: Borrow<Tensor>,

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

pub fn mkldnn_linear<T>(&self, weight: &Tensor, bias: Option<T>) -> Tensorwhere T: Borrow<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>( &self, out: &Tensor, weight: &Tensor, bias: Option<T> ) -> Tensorwhere T: Borrow<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>( &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)where T: Borrow<Tensor>,

pub fn mkldnn_rnn_layer_backward_out<T>( &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)where T: Borrow<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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

pub fn multi_margin_loss_backward<T, S>( &self, grad_output: &Tensor, target: &Tensor, p: S, margin: S, weight: Option<T>, reduction: Reduction ) -> Tensorwhere T: Borrow<Tensor>, S: Into<Scalar>,

pub fn multi_margin_loss_backward_grad_input<T, S>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, p: S, margin: S, weight: Option<T>, reduction: Reduction ) -> Tensorwhere T: Borrow<Tensor>, S: Into<Scalar>,

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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>( &self, weight: Option<T>, bias: Option<T>, running_mean: Option<T>, running_var: Option<T>, training: bool, momentum: f64, eps: f64 ) -> (Tensor, Tensor, Tensor)where T: Borrow<Tensor>,

pub fn native_batch_norm_out<T>( &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)where T: Borrow<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_out( &self, out0: &Tensor, out1: &Tensor, p: f64, train: bool ) -> (Tensor, Tensor)

pub fn native_group_norm<T>( &self, weight: Option<T>, bias: Option<T>, n: i64, c: i64, hxw: i64, group: i64, eps: f64 ) -> (Tensor, Tensor, Tensor)where T: Borrow<Tensor>,

pub fn native_group_norm_out<T>( &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)where T: Borrow<Tensor>,

pub fn native_layer_norm<T>( &self, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64 ) -> (Tensor, Tensor, Tensor)where T: Borrow<Tensor>,

pub fn native_layer_norm_out<T>( &self, out0: &Tensor, out1: &Tensor, out2: &Tensor, normalized_shape: impl IntList, weight: Option<T>, bias: Option<T>, eps: f64 ) -> (Tensor, Tensor, Tensor)where T: Borrow<Tensor>,

pub fn native_norm(&self) -> Tensor

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

pub fn native_norm_scalaropt_dim_dtype<S>( &self, p: S, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensorwhere S: Into<Scalar>,

pub fn native_norm_scalaropt_dim_dtype_out<S>( &self, out: &Tensor, p: S, dim: impl IntList, keepdim: bool, dtype: impl Into<Option<Kind>> ) -> Tensorwhere S: Into<Scalar>,

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

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

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

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>( &self, size: impl IntList, fill_value: S, options: (Kind, Device) ) -> Tensorwhere S: Into<Scalar>,

pub fn new_full_out<S>( &self, out: &Tensor, size: impl IntList, fill_value: S ) -> Tensorwhere S: Into<Scalar>,

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>( &self, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Tensorwhere T: Borrow<Tensor>,

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

pub fn nll_loss2d_backward<T>( &self, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Tensorwhere T: Borrow<Tensor>,

pub fn nll_loss2d_backward_grad_input<T>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Tensorwhere T: Borrow<Tensor>,

pub fn nll_loss2d_out<T>( &self, out: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn nll_loss_backward<T>( &self, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Tensorwhere T: Borrow<Tensor>,

pub fn nll_loss_backward_grad_input<T>( &self, grad_input: &Tensor, grad_output: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64, total_weight: &Tensor ) -> Tensorwhere T: Borrow<Tensor>,

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

pub fn nll_loss_out<T>( &self, out: &Tensor, target: &Tensor, weight: Option<T>, reduction: Reduction, ignore_index: i64 ) -> Tensorwhere T: Borrow<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>( &self, out: &Tensor, p: S, dim: impl IntList, keepdim: bool, dtype: Kind ) -> Tensorwhere S: Into<Scalar>,

pub fn norm_out<S>( &self, out: &Tensor, p: S, dim: impl IntList, keepdim: bool ) -> Tensorwhere S: Into<Scalar>,

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

pub fn norm_scalaropt_dim<S>( &self, p: S, dim: impl IntList, keepdim: bool ) -> Tensorwhere S: Into<Scalar>,

pub fn norm_scalaropt_dim_dtype<S>( &self, p: S, dim: impl IntList, keepdim: bool, dtype: Kind ) -> Tensorwhere S: Into<Scalar>,

pub fn norm_scalaropt_dtype<S>(&self, p: S, dtype: Kind) -> Tensorwhere S: Into<Scalar>,

pub fn norm_scalaropt_dtype_out<S>( &self, out: &Tensor, p: S, dtype: Kind ) -> Tensorwhere S: Into<Scalar>,

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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

pub fn ones_like_out(&self, out: &Tensor) -> 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 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 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>(&mut self, exponent: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn pow_tensor_scalar<S>(&self, exponent: S) -> Tensorwhere S: Into<Scalar>,

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

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 quantized_batch_norm<T>( &self, weight: Option<T>, bias: Option<T>, mean: &Tensor, var: &Tensor, eps: f64, output_scale: f64, output_zero_point: i64 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn quantized_batch_norm_out<T>( &self, out: &Tensor, weight: Option<T>, bias: Option<T>, mean: &Tensor, var: &Tensor, eps: f64, output_scale: f64, output_zero_point: i64 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn quantized_gru_cell<S>( &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 ) -> Tensorwhere S: Into<Scalar>,

pub fn quantized_lstm_cell<T, S>( &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)where T: Borrow<Tensor>, S: Into<Scalar>,

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>( &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 ) -> Tensorwhere S: Into<Scalar>,

pub fn quantized_rnn_tanh_cell<S>( &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 ) -> Tensorwhere S: Into<Scalar>,

pub fn rad2deg(&self) -> Tensor

pub fn rad2deg_(&mut self) -> Tensor

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

pub fn rand_like(&self) -> Tensor

pub fn rand_like_out(&self, out: &Tensor) -> 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 randn_like(&self) -> Tensor

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

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

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

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>(&self, p: S, dim: i64, maxnorm: S) -> Tensorwhere S: Into<Scalar>,

pub fn renorm_<S>(&mut self, p: S, dim: i64, maxnorm: S) -> Tensorwhere S: Into<Scalar>,

pub fn renorm_out<S>(&self, out: &Tensor, p: S, dim: i64, maxnorm: S) -> Tensorwhere S: Into<Scalar>,

pub fn repeat(&self, repeats: impl IntList) -> 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_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>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> (Tensor, Tensor)where T: Borrow<Tensor>,

pub fn rnn_relu_cell<T>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Tensorwhere T: Borrow<Tensor>,

pub fn rnn_tanh<T>( &self, hx: &Tensor, params: &[T], has_biases: bool, num_layers: i64, dropout: f64, train: bool, bidirectional: bool, batch_first: bool ) -> (Tensor, Tensor)where T: Borrow<Tensor>,

pub fn rnn_tanh_cell<T>( &self, hx: &Tensor, w_ih: &Tensor, w_hh: &Tensor, b_ih: Option<T>, b_hh: Option<T> ) -> Tensorwhere T: Borrow<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 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>( &self, grad_output: &Tensor, noise: &Tensor, lower: S, upper: S, training: bool, self_is_result: bool ) -> Tensorwhere S: Into<Scalar>,

pub fn rrelu_with_noise_backward_out<S>( &self, out: &Tensor, grad_output: &Tensor, noise: &Tensor, lower: S, upper: S, training: bool, self_is_result: bool ) -> Tensorwhere S: Into<Scalar>,

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn rsub_tensor_out(&self, out: &Tensor, other: &Tensor) -> 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>(&self, dim: i64, index: &Tensor, value: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn scatter_value_out<S>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S ) -> Tensorwhere S: Into<Scalar>,

pub fn scatter_value_reduce<S>( &self, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Tensorwhere S: Into<Scalar>,

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

pub fn scatter_value_reduce_out<S>( &self, out: &Tensor, dim: i64, index: &Tensor, value: S, reduce: &str ) -> Tensorwhere S: Into<Scalar>,

pub fn searchsorted<T>( &self, sorted_sequence: &Tensor, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Tensorwhere T: Borrow<Tensor>,

pub fn searchsorted_tensor_out<T>( &self, out: &Tensor, sorted_sequence: &Tensor, out_int32: bool, right: bool, side: &str, sorter: Option<T> ) -> Tensorwhere T: Borrow<Tensor>,

pub fn select(&self, 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_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_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>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList ) -> Tensorwhere T: Borrow<Tensor>,

pub fn slow_conv3d_out<T>( &self, out: &Tensor, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList ) -> Tensorwhere T: Borrow<Tensor>,

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

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

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

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

pub fn slow_conv_transpose2d<T>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Tensorwhere T: Borrow<Tensor>,

pub fn slow_conv_transpose2d_out<T>( &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 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn slow_conv_transpose3d<T>( &self, weight: &Tensor, kernel_size: impl IntList, bias: Option<T>, stride: impl IntList, padding: impl IntList, output_padding: impl IntList, dilation: impl IntList ) -> Tensorwhere T: Borrow<Tensor>,

pub fn slow_conv_transpose3d_out<T>( &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 ) -> Tensorwhere T: Borrow<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>( &self, grad_output: &Tensor, beta: S, threshold: S ) -> Tensorwhere S: Into<Scalar>,

pub fn softplus_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, beta: S, threshold: S ) -> Tensorwhere S: Into<Scalar>,

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

pub fn softshrink(&self) -> Tensor

pub fn softshrink_backward<S>(&self, grad_output: &Tensor, lambd: S) -> Tensorwhere S: Into<Scalar>,

pub fn softshrink_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, lambd: S ) -> Tensorwhere S: Into<Scalar>,

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_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_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_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_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_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_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_xlog1py(&self, other: &Tensor) -> Tensor

pub fn special_xlog1py_other_scalar<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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

pub fn special_xlogy_other_scalar<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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

pub fn special_zeta_other_scalar<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn special_zeta_out(&self, out: &Tensor, 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>(&self, out: &[T], split_size: i64, dim: i64)where T: Borrow<Tensor>,

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>( &self, out: &[T], split_sizes: impl IntList, dim: i64 )where T: Borrow<Tensor>,

pub fn sqrt(&self) -> Tensor

pub fn sqrt_(&mut self) -> Tensor

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

pub fn square(&self) -> Tensor

pub fn square_(&mut self) -> Tensor

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

pub fn squeeze(&self) -> Tensor

pub fn squeeze_(&mut self) -> Tensor

pub fn squeeze_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 std(&self, unbiased: bool) -> Tensor

pub fn std_correction<S>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Tensorwhere S: Into<Scalar>,

pub fn std_correction_out<S>( &self, out: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Tensorwhere S: Into<Scalar>,

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>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> (Tensor, Tensor)where S: Into<Scalar>,

pub fn std_mean_correction_out<S>( &self, out0: &Tensor, out1: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> (Tensor, Tensor)where S: Into<Scalar>,

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>( &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 ) -> Tensorwhere T: Borrow<Tensor>,

pub fn stft_center<T>( &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 ) -> Tensorwhere T: Borrow<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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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_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>(&self, threshold: S, value: S) -> Tensorwhere S: Into<Scalar>,

pub fn threshold_<S>(&mut self, threshold: S, value: S) -> Tensorwhere S: Into<Scalar>,

pub fn threshold_backward<S>( &self, grad_output: &Tensor, threshold: S ) -> Tensorwhere S: Into<Scalar>,

pub fn threshold_backward_grad_input<S>( &self, grad_input: &Tensor, grad_output: &Tensor, threshold: S ) -> Tensorwhere S: Into<Scalar>,

pub fn threshold_out<S>(&self, out: &Tensor, threshold: S, value: S) -> Tensorwhere S: Into<Scalar>,

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_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 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_out(&self, out: &Tensor, diagonal: i64) -> Tensor

pub fn triu(&self, diagonal: i64) -> Tensor

pub fn triu_(&mut self, diagonal: 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>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

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>(&self, out: &[T], dim: i64)where T: Borrow<Tensor>,

pub fn unflatten(&self, dim: i64, sizes: impl IntList) -> Tensor

pub fn unfold(&self, dimension: 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>(&self, out: &[T], split_size: i64, dim: i64)where T: Borrow<Tensor>,

pub fn unsafe_split_with_sizes( &self, split_sizes: impl IntList, dim: i64 ) -> Vec<Tensor>

pub fn unsafe_split_with_sizes_out<T>( &self, out: &[T], split_sizes: impl IntList, dim: i64 )where T: Borrow<Tensor>,

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

pub fn values_copy(&self) -> Tensor

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

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

pub fn var_correction<S>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> Tensorwhere S: Into<Scalar>,

pub fn var_correction_out<S>( &self, out: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> Tensorwhere S: Into<Scalar>,

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>( &self, dim: impl IntListOption, correction: S, keepdim: bool ) -> (Tensor, Tensor)where S: Into<Scalar>,

pub fn var_mean_correction_out<S>( &self, out0: &Tensor, out1: &Tensor, dim: impl IntListOption, correction: S, keepdim: bool ) -> (Tensor, Tensor)where S: Into<Scalar>,

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 where_scalarother<S>(&self, condition: &Tensor, other: S) -> Tensorwhere S: Into<Scalar>,

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

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

pub fn xlogy_scalar_other<S>(&self, other: S) -> Tensorwhere S: Into<Scalar>,

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

pub fn zero(&self) -> Tensor

pub fn zero_(&mut self) -> Tensor

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

pub fn zeros_like(&self) -> Tensor

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

pub fn iter<T>(&self) -> Result<Iter<T>, TchError>

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

Writes a tensor in the npy format so that it can be read using python.

pub fn f_view<T>(&self, s: T) -> Result<Tensor, TchError>where T: Shape,

pub fn view<T>(&self, s: T) -> Tensorwhere T: Shape,

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

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

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

pub fn init(&mut self, i: Init)

Re-initializes the tensor using the specified initialization.

pub fn apply<M>(&self, m: &M) -> Tensorwhere M: Module,

pub fn apply_t<M>(&self, m: &M, train: bool) -> Tensorwhere M: ModuleT,

pub fn apply_opt<M>(&self, m: &Option<M>) -> Tensorwhere M: Module,

pub fn apply_opt_t<M>(&self, m: &Option<M>, train: bool) -> Tensorwhere M: ModuleT,

Trait Implementations

impl<'a> AsRef<Tensor> for OpenCvMatAsTchTensor<'a>

fn as_ref(&self) -> &Tensor

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Debug for OpenCvMatAsTchTensor<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Deref for OpenCvMatAsTchTensor<'a>

type Target = Tensor

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> DerefMut for OpenCvMatAsTchTensor<'a>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a> Drop for OpenCvMatAsTchTensor<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> TryFromCv<&'a Mat> for OpenCvMatAsTchTensor<'a>

type Error = Error

fn try_from_cv(from: &'a Mat) -> Result<Self, Self::Error>