Struct cv_convert::TensorFromMat[−][src]

pub struct TensorFromMat { /* fields omitted */ }
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.

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

Copies values from the argument tensor to the input tensor.

[src]
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.

[src]
pub fn f_internal_and_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_and_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_iand_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_iand_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_ilshift_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_ilshift_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_ior_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_ior_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_irshift_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_irshift_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_ixor_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_ixor_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_lshift_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_lshift_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_or_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_or_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_rshift_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_rshift_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_xor_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_internal_xor_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_add_relu_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
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>
[src]
pub fn f_internal_baddbmm_mkl_(
    &mut self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_coalesced_(
    &mut self,
    coalesced: bool
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>
[src]
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>, 
[src]
pub fn f_internal_linalg_inv_out_helper_(
    &mut self,
    infos_lu: &Tensor,
    infos_getri: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_linalg_solve_out_helper_(
    &mut self,
    other: &Tensor,
    infos: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_mkldnn_transpose_(
    &mut self,
    dim0: i64,
    dim1: i64
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_sobol_engine_ff_(
    &mut self,
    n: i64,
    sobolstate: &Tensor,
    dimension: i64,
    num_generated: i64
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_sobol_engine_initialize_state_(
    &mut self,
    dimension: i64
) -> Result<Tensor, TchError>
[src]
pub fn f_internal_sobol_engine_scramble_(
    &mut self,
    ltm: &Tensor,
    dimension: i64
) -> Result<Tensor, TchError>
[src]
pub fn f_abs_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_absolute_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_acos_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_acosh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_add_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_add_scalar_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_addbmm_(
    &mut self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_addcdiv_(
    &mut self,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_addcmul_(
    &mut self,
    tensor1: &Tensor,
    tensor2: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_addmm_(
    &mut self,
    mat1: &Tensor,
    mat2: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_addmv_(
    &mut self,
    mat: &Tensor,
    vec: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_addr_(
    &mut self,
    vec1: &Tensor,
    vec2: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_alpha_dropout_(
    &mut self,
    p: f64,
    train: bool
) -> Result<Tensor, TchError>
[src]
pub fn f_arccos_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_arccosh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_arcsin_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_arcsinh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_arctan_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_arctanh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_as_strided_(
    &mut self,
    size: &[i64],
    stride: &[i64],
    storage_offset: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
[src]
pub fn f_asin_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_asinh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_atan2_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_atan_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_atanh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_baddbmm_(
    &mut self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_bernoulli_(&mut self, p: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_bernoulli_float_(&mut self, p: f64) -> Result<Tensor, TchError>
[src]
pub fn f_bitwise_and_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_bitwise_and_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_bitwise_not_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_bitwise_or_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_bitwise_or_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_bitwise_xor_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_bitwise_xor_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_cauchy_(&mut self, median: f64, sigma: f64) -> Result<Tensor, TchError>
[src]
pub fn f_ceil_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_celu_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_clamp_<S>(&mut self, min: S, max: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_clamp_max_<S>(&mut self, max: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_clamp_max_tensor_(&mut self, max: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_clamp_min_<S>(&mut self, min: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_clamp_min_tensor_(&mut self, min: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_clamp_tensor_<T>(
    &mut self,
    min: Option<T>,
    max: Option<T>
) -> Result<Tensor, TchError> where
    T: Borrow<Tensor>, 
[src]
pub fn f_clip_<S>(&mut self, min: S, max: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_clip_tensor_<T>(
    &mut self,
    min: Option<T>,
    max: Option<T>
) -> Result<Tensor, TchError> where
    T: Borrow<Tensor>, 
[src]
pub fn f_copy_sparse_to_sparse_(
    &mut self,
    src: &Tensor,
    non_blocking: bool
) -> Result<Tensor, TchError>
[src]
pub fn f_copysign_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_copysign_scalar_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_cos_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_cosh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_cumprod_(&mut self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>
[src]
pub fn f_cumsum_(&mut self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>
[src]
pub fn f_deg2rad_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_detach_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_digamma_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_div_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_div_scalar_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_div_scalar_mode_<S>(
    &mut self,
    other: S,
    rounding_mode: &str
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_div_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Result<Tensor, TchError>
[src]
pub fn f_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_divide_scalar_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_divide_scalar_mode_<S>(
    &mut self,
    other: S,
    rounding_mode: &str
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_divide_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Result<Tensor, TchError>
[src]
pub fn f_dropout_(&mut self, p: f64, train: bool) -> Result<Tensor, TchError>
[src]
pub fn f_elu_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_embedding_renorm_(
    &mut self,
    indices: &Tensor,
    max_norm: f64,
    norm_type: f64
) -> Result<Tensor, TchError>
[src]
pub fn f_eq_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_eq_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_erf_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_erfc_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_erfinv_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_exp2_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_exp_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_expm1_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_exponential_(&mut self, lambd: f64) -> Result<Tensor, TchError>
[src]
pub fn f_feature_alpha_dropout_(
    &mut self,
    p: f64,
    train: bool
) -> Result<Tensor, TchError>
[src]
pub fn f_feature_dropout_(
    &mut self,
    p: f64,
    train: bool
) -> Result<Tensor, TchError>
[src]
pub fn f_fill_<S>(&mut self, value: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_fill_diagonal_<S>(
    &mut self,
    fill_value: S,
    wrap: bool
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_fill_tensor_(&mut self, value: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_fix_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_float_power_<S>(&mut self, exponent: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_float_power_tensor_(
    &mut self,
    exponent: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_floor_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_floor_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_floor_divide_scalar_<S>(
    &mut self,
    other: S
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_fmod_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_fmod_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_frac_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_gcd_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_ge_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_ge_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_geometric_(&mut self, p: f64) -> Result<Tensor, TchError>
[src]
pub fn f_greater_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_greater_equal_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_greater_equal_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_greater_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_gt_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_gt_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_hardsigmoid_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_hardswish_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_hardtanh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_heaviside_(&mut self, values: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_hypot_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_i0_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_igamma_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_igammac_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_index_add_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_index_add_alpha_<S>(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor,
    alpha: S
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_index_fill_<S>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_index_fill_int_tensor_(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_index_put_<T>(
    &mut self,
    indices: &[Option<T>],
    values: &Tensor,
    accumulate: bool
) -> Result<Tensor, TchError> where
    T: Borrow<Tensor>, 
[src]
pub fn f_lcm_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_ldexp_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_le_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_le_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_leaky_relu_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_lerp_<S>(
    &mut self,
    end: &Tensor,
    weight: S
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_lerp_tensor_(
    &mut self,
    end: &Tensor,
    weight: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_less_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_less_equal_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_less_equal_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_less_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_lgamma_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_log10_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_log1p_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_log2_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_log_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_log_normal_(&mut self, mean: f64, std: f64) -> Result<Tensor, TchError>
[src]
pub fn f_logical_and_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_logical_not_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_logical_or_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_logical_xor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_logit_(
    &mut self,
    eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
[src]
pub fn f_lt_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_lt_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_masked_fill_<S>(
    &mut self,
    mask: &Tensor,
    value: S
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_masked_fill_tensor_(
    &mut self,
    mask: &Tensor,
    value: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_masked_scatter_(
    &mut self,
    mask: &Tensor,
    source: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_mish_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_mul_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_mul_scalar_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_multiply_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_multiply_scalar_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_mvlgamma_(&mut self, p: i64) -> Result<Tensor, TchError>
[src]
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>
[src]
pub fn f_ne_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_ne_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_neg_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_negative_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_nextafter_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_normal_(&mut self, mean: f64, std: f64) -> Result<Tensor, TchError>
[src]
pub fn f_not_equal_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_not_equal_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_polygamma_(&mut self, n: i64) -> Result<Tensor, TchError>
[src]
pub fn f_pow_<S>(&mut self, exponent: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_pow_tensor_(&mut self, exponent: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_put_(
    &mut self,
    index: &Tensor,
    source: &Tensor,
    accumulate: bool
) -> Result<Tensor, TchError>
[src]
pub fn f_rad2deg_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_random_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_random_from_(
    &mut self,
    from: i64,
    to: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
[src]
pub fn f_random_to_(&mut self, to: i64) -> Result<Tensor, TchError>
[src]
pub fn f_reciprocal_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_relu6_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_relu_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_remainder_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_remainder_tensor_(
    &mut self,
    other: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_renorm_<S>(
    &mut self,
    p: S,
    dim: i64,
    maxnorm: S
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_requires_grad_(
    &mut self,
    requires_grad: bool
) -> Result<Tensor, TchError>
[src]
pub fn f_resize_(&mut self, size: &[i64]) -> Result<Tensor, TchError>
[src]
pub fn f_resize_as_(
    &mut self,
    the_template: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_resize_as_sparse_(
    &mut self,
    the_template: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_round_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_rrelu_(&mut self, training: bool) -> Result<Tensor, TchError>
[src]
pub fn f_rrelu_with_noise_(
    &mut self,
    noise: &Tensor,
    training: bool
) -> Result<Tensor, TchError>
[src]
pub fn f_rsqrt_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_scatter_(
    &mut self,
    dim: i64,
    index: &Tensor,
    src: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_scatter_add_(
    &mut self,
    dim: i64,
    index: &Tensor,
    src: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_scatter_reduce_(
    &mut self,
    dim: i64,
    index: &Tensor,
    src: &Tensor,
    reduce: &str
) -> Result<Tensor, TchError>
[src]
pub fn f_scatter_value_<S>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_scatter_value_reduce_<S>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S,
    reduce: &str
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_selu_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_set_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_set_source_tensor_(
    &mut self,
    source: &Tensor
) -> Result<Tensor, TchError>
[src]
pub fn f_sgn_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_sigmoid_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_sign_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_silu_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_sin_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_sinc_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_sinh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_sparse_resize_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Result<Tensor, TchError>
[src]
pub fn f_sparse_resize_and_clear_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Result<Tensor, TchError>
[src]
pub fn f_sqrt_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_square_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_squeeze_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_squeeze_dim_(&mut self, dim: i64) -> Result<Tensor, TchError>
[src]
pub fn f_sub_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_sub_scalar_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_subtract_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_subtract_scalar_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_swapaxes_(
    &mut self,
    axis0: i64,
    axis1: i64
) -> Result<Tensor, TchError>
[src]
pub fn f_swapdims_(&mut self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>
[src]
pub fn f_t_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_tan_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_tanh_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_threshold_<S>(
    &mut self,
    threshold: S,
    value: S
) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_to_device_(
    &self,
    device: Device,
    dtype: Kind,
    non_blocking: bool,
    copy: bool
) -> Result<Tensor, TchError>
[src]
pub fn f_transpose_(&mut self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>
[src]
pub fn f_tril_(&mut self, diagonal: i64) -> Result<Tensor, TchError>
[src]
pub fn f_triu_(&mut self, diagonal: i64) -> Result<Tensor, TchError>
[src]
pub fn f_true_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_true_divide_scalar_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_trunc_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn f_uniform_(&mut self, from: f64, to: f64) -> Result<Tensor, TchError>
[src]
pub fn f_unsqueeze_(&mut self, dim: i64) -> Result<Tensor, TchError>
[src]
pub fn f_view_(&self, size: &[i64]) -> Result<Tensor, TchError>
[src]
pub fn f_xlogy_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
[src]
pub fn f_xlogy_scalar_other_<S>(&mut self, other: S) -> Result<Tensor, TchError> where
    S: Into<Scalar>, 
[src]
pub fn f_zero_(&mut self) -> Result<Tensor, TchError>
[src]
pub fn internal_and_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_and_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_iand_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_iand_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_ilshift_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_ilshift_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_ior_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_ior_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_irshift_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_irshift_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_ixor_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_ixor_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_lshift_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_lshift_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_or_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_or_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_rshift_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_rshift_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_xor_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn internal_xor_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn internal_add_relu_(&mut self, other: &Tensor) -> Tensor
[src]
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
[src]
pub fn internal_baddbmm_mkl_(
    &mut self,
    batch1: &Tensor,
    batch2: &Tensor
) -> Tensor
[src]
pub fn internal_coalesced_(&mut self, coalesced: bool) -> Tensor
[src]
pub fn internal_index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Tensor
[src]
pub fn internal_index_put_impl_<T>(
    &mut self,
    indices: &[Option<T>],
    values: &Tensor,
    accumulate: bool,
    unsafe_: bool
) -> Tensor where
    T: Borrow<Tensor>, 
[src]
pub fn internal_linalg_inv_out_helper_(
    &mut self,
    infos_lu: &Tensor,
    infos_getri: &Tensor
) -> Tensor
[src]
pub fn internal_linalg_solve_out_helper_(
    &mut self,
    other: &Tensor,
    infos: &Tensor
) -> Tensor
[src]
pub fn internal_mkldnn_transpose_(&mut self, dim0: i64, dim1: i64) -> Tensor
[src]
pub fn internal_sobol_engine_ff_(
    &mut self,
    n: i64,
    sobolstate: &Tensor,
    dimension: i64,
    num_generated: i64
) -> Tensor
[src]
pub fn internal_sobol_engine_initialize_state_(
    &mut self,
    dimension: i64
) -> Tensor
[src]
pub fn internal_sobol_engine_scramble_(
    &mut self,
    ltm: &Tensor,
    dimension: i64
) -> Tensor
[src]
pub fn abs_(&mut self) -> Tensor
[src]
pub fn absolute_(&mut self) -> Tensor
[src]
pub fn acos_(&mut self) -> Tensor
[src]
pub fn acosh_(&mut self) -> Tensor
[src]
pub fn g_add_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn g_add_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn addbmm_(&mut self, batch1: &Tensor, batch2: &Tensor) -> Tensor
[src]
pub fn addcdiv_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
[src]
pub fn addcmul_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
[src]
pub fn addmm_(&mut self, mat1: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn addmv_(&mut self, mat: &Tensor, vec: &Tensor) -> Tensor
[src]
pub fn addr_(&mut self, vec1: &Tensor, vec2: &Tensor) -> Tensor
[src]
pub fn alpha_dropout_(&mut self, p: f64, train: bool) -> Tensor
[src]
pub fn arccos_(&mut self) -> Tensor
[src]
pub fn arccosh_(&mut self) -> Tensor
[src]
pub fn arcsin_(&mut self) -> Tensor
[src]
pub fn arcsinh_(&mut self) -> Tensor
[src]
pub fn arctan_(&mut self) -> Tensor
[src]
pub fn arctanh_(&mut self) -> Tensor
[src]
pub fn as_strided_(
    &mut self,
    size: &[i64],
    stride: &[i64],
    storage_offset: impl Into<Option<i64>>
) -> Tensor
[src]
pub fn asin_(&mut self) -> Tensor
[src]
pub fn asinh_(&mut self) -> Tensor
[src]
pub fn atan2_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn atan_(&mut self) -> Tensor
[src]
pub fn atanh_(&mut self) -> Tensor
[src]
pub fn baddbmm_(&mut self, batch1: &Tensor, batch2: &Tensor) -> Tensor
[src]
pub fn bernoulli_(&mut self, p: &Tensor) -> Tensor
[src]
pub fn bernoulli_float_(&mut self, p: f64) -> Tensor
[src]
pub fn bitwise_and_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn bitwise_and_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn bitwise_not_(&mut self) -> Tensor
[src]
pub fn bitwise_or_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn bitwise_or_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn bitwise_xor_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn bitwise_xor_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn cauchy_(&mut self, median: f64, sigma: f64) -> Tensor
[src]
pub fn ceil_(&mut self) -> Tensor
[src]
pub fn celu_(&mut self) -> Tensor
[src]
pub fn clamp_<S>(&mut self, min: S, max: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn clamp_max_<S>(&mut self, max: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn clamp_max_tensor_(&mut self, max: &Tensor) -> Tensor
[src]
pub fn clamp_min_<S>(&mut self, min: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn clamp_min_tensor_(&mut self, min: &Tensor) -> Tensor
[src]
pub fn clamp_tensor_<T>(&mut self, min: Option<T>, max: Option<T>) -> Tensor where
    T: Borrow<Tensor>, 
[src]
pub fn clip_<S>(&mut self, min: S, max: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn clip_tensor_<T>(&mut self, min: Option<T>, max: Option<T>) -> Tensor where
    T: Borrow<Tensor>, 
[src]
pub fn copy_sparse_to_sparse_(
    &mut self,
    src: &Tensor,
    non_blocking: bool
) -> Tensor
[src]
pub fn copysign_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn copysign_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn cos_(&mut self) -> Tensor
[src]
pub fn cosh_(&mut self) -> Tensor
[src]
pub fn cumprod_(&mut self, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn cumsum_(&mut self, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn deg2rad_(&mut self) -> Tensor
[src]
pub fn detach_(&mut self) -> Tensor
[src]
pub fn digamma_(&mut self) -> Tensor
[src]
pub fn g_div_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn g_div_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn g_div_scalar_mode_<S>(&mut self, other: S, rounding_mode: &str) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn g_div_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Tensor
[src]
pub fn divide_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn divide_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn divide_scalar_mode_<S>(
    &mut self,
    other: S,
    rounding_mode: &str
) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn divide_tensor_mode_(
    &mut self,
    other: &Tensor,
    rounding_mode: &str
) -> Tensor
[src]
pub fn dropout_(&mut self, p: f64, train: bool) -> Tensor
[src]
pub fn elu_(&mut self) -> Tensor
[src]
pub fn embedding_renorm_(
    &mut self,
    indices: &Tensor,
    max_norm: f64,
    norm_type: f64
) -> Tensor
[src]
pub fn eq_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn eq_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn erf_(&mut self) -> Tensor
[src]
pub fn erfc_(&mut self) -> Tensor
[src]
pub fn erfinv_(&mut self) -> Tensor
[src]
pub fn exp2_(&mut self) -> Tensor
[src]
pub fn exp_(&mut self) -> Tensor
[src]
pub fn expm1_(&mut self) -> Tensor
[src]
pub fn exponential_(&mut self, lambd: f64) -> Tensor
[src]
pub fn feature_alpha_dropout_(&mut self, p: f64, train: bool) -> Tensor
[src]
pub fn feature_dropout_(&mut self, p: f64, train: bool) -> Tensor
[src]
pub fn fill_<S>(&mut self, value: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn fill_diagonal_<S>(&mut self, fill_value: S, wrap: bool) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn fill_tensor_(&mut self, value: &Tensor) -> Tensor
[src]
pub fn fix_(&mut self) -> Tensor
[src]
pub fn float_power_<S>(&mut self, exponent: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn float_power_tensor_(&mut self, exponent: &Tensor) -> Tensor
[src]
pub fn floor_(&mut self) -> Tensor
[src]
pub fn floor_divide_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn floor_divide_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn fmod_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn fmod_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn frac_(&mut self) -> Tensor
[src]
pub fn gcd_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn ge_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn ge_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn geometric_(&mut self, p: f64) -> Tensor
[src]
pub fn greater_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn greater_equal_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn greater_equal_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn greater_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn gt_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn gt_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn hardsigmoid_(&mut self) -> Tensor
[src]
pub fn hardswish_(&mut self) -> Tensor
[src]
pub fn hardtanh_(&mut self) -> Tensor
[src]
pub fn heaviside_(&mut self, values: &Tensor) -> Tensor
[src]
pub fn hypot_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn i0_(&mut self) -> Tensor
[src]
pub fn igamma_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn igammac_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn index_add_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Tensor
[src]
pub fn index_add_alpha_<S>(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor,
    alpha: S
) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn index_copy_(
    &mut self,
    dim: i64,
    index: &Tensor,
    source: &Tensor
) -> Tensor
[src]
pub fn index_fill_<S>(&mut self, dim: i64, index: &Tensor, value: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn index_fill_int_tensor_(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: &Tensor
) -> Tensor
[src]
pub fn index_put_<T>(
    &mut self,
    indices: &[Option<T>],
    values: &Tensor,
    accumulate: bool
) -> Tensor where
    T: Borrow<Tensor>, 
[src]
pub fn lcm_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn ldexp_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn le_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn le_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn leaky_relu_(&mut self) -> Tensor
[src]
pub fn lerp_<S>(&mut self, end: &Tensor, weight: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn lerp_tensor_(&mut self, end: &Tensor, weight: &Tensor) -> Tensor
[src]
pub fn less_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn less_equal_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn less_equal_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn less_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn lgamma_(&mut self) -> Tensor
[src]
pub fn log10_(&mut self) -> Tensor
[src]
pub fn log1p_(&mut self) -> Tensor
[src]
pub fn log2_(&mut self) -> Tensor
[src]
pub fn log_(&mut self) -> Tensor
[src]
pub fn log_normal_(&mut self, mean: f64, std: f64) -> Tensor
[src]
pub fn logical_and_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn logical_not_(&mut self) -> Tensor
[src]
pub fn logical_or_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn logical_xor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn logit_(&mut self, eps: impl Into<Option<f64>>) -> Tensor
[src]
pub fn lt_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn lt_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn masked_fill_<S>(&mut self, mask: &Tensor, value: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn masked_fill_tensor_(&mut self, mask: &Tensor, value: &Tensor) -> Tensor
[src]
pub fn masked_scatter_(&mut self, mask: &Tensor, source: &Tensor) -> Tensor
[src]
pub fn mish_(&mut self) -> Tensor
[src]
pub fn g_mul_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn g_mul_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn multiply_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn multiply_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn mvlgamma_(&mut self, p: i64) -> Tensor
[src]
pub fn nan_to_num_(
    &mut self,
    nan: impl Into<Option<f64>>,
    posinf: impl Into<Option<f64>>,
    neginf: impl Into<Option<f64>>
) -> Tensor
[src]
pub fn ne_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn ne_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn neg_(&mut self) -> Tensor
[src]
pub fn negative_(&mut self) -> Tensor
[src]
pub fn nextafter_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn normal_(&mut self, mean: f64, std: f64) -> Tensor
[src]
pub fn not_equal_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn not_equal_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn polygamma_(&mut self, n: i64) -> Tensor
[src]
pub fn pow_<S>(&mut self, exponent: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn pow_tensor_(&mut self, exponent: &Tensor) -> Tensor
[src]
pub fn put_(
    &mut self,
    index: &Tensor,
    source: &Tensor,
    accumulate: bool
) -> Tensor
[src]
pub fn rad2deg_(&mut self) -> Tensor
[src]
pub fn random_(&mut self) -> Tensor
[src]
pub fn random_from_(&mut self, from: i64, to: impl Into<Option<i64>>) -> Tensor
[src]
pub fn random_to_(&mut self, to: i64) -> Tensor
[src]
pub fn reciprocal_(&mut self) -> Tensor
[src]
pub fn relu6_(&mut self) -> Tensor
[src]
pub fn relu_(&mut self) -> Tensor
[src]
pub fn remainder_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn remainder_tensor_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn renorm_<S>(&mut self, p: S, dim: i64, maxnorm: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn requires_grad_(&mut self, requires_grad: bool) -> Tensor
[src]
pub fn resize_(&mut self, size: &[i64]) -> Tensor
[src]
pub fn resize_as_(&mut self, the_template: &Tensor) -> Tensor
[src]
pub fn resize_as_sparse_(&mut self, the_template: &Tensor) -> Tensor
[src]
pub fn round_(&mut self) -> Tensor
[src]
pub fn rrelu_(&mut self, training: bool) -> Tensor
[src]
pub fn rrelu_with_noise_(&mut self, noise: &Tensor, training: bool) -> Tensor
[src]
pub fn rsqrt_(&mut self) -> Tensor
[src]
pub fn scatter_(&mut self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor
[src]
pub fn scatter_add_(&mut self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor
[src]
pub fn scatter_reduce_(
    &mut self,
    dim: i64,
    index: &Tensor,
    src: &Tensor,
    reduce: &str
) -> Tensor
[src]
pub fn scatter_value_<S>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S
) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn scatter_value_reduce_<S>(
    &mut self,
    dim: i64,
    index: &Tensor,
    value: S,
    reduce: &str
) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn selu_(&mut self) -> Tensor
[src]
pub fn set_(&mut self) -> Tensor
[src]
pub fn set_source_tensor_(&mut self, source: &Tensor) -> Tensor
[src]
pub fn sgn_(&mut self) -> Tensor
[src]
pub fn sigmoid_(&mut self) -> Tensor
[src]
pub fn sign_(&mut self) -> Tensor
[src]
pub fn silu_(&mut self) -> Tensor
[src]
pub fn sin_(&mut self) -> Tensor
[src]
pub fn sinc_(&mut self) -> Tensor
[src]
pub fn sinh_(&mut self) -> Tensor
[src]
pub fn sparse_resize_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Tensor
[src]
pub fn sparse_resize_and_clear_(
    &mut self,
    size: &[i64],
    sparse_dim: i64,
    dense_dim: i64
) -> Tensor
[src]
pub fn sqrt_(&mut self) -> Tensor
[src]
pub fn square_(&mut self) -> Tensor
[src]
pub fn squeeze_(&mut self) -> Tensor
[src]
pub fn squeeze_dim_(&mut self, dim: i64) -> Tensor
[src]
pub fn g_sub_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn g_sub_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn subtract_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn subtract_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn swapaxes_(&mut self, axis0: i64, axis1: i64) -> Tensor
[src]
pub fn swapdims_(&mut self, dim0: i64, dim1: i64) -> Tensor
[src]
pub fn t_(&mut self) -> Tensor
[src]
pub fn tan_(&mut self) -> Tensor
[src]
pub fn tanh_(&mut self) -> Tensor
[src]
pub fn threshold_<S>(&mut self, threshold: S, value: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn to_device_(
    &self,
    device: Device,
    dtype: Kind,
    non_blocking: bool,
    copy: bool
) -> Tensor
[src]
pub fn transpose_(&mut self, dim0: i64, dim1: i64) -> Tensor
[src]
pub fn tril_(&mut self, diagonal: i64) -> Tensor
[src]
pub fn triu_(&mut self, diagonal: i64) -> Tensor
[src]
pub fn true_divide_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn true_divide_scalar_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
pub fn trunc_(&mut self) -> Tensor
[src]
pub fn uniform_(&mut self, from: f64, to: f64) -> Tensor
[src]
pub fn unsqueeze_(&mut self, dim: i64) -> Tensor
[src]
pub fn view_(&self, size: &[i64]) -> Tensor
[src]
pub fn xlogy_(&mut self, other: &Tensor) -> Tensor
[src]
pub fn xlogy_scalar_other_<S>(&mut self, other: S) -> Tensor where
    S: Into<Scalar>, 
[src]
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

Performs the conversion.

Performs the conversion.

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.