Struct cv_convert::TensorFromMat

source · [−]
pub struct TensorFromMat { /* private fields */ }
Expand description

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

Implementations

Methods from Deref<Target = Tensor>

Returns a pointer to the underlying C++ tensor.

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

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

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

Returns the number of dimension of the tensor.

Returns the shape of the input tensor.

Returns the tensor size for single dimension tensors.

Returns the tensor sizes for two dimension tensors.

Returns the tensor sizes for three dimension tensors.

Returns the tensor sizes for four dimension tensors.

Returns the tensor sizes for five dimension tensors.

Returns the tensor sizes for six dimension tensors.

Returns the stride of the input tensor.

Returns the tensor strides for single dimension tensors.

Returns the tensor strides for two dimension tensors.

Returns the tensor strides for three dimension tensors.

Returns the tensor strides for four dimension tensors.

Returns the tensor strides for five dimension tensors.

Returns the tensor strides for six dimension tensors.

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

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

Returns the device on which the input tensor is located.

Prints the input tensor.

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

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

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

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

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

Returns true if gradient are currently tracked for this tensor.

Returns the address of the first element of this tensor.

Returns true if the tensor is defined.

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

Returns true if the tensor is sparse.

Zeroes the gradient tensor attached to this tensor if defined.

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

Gradients tracking can be turned on via set_requires_grad.

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.

Copies numel elements from self to dst.

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.

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.

Copies numel elements from self to dst.

Copies numel elements from self to dst.

Copies numel elements from self to dst.

Returns the total number of elements stored in a tensor.

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

Gets the sub-tensor at the given index.

Gets the sub-tensor at the given index.

source

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

Copies values from the argument tensor to the input tensor.

source

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

Copies values from the argument tensor to the input tensor.

Saves a tensor to a file.

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

Returns a string representation for the tensor.

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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>

source

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

source

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

source

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

source

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>, 

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn f_heaviside_(&mut self, values: &Tensor) -> Result<Tensor, TchError>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn f_logit_(
    &mut self,
    eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>

source

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

source

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

source

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

source

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

source

pub fn f_masked_scatter_(
    &mut self,
    mask: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>

source

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

source

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

source

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

source

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

source

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

source

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

source

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>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn f_put_(
    &mut self,
    index: &Tensor,
    source: &Tensor,
    accumulate: bool
) -> Result<Tensor, TchError>

source

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

source

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

source

pub fn f_random_from_(
    &mut self,
    from: i64,
    to: impl Into<Option<i64>>
) -> Result<Tensor, TchError>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn f_resize_as_(
    &mut self,
    the_template: &Tensor
) -> Result<Tensor, TchError>

source

pub fn f_resize_as_sparse_(
    &mut self,
    the_template: &Tensor
) -> Result<Tensor, TchError>

source

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

source

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

source

pub fn f_rrelu_with_noise_(
    &mut self,
    noise: &Tensor,
    training: bool
) -> Result<Tensor, TchError>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn f_set_source_tensor_(
    &mut self,
    source: &Tensor
) -> Result<Tensor, TchError>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn f_sparse_resize_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Result<Tensor, TchError>

source

pub fn f_sparse_resize_and_clear_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Result<Tensor, TchError>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn f_swapaxes_(
    &mut self,
    axis0: i64,
    axis1: i64
) -> Result<Tensor, TchError>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn f_uniform_(&mut self, from: f64, to: f64) -> Result<Tensor, TchError>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn internal_coalesced_(&mut self, coalesced: bool) -> Tensor

source

pub fn internal_index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Tensor

source

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

source

pub fn internal_linalg_inv_out_helper_(
    &mut self,
    infos_lu: &Tensor,
    infos_getri: &Tensor
) -> Tensor

source

pub fn internal_mkldnn_transpose_(&mut self, dim0: i64, dim1: i64) -> Tensor

source

pub fn internal_sobol_engine_ff_(
    &mut self,
    n: i64,
    sobolstate: &Tensor,
    dimension: i64,
    num_generated: i64
) -> Tensor

source

pub fn internal_sobol_engine_initialize_state_(
    &mut self,
    dimension: i64
) -> Tensor

source

pub fn internal_sobol_engine_scramble_(
    &mut self,
    ltm: &Tensor,
    dimension: i64
) -> Tensor

source

pub fn abs_(&mut self) -> Tensor

source

pub fn absolute_(&mut self) -> Tensor

source

pub fn acos_(&mut self) -> Tensor

source

pub fn acosh_(&mut self) -> Tensor

source

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

source

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

source

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

source

pub fn addcdiv_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

source

pub fn addcmul_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor

source

pub fn addmm_(&mut self, mat1: &Tensor, mat2: &Tensor) -> Tensor

source

pub fn addmv_(&mut self, mat: &Tensor, vec: &Tensor) -> Tensor

source

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

source

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

source

pub fn arccos_(&mut self) -> Tensor

source

pub fn arccosh_(&mut self) -> Tensor

source

pub fn arcsin_(&mut self) -> Tensor

source

pub fn arcsinh_(&mut self) -> Tensor

source

pub fn arctan_(&mut self) -> Tensor

source

pub fn arctanh_(&mut self) -> Tensor

source

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

source

pub fn asin_(&mut self) -> Tensor

source

pub fn asinh_(&mut self) -> Tensor

source

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

source

pub fn atan_(&mut self) -> Tensor

source

pub fn atanh_(&mut self) -> Tensor

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn bitwise_not_(&mut self) -> Tensor

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn cauchy_(&mut self, median: f64, sigma: f64) -> Tensor

source

pub fn ceil_(&mut self) -> Tensor

source

pub fn celu_(&mut self) -> Tensor

source

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

source

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

source

pub fn clamp_max_tensor_(&mut self, max: &Tensor) -> Tensor

source

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

source

pub fn clamp_min_tensor_(&mut self, min: &Tensor) -> Tensor

source

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

source

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

source

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

source

pub fn conj_physical_(&mut self) -> Tensor

source

pub fn copy_sparse_to_sparse_(
    &mut self,
    src: &Tensor,
    non_blocking: bool
) -> Tensor

source

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

source

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

source

pub fn cos_(&mut self) -> Tensor

source

pub fn cosh_(&mut self) -> Tensor

source

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

source

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

source

pub fn deg2rad_(&mut self) -> Tensor

source

pub fn detach_(&mut self) -> Tensor

source

pub fn digamma_(&mut self) -> Tensor

source

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

source

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

source

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

source

pub fn g_div_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Tensor

source

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

source

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

source

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

source

pub fn divide_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Tensor

source

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

source

pub fn elu_(&mut self) -> Tensor

source

pub fn embedding_renorm_(
    &mut self,
    indices: &Tensor,
    max_norm: f64,
    norm_type: f64
) -> Tensor

source

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

source

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

source

pub fn erf_(&mut self) -> Tensor

source

pub fn erfc_(&mut self) -> Tensor

source

pub fn erfinv_(&mut self) -> Tensor

source

pub fn exp2_(&mut self) -> Tensor

source

pub fn exp_(&mut self) -> Tensor

source

pub fn expm1_(&mut self) -> Tensor

source

pub fn exponential_(&mut self, lambd: f64) -> Tensor

source

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

source

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

source

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

source

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

source

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

source

pub fn fix_(&mut self) -> Tensor

source

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

source

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

source

pub fn floor_(&mut self) -> Tensor

source

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

source

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

source

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

source

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

source

pub fn frac_(&mut self) -> Tensor

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn hardsigmoid_(&mut self) -> Tensor

source

pub fn hardswish_(&mut self) -> Tensor

source

pub fn hardtanh_(&mut self) -> Tensor

source

pub fn heaviside_(&mut self, values: &Tensor) -> Tensor

source

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

source

pub fn i0_(&mut self) -> Tensor

source

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

source

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

source

pub fn index_add_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Tensor

source

pub fn index_add_alpha_<S>(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor,
    alpha: S
) -> Tensor where
    S: Into<Scalar>, 

source

pub fn index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Tensor

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn leaky_relu_(&mut self) -> Tensor

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn lgamma_(&mut self) -> Tensor

source

pub fn log10_(&mut self) -> Tensor

source

pub fn log1p_(&mut self) -> Tensor

source

pub fn log2_(&mut self) -> Tensor

source

pub fn log_(&mut self) -> Tensor

source

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

source

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

source

pub fn logical_not_(&mut self) -> Tensor

source

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

source

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

source

pub fn logit_(&mut self, eps: impl Into<Option<f64>>) -> Tensor

source

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

source

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

source

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

source

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

source

pub fn masked_scatter_(&mut self, mask: &Tensor, source: &Tensor) -> Tensor

source

pub fn mish_(&mut self) -> Tensor

source

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

source

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

source

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

source

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

source

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

source

pub fn nan_to_num_(
    &mut self,
    nan: impl Into<Option<f64>>,
    posinf: impl Into<Option<f64>>,
    neginf: impl Into<Option<f64>>
) -> Tensor

source

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

source

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

source

pub fn neg_(&mut self) -> Tensor

source

pub fn negative_(&mut self) -> Tensor

source

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

source

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

source

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

source

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

source

pub fn polygamma_(&mut self, n: i64) -> Tensor

source

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

source

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

source

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

source

pub fn rad2deg_(&mut self) -> Tensor

source

pub fn random_(&mut self) -> Tensor

source

pub fn random_from_(&mut self, from: i64, to: impl Into<Option<i64>>) -> Tensor

source

pub fn random_to_(&mut self, to: i64) -> Tensor

source

pub fn reciprocal_(&mut self) -> Tensor

source

pub fn relu6_(&mut self) -> Tensor

source

pub fn relu_(&mut self) -> Tensor

source

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

source

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

source

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

source

pub fn requires_grad_(&mut self, requires_grad: bool) -> Tensor

source

pub fn resize_(&mut self, size: &[i64]) -> Tensor

source

pub fn resize_as_(&mut self, the_template: &Tensor) -> Tensor

source

pub fn resize_as_sparse_(&mut self, the_template: &Tensor) -> Tensor

source

pub fn round_(&mut self) -> Tensor

source

pub fn rrelu_(&mut self, training: bool) -> Tensor

source

pub fn rrelu_with_noise_(&mut self, noise: &Tensor, training: bool) -> Tensor

source

pub fn rsqrt_(&mut self) -> Tensor

source

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

source

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

source

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

source

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

source

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

source

pub fn selu_(&mut self) -> Tensor

source

pub fn set_(&mut self) -> Tensor

source

pub fn set_source_tensor_(&mut self, source: &Tensor) -> Tensor

source

pub fn sgn_(&mut self) -> Tensor

source

pub fn sigmoid_(&mut self) -> Tensor

source

pub fn sign_(&mut self) -> Tensor

source

pub fn silu_(&mut self) -> Tensor

source

pub fn sin_(&mut self) -> Tensor

source

pub fn sinc_(&mut self) -> Tensor

source

pub fn sinh_(&mut self) -> Tensor

source

pub fn sparse_resize_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Tensor

source

pub fn sparse_resize_and_clear_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Tensor

source

pub fn sqrt_(&mut self) -> Tensor

source

pub fn square_(&mut self) -> Tensor

source

pub fn squeeze_(&mut self) -> Tensor

source

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

source

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

source

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

source

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

source

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

source

pub fn swapaxes_(&mut self, axis0: i64, axis1: i64) -> Tensor

source

pub fn swapdims_(&mut self, dim0: i64, dim1: i64) -> Tensor

source

pub fn t_(&mut self) -> Tensor

source

pub fn tan_(&mut self) -> Tensor

source

pub fn tanh_(&mut self) -> Tensor

source

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

source

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

source

pub fn transpose_(&mut self, dim0: i64, dim1: i64) -> Tensor

source

pub fn tril_(&mut self, diagonal: i64) -> Tensor

source

pub fn triu_(&mut self, diagonal: i64) -> Tensor

source

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

source

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

source

pub fn trunc_(&mut self) -> Tensor

source

pub fn uniform_(&mut self, from: f64, to: f64) -> Tensor

source

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

source

pub fn view_(&self, size: &[i64]) -> Tensor

source

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

source

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

source

pub fn zero_(&mut self) -> Tensor

Writes a tensor in the npy format so that it can be read using python.

Casts a tensor to a specified kind.

Computes the cross-entropy loss based on some logits and targets.

Returns the average accuracy for some given logits assuming that targets represent ground-truth.

Moves a tensor to a specified device.

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.

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.

Copies a tensor to a newly allocated tensor using the same shape and device.

Re-initializes the tensor using the specified initialization.

Trait Implementations

Formats the value using the given formatter. Read more

The resulting type after dereferencing.

Dereferences the value.

Mutably dereferences the value.

Executes the destructor for this type. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The alignment of pointer.

The type for initializers.

Initializes a with the given initializer. Read more

Dereferences the given pointer. Read more

Mutably dereferences the given pointer. Read more

Drops the object pointed to by the given pointer. Read more

Should always be Self

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

Checks if self is actually part of its subset T (and can be converted to it).

Use with care! Same as self.to_subset but without any property checks. Always succeeds.

The inclusion map: converts self to the equivalent element of its superset.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.