Tensor
A tensor handle owned by the caller; dropped = released (the last release
frees the storage). Handles are tied to the Api that produced them.
Implements: Add, Debug, Div, Drop, IndexEntry, IndexOp, IntoOperand, Mul, Neg, Sub
abs / f_abs
fn f_abs(self) -> Result<Tensor>
fn abs(self) -> Tensor
ClikaRT::ops::abs: delegates to Api::f_op_abs.
abs_ / f_abs_
fn f_abs_(self) -> Result<&Self>
fn abs_(self) -> &Self
ClikaRT::ops::abs_: delegates to Api::f_op_abs_inplace.
acos / f_acos
fn f_acos(self) -> Result<Tensor>
fn acos(self) -> Tensor
ClikaRT::ops::acos: delegates to Api::f_op_acos.
acos_ / f_acos_
fn f_acos_(self) -> Result<&Self>
fn acos_(self) -> &Self
ClikaRT::ops::acos_: delegates to Api::f_op_acos_inplace.
acosh / f_acosh
fn f_acosh(self) -> Result<Tensor>
fn acosh(self) -> Tensor
ClikaRT::ops::acosh: delegates to Api::f_op_acosh.
acosh_ / f_acosh_
fn f_acosh_(self) -> Result<&Self>
fn acosh_(self) -> &Self
ClikaRT::ops::acosh_: delegates to Api::f_op_acosh_inplace.
adaptive_avg_pool / f_adaptive_avg_pool
fn f_adaptive_avg_pool(self, output_size: &[i64]) -> Result<Tensor>
fn adaptive_avg_pool(self, output_size: &[i64]) -> Tensor
ClikaRT::ops::adaptive_avg_pool: delegates to Api::f_op_adaptive_avg_pool.
adaptive_avg_pool1d / f_adaptive_avg_pool1d
fn f_adaptive_avg_pool1d(self, output_size: &[i64]) -> Result<Tensor>
fn adaptive_avg_pool1d(self, output_size: &[i64]) -> Tensor
ClikaRT::ops::adaptive_avg_pool1d: delegates to Api::f_op_adaptive_avg_pool1d.
adaptive_avg_pool2d / f_adaptive_avg_pool2d
fn f_adaptive_avg_pool2d(self, output_size: &[i64]) -> Result<Tensor>
fn adaptive_avg_pool2d(self, output_size: &[i64]) -> Tensor
ClikaRT::ops::adaptive_avg_pool2d: delegates to Api::f_op_adaptive_avg_pool2d.
adaptive_avg_pool3d / f_adaptive_avg_pool3d
fn f_adaptive_avg_pool3d(self, output_size: &[i64]) -> Result<Tensor>
fn adaptive_avg_pool3d(self, output_size: &[i64]) -> Tensor
ClikaRT::ops::adaptive_avg_pool3d: delegates to Api::f_op_adaptive_avg_pool3d.
adaptive_max_pool / f_adaptive_max_pool
fn f_adaptive_max_pool(self, output_size: &[i64]) -> Result<Tensor>
fn adaptive_max_pool(self, output_size: &[i64]) -> Tensor
ClikaRT::ops::adaptive_max_pool: delegates to Api::f_op_adaptive_max_pool.
adaptive_max_pool1d / f_adaptive_max_pool1d
fn f_adaptive_max_pool1d(self, output_size: &[i64]) -> Result<Tensor>
fn adaptive_max_pool1d(self, output_size: &[i64]) -> Tensor
ClikaRT::ops::adaptive_max_pool1d: delegates to Api::f_op_adaptive_max_pool1d.
adaptive_max_pool2d / f_adaptive_max_pool2d
fn f_adaptive_max_pool2d(self, output_size: &[i64]) -> Result<Tensor>
fn adaptive_max_pool2d(self, output_size: &[i64]) -> Tensor
ClikaRT::ops::adaptive_max_pool2d: delegates to Api::f_op_adaptive_max_pool2d.
adaptive_max_pool3d / f_adaptive_max_pool3d
fn f_adaptive_max_pool3d(self, output_size: &[i64]) -> Result<Tensor>
fn adaptive_max_pool3d(self, output_size: &[i64]) -> Tensor
ClikaRT::ops::adaptive_max_pool3d: delegates to Api::f_op_adaptive_max_pool3d.
add_ / f_add_
fn f_add_(self, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Result<&Self>
fn add_(self, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> &Self
ClikaRT::ops::add_: delegates to Api::f_op_add_inplace.
add_layer_norm / f_add_layer_norm
fn f_add_layer_norm(self, residual: Tensor, post_residual: Tensor, normalized_shape: &[i64], skip_bias: Tensor, weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Result<(Tensor, Tensor)>
fn add_layer_norm(self, residual: Tensor, post_residual: Tensor, normalized_shape: &[i64], skip_bias: Tensor, weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> (Tensor, Tensor)
ClikaRT::ops::add_layer_norm: delegates to Api::f_op_add_layer_norm.
add_rms_norm / f_add_rms_norm
fn f_add_rms_norm(self, residual: Tensor, residual2: Tensor, post_residual: Tensor, normalized_shape: &[i64], skip_bias: Tensor, weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Result<(Tensor, Tensor)>
fn add_rms_norm(self, residual: Tensor, residual2: Tensor, post_residual: Tensor, normalized_shape: &[i64], skip_bias: Tensor, weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> (Tensor, Tensor)
ClikaRT::ops::add_rms_norm: delegates to Api::f_op_add_rms_norm.
add_tensor / f_add_tensor
fn f_add_tensor(self, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Result<Tensor>
fn add_tensor(self, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::add: delegates to Api::f_op_add_tensor.
all / f_all
fn f_all(self, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn all(self, dims: &[i64], keepdim: bool) -> Tensor
ClikaRT::ops::all: delegates to Api::f_op_all.
allclose / f_allclose
fn f_allclose(self, other: Tensor, rtol: f64, atol: f64, equal_nan: bool) -> Result<Tensor>
fn allclose(self, other: Tensor, rtol: f64, atol: f64, equal_nan: bool) -> Tensor
ClikaRT::ops::allclose: delegates to Api::f_op_allclose.
amax / f_amax
fn f_amax(self, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn amax(self, dims: &[i64], keepdim: bool) -> Tensor
ClikaRT::ops::amax: delegates to Api::f_op_amax.
amin / f_amin
fn f_amin(self, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn amin(self, dims: &[i64], keepdim: bool) -> Tensor
ClikaRT::ops::amin: delegates to Api::f_op_amin.
aminmax / f_aminmax
fn f_aminmax(self, dim_has: bool, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn aminmax(self, dim_has: bool, dim: i64, keepdim: bool) -> (Tensor, Tensor)
ClikaRT::ops::aminmax: delegates to Api::f_op_aminmax.
any / f_any
fn f_any(self, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn any(self, dims: &[i64], keepdim: bool) -> Tensor
ClikaRT::ops::any: delegates to Api::f_op_any.
apply
fn apply(self, module: &M) -> Result<Tensor>
Run module.forward(self); reads as a left-to-right chain:
x.apply(&fc1)?.apply(&fc2)?.
argmax / f_argmax
fn f_argmax(self, dims: &[i64], keepdim: bool, index_dtype: clika_rt_data_type) -> Result<Tensor>
fn argmax(self, dims: &[i64], keepdim: bool, index_dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::argmax: delegates to Api::f_op_argmax.
argmin / f_argmin
fn f_argmin(self, dims: &[i64], keepdim: bool, index_dtype: clika_rt_data_type) -> Result<Tensor>
fn argmin(self, dims: &[i64], keepdim: bool, index_dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::argmin: delegates to Api::f_op_argmin.
argsort / f_argsort
fn f_argsort(self, dim: i64, descending: bool, stable: bool) -> Result<Tensor>
fn argsort(self, dim: i64, descending: bool, stable: bool) -> Tensor
ClikaRT::ops::argsort: delegates to Api::f_op_argsort.
asin / f_asin
fn f_asin(self) -> Result<Tensor>
fn asin(self) -> Tensor
ClikaRT::ops::asin: delegates to Api::f_op_asin.
asin_ / f_asin_
fn f_asin_(self) -> Result<&Self>
fn asin_(self) -> &Self
ClikaRT::ops::asin_: delegates to Api::f_op_asin_inplace.
asinh / f_asinh
fn f_asinh(self) -> Result<Tensor>
fn asinh(self) -> Tensor
ClikaRT::ops::asinh: delegates to Api::f_op_asinh.
asinh_ / f_asinh_
fn f_asinh_(self) -> Result<&Self>
fn asinh_(self) -> &Self
ClikaRT::ops::asinh_: delegates to Api::f_op_asinh_inplace.
atan / f_atan
fn f_atan(self) -> Result<Tensor>
fn atan(self) -> Tensor
ClikaRT::ops::atan: delegates to Api::f_op_atan.
atan2 / f_atan2
fn f_atan2(self, other: Tensor) -> Result<Tensor>
fn atan2(self, other: Tensor) -> Tensor
ClikaRT::ops::atan2: delegates to Api::f_op_atan2.
atan2_ / f_atan2_
fn f_atan2_(self, other: Tensor) -> Result<&Self>
fn atan2_(self, other: Tensor) -> &Self
ClikaRT::ops::atan2_: delegates to Api::f_op_atan2_inplace.
atan_ / f_atan_
fn f_atan_(self) -> Result<&Self>
fn atan_(self) -> &Self
ClikaRT::ops::atan_: delegates to Api::f_op_atan_inplace.
atanh / f_atanh
fn f_atanh(self) -> Result<Tensor>
fn atanh(self) -> Tensor
ClikaRT::ops::atanh: delegates to Api::f_op_atanh.
atanh_ / f_atanh_
fn f_atanh_(self) -> Result<&Self>
fn atanh_(self) -> &Self
ClikaRT::ops::atanh_: delegates to Api::f_op_atanh_inplace.
atleast_1d / f_atleast_1d
fn f_atleast_1d(self) -> Result<Tensor>
fn atleast_1d(self) -> Tensor
ClikaRT::ops::atleast_1d: delegates to Api::f_op_atleast_1d.
atleast_2d / f_atleast_2d
fn f_atleast_2d(self) -> Result<Tensor>
fn atleast_2d(self) -> Tensor
ClikaRT::ops::atleast_2d: delegates to Api::f_op_atleast_2d.
atleast_3d / f_atleast_3d
fn f_atleast_3d(self) -> Result<Tensor>
fn atleast_3d(self) -> Tensor
ClikaRT::ops::atleast_3d: delegates to Api::f_op_atleast_3d.
avg_pool / f_avg_pool
fn f_avg_pool(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Result<Tensor>
fn avg_pool(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Tensor
ClikaRT::ops::avg_pool: delegates to Api::f_op_avg_pool.
avg_pool1d / f_avg_pool1d
fn f_avg_pool1d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool) -> Result<Tensor>
fn avg_pool1d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool) -> Tensor
ClikaRT::ops::avg_pool1d: delegates to Api::f_op_avg_pool1d.
avg_pool2d / f_avg_pool2d
fn f_avg_pool2d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Result<Tensor>
fn avg_pool2d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Tensor
ClikaRT::ops::avg_pool2d: delegates to Api::f_op_avg_pool2d.
avg_pool3d / f_avg_pool3d
fn f_avg_pool3d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Result<Tensor>
fn avg_pool3d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Tensor
ClikaRT::ops::avg_pool3d: delegates to Api::f_op_avg_pool3d.
batch_norm / f_batch_norm
fn f_batch_norm(self, weight: Tensor, bias: Tensor, running_mean: Tensor, running_var: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn batch_norm(self, weight: Tensor, bias: Tensor, running_mean: Tensor, running_var: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::batch_norm: delegates to Api::f_op_batch_norm.
bernoulli_ / f_bernoulli_
fn f_bernoulli_(self, device: clika_rt_stream_or_device) -> Result<&Self>
fn bernoulli_(self, device: clika_rt_stream_or_device) -> &Self
ClikaRT::ops::bernoulli_: delegates to Api::f_op_bernoulli_inplace.
binary_cross_entropy / f_binary_cross_entropy
fn f_binary_cross_entropy(self, target: Tensor, weight: Tensor, reduction: clika_rt_reduction) -> Result<Tensor>
fn binary_cross_entropy(self, target: Tensor, weight: Tensor, reduction: clika_rt_reduction) -> Tensor
ClikaRT::ops::binary_cross_entropy: delegates to Api::f_op_binary_cross_entropy.
binary_cross_entropy_with_logits / f_binary_cross_entropy_with_logits
fn f_binary_cross_entropy_with_logits(self, target: Tensor, weight: Tensor, reduction: clika_rt_reduction, pos_weight: Tensor) -> Result<Tensor>
fn binary_cross_entropy_with_logits(self, target: Tensor, weight: Tensor, reduction: clika_rt_reduction, pos_weight: Tensor) -> Tensor
ClikaRT::ops::binary_cross_entropy_with_logits: delegates to Api::f_op_binary_cross_entropy_with_logits.
bincount / f_bincount
fn f_bincount(self, weights: Tensor, minlength: i64) -> Result<Tensor>
fn bincount(self, weights: Tensor, minlength: i64) -> Tensor
ClikaRT::ops::bincount: delegates to Api::f_op_bincount.
bitwise_and / f_bitwise_and
fn f_bitwise_and(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn bitwise_and(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::bitwise_and: delegates to Api::f_op_bitwise_and.
bitwise_and_ / f_bitwise_and_
fn f_bitwise_and_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn bitwise_and_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::bitwise_and_: delegates to Api::f_op_bitwise_and_inplace.
bitwise_left_shift / f_bitwise_left_shift
fn f_bitwise_left_shift(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn bitwise_left_shift(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::bitwise_left_shift: delegates to Api::f_op_bitwise_left_shift.
bitwise_left_shift_ / f_bitwise_left_shift_
fn f_bitwise_left_shift_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn bitwise_left_shift_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::bitwise_left_shift_: delegates to Api::f_op_bitwise_left_shift_inplace.
bitwise_not / f_bitwise_not
fn f_bitwise_not(self) -> Result<Tensor>
fn bitwise_not(self) -> Tensor
ClikaRT::ops::bitwise_not: delegates to Api::f_op_bitwise_not.
bitwise_not_ / f_bitwise_not_
fn f_bitwise_not_(self) -> Result<&Self>
fn bitwise_not_(self) -> &Self
ClikaRT::ops::bitwise_not_: delegates to Api::f_op_bitwise_not_inplace.
bitwise_or / f_bitwise_or
fn f_bitwise_or(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn bitwise_or(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::bitwise_or: delegates to Api::f_op_bitwise_or.
bitwise_or_ / f_bitwise_or_
fn f_bitwise_or_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn bitwise_or_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::bitwise_or_: delegates to Api::f_op_bitwise_or_inplace.
bitwise_right_shift / f_bitwise_right_shift
fn f_bitwise_right_shift(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn bitwise_right_shift(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::bitwise_right_shift: delegates to Api::f_op_bitwise_right_shift.
bitwise_right_shift_ / f_bitwise_right_shift_
fn f_bitwise_right_shift_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn bitwise_right_shift_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::bitwise_right_shift_: delegates to Api::f_op_bitwise_right_shift_inplace.
bitwise_xor / f_bitwise_xor
fn f_bitwise_xor(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn bitwise_xor(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::bitwise_xor: delegates to Api::f_op_bitwise_xor.
bitwise_xor_ / f_bitwise_xor_
fn f_bitwise_xor_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn bitwise_xor_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::bitwise_xor_: delegates to Api::f_op_bitwise_xor_inplace.
bmm / f_bmm
fn f_bmm(self, other: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn bmm(self, other: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::bmm: delegates to Api::f_op_bmm.
broadcast_to / f_broadcast_to
fn f_broadcast_to(self, shape: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn broadcast_to(self, shape: &[clika_rt_scalar_or_tensor]) -> Tensor
ClikaRT::ops::broadcast_to: delegates to Api::f_op_broadcast_to.
bucketize / f_bucketize
fn f_bucketize(self, boundaries: Tensor, out_int32: bool, right: bool) -> Result<Tensor>
fn bucketize(self, boundaries: Tensor, out_int32: bool, right: bool) -> Tensor
ClikaRT::ops::bucketize: delegates to Api::f_op_bucketize.
cast / f_cast
fn f_cast(self, target: clika_rt_data_type, force_copy: bool) -> Result<Tensor>
fn cast(self, target: clika_rt_data_type, force_copy: bool) -> Tensor
ClikaRT::ops::cast: delegates to Api::f_op_cast.
cast_like / f_cast_like
fn f_cast_like(self, reference: Tensor) -> Result<Tensor>
fn cast_like(self, reference: Tensor) -> Tensor
ClikaRT::ops::cast_like: delegates to Api::f_op_cast_like.
causal_conv_update / f_causal_conv_update
fn f_causal_conv_update(self, weight: Tensor, bias: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn causal_conv_update(self, weight: Tensor, bias: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::causal_conv_update: delegates to Api::f_op_causal_conv_update.
ceil / f_ceil
fn f_ceil(self) -> Result<Tensor>
fn ceil(self) -> Tensor
ClikaRT::ops::ceil: delegates to Api::f_op_ceil.
ceil_ / f_ceil_
fn f_ceil_(self) -> Result<&Self>
fn ceil_(self) -> &Self
ClikaRT::ops::ceil_: delegates to Api::f_op_ceil_inplace.
celu / f_celu
fn f_celu(self, alpha: f64) -> Result<Tensor>
fn celu(self, alpha: f64) -> Tensor
ClikaRT::ops::celu: delegates to Api::f_op_celu.
celu_ / f_celu_
fn f_celu_(self, alpha: f64) -> Result<&Self>
fn celu_(self, alpha: f64) -> &Self
ClikaRT::ops::celu_: delegates to Api::f_op_celu_inplace.
chunk / f_chunk
fn f_chunk(self, num_chunks: i64, dim: i64) -> Result<TensorList>
fn chunk(self, num_chunks: i64, dim: i64) -> TensorList
ClikaRT::ops::chunk: delegates to Api::f_op_chunk.
circular_pad / f_circular_pad
fn f_circular_pad(self, pad: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn circular_pad(self, pad: &[clika_rt_scalar_or_tensor]) -> Tensor
ClikaRT::ops::circular_pad: delegates to Api::f_op_circular_pad.
clamp / f_clamp
fn f_clamp(self, min: clika_rt_scalar_or_tensor, max: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn clamp(self, min: clika_rt_scalar_or_tensor, max: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::clamp: delegates to Api::f_op_clamp.
clamp_ / f_clamp_
fn f_clamp_(self, min: clika_rt_scalar_or_tensor, max: clika_rt_scalar_or_tensor) -> Result<&Self>
fn clamp_(self, min: clika_rt_scalar_or_tensor, max: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::clamp_: delegates to Api::f_op_clamp_inplace.
clamp_max / f_clamp_max
fn f_clamp_max(self, max: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn clamp_max(self, max: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::clamp_max: delegates to Api::f_op_clamp_max.
clamp_max_ / f_clamp_max_
fn f_clamp_max_(self, max: clika_rt_scalar_or_tensor) -> Result<&Self>
fn clamp_max_(self, max: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::clamp_max_: delegates to Api::f_op_clamp_max_inplace.
clamp_min / f_clamp_min
fn f_clamp_min(self, min: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn clamp_min(self, min: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::clamp_min: delegates to Api::f_op_clamp_min.
clamp_min_ / f_clamp_min_
fn f_clamp_min_(self, min: clika_rt_scalar_or_tensor) -> Result<&Self>
fn clamp_min_(self, min: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::clamp_min_: delegates to Api::f_op_clamp_min_inplace.
constant_pad / f_constant_pad
fn f_constant_pad(self, pad: &[clika_rt_scalar_or_tensor], value: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn constant_pad(self, pad: &[clika_rt_scalar_or_tensor], value: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::constant_pad: delegates to Api::f_op_constant_pad.
contiguous / f_contiguous
fn f_contiguous(self, force_copy: bool) -> Result<Tensor>
fn contiguous(self, force_copy: bool) -> Tensor
ClikaRT::ops::contiguous: delegates to Api::f_op_contiguous.
conv / f_conv
fn f_conv(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, mode: clika_rt_pad_mode, value_has: bool, value: f64, activation: clika_rt_activation) -> Result<Tensor>
fn conv(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, mode: clika_rt_pad_mode, value_has: bool, value: f64, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::conv: delegates to Api::f_op_conv.
conv1d / f_conv1d
fn f_conv1d(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn conv1d(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::conv1d: delegates to Api::f_op_conv1d.
conv2d / f_conv2d
fn f_conv2d(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn conv2d(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::conv2d: delegates to Api::f_op_conv2d.
conv3d / f_conv3d
fn f_conv3d(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn conv3d(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::conv3d: delegates to Api::f_op_conv3d.
conv_transpose / f_conv_transpose
fn f_conv_transpose(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], groups: i64, dilation: &[i64], activation: clika_rt_activation) -> Result<Tensor>
fn conv_transpose(self, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], groups: i64, dilation: &[i64], activation: clika_rt_activation) -> Tensor
ClikaRT::ops::conv_transpose: delegates to Api::f_op_conv_transpose.
conv_transpose1d / f_conv_transpose1d
fn f_conv_transpose1d(self, weight: Tensor, bias: Tensor, options: &ConvTranspose1dOptions) -> Result<Tensor>
fn conv_transpose1d(self, weight: Tensor, bias: Tensor, options: &ConvTranspose1dOptions) -> Tensor
ClikaRT::ops::conv_transpose1d: delegates to Api::f_op_conv_transpose1d.
conv_transpose2d / f_conv_transpose2d
fn f_conv_transpose2d(self, weight: Tensor, bias: Tensor, options: &ConvTranspose2dOptions) -> Result<Tensor>
fn conv_transpose2d(self, weight: Tensor, bias: Tensor, options: &ConvTranspose2dOptions) -> Tensor
ClikaRT::ops::conv_transpose2d: delegates to Api::f_op_conv_transpose2d.
conv_transpose3d / f_conv_transpose3d
fn f_conv_transpose3d(self, weight: Tensor, bias: Tensor, options: &ConvTranspose3dOptions) -> Result<Tensor>
fn conv_transpose3d(self, weight: Tensor, bias: Tensor, options: &ConvTranspose3dOptions) -> Tensor
ClikaRT::ops::conv_transpose3d: delegates to Api::f_op_conv_transpose3d.
copy_ / f_copy_
fn f_copy_(self, src: Tensor, target: clika_rt_stream_or_device) -> Result<&Self>
fn copy_(self, src: Tensor, target: clika_rt_stream_or_device) -> &Self
ClikaRT::ops::copy_: delegates to Api::f_op_copy_inplace.
copysign / f_copysign
fn f_copysign(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn copysign(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::copysign: delegates to Api::f_op_copysign.
copysign_ / f_copysign_
fn f_copysign_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn copysign_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::copysign_: delegates to Api::f_op_copysign_inplace.
cos / f_cos
fn f_cos(self) -> Result<Tensor>
fn cos(self) -> Tensor
ClikaRT::ops::cos: delegates to Api::f_op_cos.
cos_ / f_cos_
fn f_cos_(self) -> Result<&Self>
fn cos_(self) -> &Self
ClikaRT::ops::cos_: delegates to Api::f_op_cos_inplace.
cosh / f_cosh
fn f_cosh(self) -> Result<Tensor>
fn cosh(self) -> Tensor
ClikaRT::ops::cosh: delegates to Api::f_op_cosh.
cosh_ / f_cosh_
fn f_cosh_(self) -> Result<&Self>
fn cosh_(self) -> &Self
ClikaRT::ops::cosh_: delegates to Api::f_op_cosh_inplace.
count_nonzero / f_count_nonzero
fn f_count_nonzero(self, dims: &[i64]) -> Result<Tensor>
fn count_nonzero(self, dims: &[i64]) -> Tensor
ClikaRT::ops::count_nonzero: delegates to Api::f_op_count_nonzero.
cross / f_cross
fn f_cross(self, other: Tensor, dim_has: bool, dim: i64) -> Result<Tensor>
fn cross(self, other: Tensor, dim_has: bool, dim: i64) -> Tensor
ClikaRT::ops::cross: delegates to Api::f_op_cross.
cross_entropy / f_cross_entropy
fn f_cross_entropy(self, target: Tensor, weight: Tensor, ignore_index_has: bool, ignore_index: i64, reduction: clika_rt_reduction) -> Result<Tensor>
fn cross_entropy(self, target: Tensor, weight: Tensor, ignore_index_has: bool, ignore_index: i64, reduction: clika_rt_reduction) -> Tensor
ClikaRT::ops::cross_entropy: delegates to Api::f_op_cross_entropy.
cummax / f_cummax
fn f_cummax(self, dim: i64) -> Result<(Tensor, Tensor)>
fn cummax(self, dim: i64) -> (Tensor, Tensor)
ClikaRT::ops::cummax: delegates to Api::f_op_cummax.
cummin / f_cummin
fn f_cummin(self, dim: i64) -> Result<(Tensor, Tensor)>
fn cummin(self, dim: i64) -> (Tensor, Tensor)
ClikaRT::ops::cummin: delegates to Api::f_op_cummin.
cumprod / f_cumprod
fn f_cumprod(self, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn cumprod(self, dim: i64, dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::cumprod: delegates to Api::f_op_cumprod.
cumprod_ / f_cumprod_
fn f_cumprod_(self, dim: i64, dtype: clika_rt_data_type) -> Result<&Self>
fn cumprod_(self, dim: i64, dtype: clika_rt_data_type) -> &Self
ClikaRT::ops::cumprod_: delegates to Api::f_op_cumprod_inplace.
cumsum / f_cumsum
fn f_cumsum(self, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn cumsum(self, dim: i64, dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::cumsum: delegates to Api::f_op_cumsum.
cumsum_ / f_cumsum_
fn f_cumsum_(self, dim: i64, dtype: clika_rt_data_type) -> Result<&Self>
fn cumsum_(self, dim: i64, dtype: clika_rt_data_type) -> &Self
ClikaRT::ops::cumsum_: delegates to Api::f_op_cumsum_inplace.
deform_conv / f_deform_conv
fn f_deform_conv(self, weight: Tensor, offset: Tensor, mask: Tensor, bias: Tensor, options: &DeformConvOptions) -> Result<Tensor>
fn deform_conv(self, weight: Tensor, offset: Tensor, mask: Tensor, bias: Tensor, options: &DeformConvOptions) -> Tensor
ClikaRT::ops::deform_conv: delegates to Api::f_op_deform_conv.
deg2rad / f_deg2rad
fn f_deg2rad(self) -> Result<Tensor>
fn deg2rad(self) -> Tensor
ClikaRT::ops::deg2rad: delegates to Api::f_op_deg2rad.
deg2rad_ / f_deg2rad_
fn f_deg2rad_(self) -> Result<&Self>
fn deg2rad_(self) -> &Self
ClikaRT::ops::deg2rad_: delegates to Api::f_op_deg2rad_inplace.
diag / f_diag
fn f_diag(self, diagonal: i64) -> Result<Tensor>
fn diag(self, diagonal: i64) -> Tensor
ClikaRT::ops::diag: delegates to Api::f_op_diag.
diag_embed / f_diag_embed
fn f_diag_embed(self, offset: i64, dim1: i64, dim2: i64) -> Result<Tensor>
fn diag_embed(self, offset: i64, dim1: i64, dim2: i64) -> Tensor
ClikaRT::ops::diag_embed: delegates to Api::f_op_diag_embed.
diagonal / f_diagonal
fn f_diagonal(self, offset: i64, dim1: i64, dim2: i64) -> Result<Tensor>
fn diagonal(self, offset: i64, dim1: i64, dim2: i64) -> Tensor
ClikaRT::ops::diagonal: delegates to Api::f_op_diagonal.
diff / f_diff
fn f_diff(self, n: i64, dim: i64, prepend: Tensor, append: Tensor) -> Result<Tensor>
fn diff(self, n: i64, dim: i64, prepend: Tensor, append: Tensor) -> Tensor
ClikaRT::ops::diff: delegates to Api::f_op_diff.
div_ / f_div_
fn f_div_(self, other: clika_rt_scalar_or_tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation) -> Result<&Self>
fn div_(self, other: clika_rt_scalar_or_tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation) -> &Self
ClikaRT::ops::div_: delegates to Api::f_op_div_inplace.
div_tensor / f_div_tensor
fn f_div_tensor(self, other: clika_rt_scalar_or_tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation) -> Result<Tensor>
fn div_tensor(self, other: clika_rt_scalar_or_tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::div: delegates to Api::f_op_div_tensor.
dot / f_dot
fn f_dot(self, other: Tensor) -> Result<Tensor>
fn dot(self, other: Tensor) -> Tensor
ClikaRT::ops::dot: delegates to Api::f_op_dot.
dynamic_quantize / f_dynamic_quantize
fn f_dynamic_quantize(self) -> Result<(Tensor, Tensor, Tensor)>
fn dynamic_quantize(self) -> (Tensor, Tensor, Tensor)
ClikaRT::ops::dynamic_quantize: delegates to Api::f_op_dynamic_quantize.
elu / f_elu
fn f_elu(self, alpha: f64, scale: f64, input_scale: f64) -> Result<Tensor>
fn elu(self, alpha: f64, scale: f64, input_scale: f64) -> Tensor
ClikaRT::ops::elu: delegates to Api::f_op_elu.
elu_ / f_elu_
fn f_elu_(self, alpha: f64, scale: f64, input_scale: f64) -> Result<&Self>
fn elu_(self, alpha: f64, scale: f64, input_scale: f64) -> &Self
ClikaRT::ops::elu_: delegates to Api::f_op_elu_inplace.
eq / f_eq
fn f_eq(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn eq(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::eq: delegates to Api::f_op_eq.
eq_ / f_eq_
fn f_eq_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn eq_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::eq_: delegates to Api::f_op_eq_inplace.
erf / f_erf
fn f_erf(self) -> Result<Tensor>
fn erf(self) -> Tensor
ClikaRT::ops::erf: delegates to Api::f_op_erf.
erf_ / f_erf_
fn f_erf_(self) -> Result<&Self>
fn erf_(self) -> &Self
ClikaRT::ops::erf_: delegates to Api::f_op_erf_inplace.
erfc / f_erfc
fn f_erfc(self) -> Result<Tensor>
fn erfc(self) -> Tensor
ClikaRT::ops::erfc: delegates to Api::f_op_erfc.
erfc_ / f_erfc_
fn f_erfc_(self) -> Result<&Self>
fn erfc_(self) -> &Self
ClikaRT::ops::erfc_: delegates to Api::f_op_erfc_inplace.
erfinv / f_erfinv
fn f_erfinv(self) -> Result<Tensor>
fn erfinv(self) -> Tensor
ClikaRT::ops::erfinv: delegates to Api::f_op_erfinv.
erfinv_ / f_erfinv_
fn f_erfinv_(self) -> Result<&Self>
fn erfinv_(self) -> &Self
ClikaRT::ops::erfinv_: delegates to Api::f_op_erfinv_inplace.
exp / f_exp
fn f_exp(self) -> Result<Tensor>
fn exp(self) -> Tensor
ClikaRT::ops::exp: delegates to Api::f_op_exp.
exp_ / f_exp_
fn f_exp_(self) -> Result<&Self>
fn exp_(self) -> &Self
ClikaRT::ops::exp_: delegates to Api::f_op_exp_inplace.
expand / f_expand
fn f_expand(self, shape: &[clika_rt_scalar_or_tensor], bidirectional: bool) -> Result<Tensor>
fn expand(self, shape: &[clika_rt_scalar_or_tensor], bidirectional: bool) -> Tensor
ClikaRT::ops::expand: delegates to Api::f_op_expand.
expand_as / f_expand_as
fn f_expand_as(self, other: Tensor) -> Result<Tensor>
fn expand_as(self, other: Tensor) -> Tensor
ClikaRT::ops::expand_as: delegates to Api::f_op_expand_as.
exponential_ / f_exponential_
fn f_exponential_(self, lambd: f64, device: clika_rt_stream_or_device) -> Result<&Self>
fn exponential_(self, lambd: f64, device: clika_rt_stream_or_device) -> &Self
ClikaRT::ops::exponential_: delegates to Api::f_op_exponential_inplace.
fast_gelu / f_fast_gelu
fn f_fast_gelu(self) -> Result<Tensor>
fn fast_gelu(self) -> Tensor
ClikaRT::ops::fast_gelu: delegates to Api::f_op_fast_gelu.
fill / f_fill
fn f_fill(self, value: clika_rt_scalar_or_tensor, device: clika_rt_stream_or_device) -> Result<Tensor>
fn fill(self, value: clika_rt_scalar_or_tensor, device: clika_rt_stream_or_device) -> Tensor
ClikaRT::ops::fill: delegates to Api::f_op_fill.
fill_ / f_fill_
fn f_fill_(self, value: clika_rt_scalar_or_tensor, device: clika_rt_stream_or_device) -> Result<&Self>
fn fill_(self, value: clika_rt_scalar_or_tensor, device: clika_rt_stream_or_device) -> &Self
ClikaRT::ops::fill_: delegates to Api::f_op_fill_inplace.
fill_diagonal / f_fill_diagonal
fn f_fill_diagonal(self, fill_value: clika_rt_scalar, wrap: bool, device: clika_rt_stream_or_device) -> Result<Tensor>
fn fill_diagonal(self, fill_value: clika_rt_scalar, wrap: bool, device: clika_rt_stream_or_device) -> Tensor
ClikaRT::ops::fill_diagonal: delegates to Api::f_op_fill_diagonal.
fill_diagonal_ / f_fill_diagonal_
fn f_fill_diagonal_(self, fill_value: clika_rt_scalar, wrap: bool, device: clika_rt_stream_or_device) -> Result<&Self>
fn fill_diagonal_(self, fill_value: clika_rt_scalar, wrap: bool, device: clika_rt_stream_or_device) -> &Self
ClikaRT::ops::fill_diagonal_: delegates to Api::f_op_fill_diagonal_inplace.
flatten / f_flatten
fn f_flatten(self, start_dim: i64, end_dim: i64) -> Result<Tensor>
fn flatten(self, start_dim: i64, end_dim: i64) -> Tensor
ClikaRT::ops::flatten: delegates to Api::f_op_flatten.
flip / f_flip
fn f_flip(self, dims: &[i64]) -> Result<Tensor>
fn flip(self, dims: &[i64]) -> Tensor
ClikaRT::ops::flip: delegates to Api::f_op_flip.
fliplr / f_fliplr
fn f_fliplr(self) -> Result<Tensor>
fn fliplr(self) -> Tensor
ClikaRT::ops::fliplr: delegates to Api::f_op_fliplr.
flipud / f_flipud
fn f_flipud(self) -> Result<Tensor>
fn flipud(self) -> Tensor
ClikaRT::ops::flipud: delegates to Api::f_op_flipud.
floor / f_floor
fn f_floor(self) -> Result<Tensor>
fn floor(self) -> Tensor
ClikaRT::ops::floor: delegates to Api::f_op_floor.
floor_ / f_floor_
fn f_floor_(self) -> Result<&Self>
fn floor_(self) -> &Self
ClikaRT::ops::floor_: delegates to Api::f_op_floor_inplace.
floor_divide / f_floor_divide
fn f_floor_divide(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn floor_divide(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::floor_divide: delegates to Api::f_op_floor_divide.
floor_divide_ / f_floor_divide_
fn f_floor_divide_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn floor_divide_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::floor_divide_: delegates to Api::f_op_floor_divide_inplace.
fmax / f_fmax
fn f_fmax(self, other: Tensor) -> Result<Tensor>
fn fmax(self, other: Tensor) -> Tensor
ClikaRT::ops::fmax: delegates to Api::f_op_fmax.
fmin / f_fmin
fn f_fmin(self, other: Tensor) -> Result<Tensor>
fn fmin(self, other: Tensor) -> Tensor
ClikaRT::ops::fmin: delegates to Api::f_op_fmin.
fmod / f_fmod
fn f_fmod(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn fmod(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::fmod: delegates to Api::f_op_fmod.
fmod_ / f_fmod_
fn f_fmod_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn fmod_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::fmod_: delegates to Api::f_op_fmod_inplace.
fold / f_fold
fn f_fold(self, output_size: &[i64], kernel_size: &[i64], dilation: &[i64], padding: &[i64], stride: &[i64], mode: clika_rt_pad_mode, value_has: bool, value: f64) -> Result<Tensor>
fn fold(self, output_size: &[i64], kernel_size: &[i64], dilation: &[i64], padding: &[i64], stride: &[i64], mode: clika_rt_pad_mode, value_has: bool, value: f64) -> Tensor
ClikaRT::ops::fold: delegates to Api::f_op_fold.
frac / f_frac
fn f_frac(self) -> Result<Tensor>
fn frac(self) -> Tensor
ClikaRT::ops::frac: delegates to Api::f_op_frac.
frac_ / f_frac_
fn f_frac_(self) -> Result<&Self>
fn frac_(self) -> &Self
ClikaRT::ops::frac_: delegates to Api::f_op_frac_inplace.
frexp / f_frexp
fn f_frexp(self) -> Result<(Tensor, Tensor)>
fn frexp(self) -> (Tensor, Tensor)
ClikaRT::ops::frexp: delegates to Api::f_op_frexp.
gated_rms_norm / f_gated_rms_norm
fn f_gated_rms_norm(self, gate: Tensor, normalized_shape: &[i64], weight: Tensor, eps_has: bool, eps: f64) -> Result<Tensor>
fn gated_rms_norm(self, gate: Tensor, normalized_shape: &[i64], weight: Tensor, eps_has: bool, eps: f64) -> Tensor
ClikaRT::ops::gated_rms_norm: delegates to Api::f_op_gated_rms_norm.
gather / f_gather
fn f_gather(self, dim: i64, index: Tensor) -> Result<Tensor>
fn gather(self, dim: i64, index: Tensor) -> Tensor
ClikaRT::ops::gather: delegates to Api::f_op_gather.
ge / f_ge
fn f_ge(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn ge(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::ge: delegates to Api::f_op_ge.
ge_ / f_ge_
fn f_ge_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn ge_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::ge_: delegates to Api::f_op_ge_inplace.
geglu / f_geglu
fn f_geglu(self, approximate: clika_rt_gelu_mode) -> Result<Tensor>
fn geglu(self, approximate: clika_rt_gelu_mode) -> Tensor
ClikaRT::ops::geglu: delegates to Api::f_op_geglu.
gelu / f_gelu
fn f_gelu(self, approximate: clika_rt_gelu_mode) -> Result<Tensor>
fn gelu(self, approximate: clika_rt_gelu_mode) -> Tensor
ClikaRT::ops::gelu: delegates to Api::f_op_gelu.
gelu_ / f_gelu_
fn f_gelu_(self, approximate: clika_rt_gelu_mode) -> Result<&Self>
fn gelu_(self, approximate: clika_rt_gelu_mode) -> &Self
ClikaRT::ops::gelu_: delegates to Api::f_op_gelu_inplace.
glu / f_glu
fn f_glu(self, dim: i64) -> Result<Tensor>
fn glu(self, dim: i64) -> Tensor
ClikaRT::ops::glu: delegates to Api::f_op_glu.
grid_sample / f_grid_sample
fn f_grid_sample(self, grid: Tensor, mode: clika_rt_grid_sample_mode, padding_mode: clika_rt_grid_sample_padding_mode, align_corners: bool) -> Result<Tensor>
fn grid_sample(self, grid: Tensor, mode: clika_rt_grid_sample_mode, padding_mode: clika_rt_grid_sample_padding_mode, align_corners: bool) -> Tensor
ClikaRT::ops::grid_sample: delegates to Api::f_op_grid_sample.
group_norm / f_group_norm
fn f_group_norm(self, num_groups: i64, weight: Tensor, bias: Tensor, running_mean: Tensor, running_var: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn group_norm(self, num_groups: i64, weight: Tensor, bias: Tensor, running_mean: Tensor, running_var: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::group_norm: delegates to Api::f_op_group_norm.
gt / f_gt
fn f_gt(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn gt(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::gt: delegates to Api::f_op_gt.
gt_ / f_gt_
fn f_gt_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn gt_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::gt_: delegates to Api::f_op_gt_inplace.
hardshrink / f_hardshrink
fn f_hardshrink(self, lambd: f64) -> Result<Tensor>
fn hardshrink(self, lambd: f64) -> Tensor
ClikaRT::ops::hardshrink: delegates to Api::f_op_hardshrink.
hardshrink_ / f_hardshrink_
fn f_hardshrink_(self, lambd: f64) -> Result<&Self>
fn hardshrink_(self, lambd: f64) -> &Self
ClikaRT::ops::hardshrink_: delegates to Api::f_op_hardshrink_inplace.
hardsigmoid / f_hardsigmoid
fn f_hardsigmoid(self) -> Result<Tensor>
fn hardsigmoid(self) -> Tensor
ClikaRT::ops::hardsigmoid: delegates to Api::f_op_hardsigmoid.
hardsigmoid_ / f_hardsigmoid_
fn f_hardsigmoid_(self) -> Result<&Self>
fn hardsigmoid_(self) -> &Self
ClikaRT::ops::hardsigmoid_: delegates to Api::f_op_hardsigmoid_inplace.
hardswish / f_hardswish
fn f_hardswish(self) -> Result<Tensor>
fn hardswish(self) -> Tensor
ClikaRT::ops::hardswish: delegates to Api::f_op_hardswish.
hardswish_ / f_hardswish_
fn f_hardswish_(self) -> Result<&Self>
fn hardswish_(self) -> &Self
ClikaRT::ops::hardswish_: delegates to Api::f_op_hardswish_inplace.
hardtanh / f_hardtanh
fn f_hardtanh(self, min_val: f64, max_val: f64) -> Result<Tensor>
fn hardtanh(self, min_val: f64, max_val: f64) -> Tensor
ClikaRT::ops::hardtanh: delegates to Api::f_op_hardtanh.
hardtanh_ / f_hardtanh_
fn f_hardtanh_(self, min_val: f64, max_val: f64) -> Result<&Self>
fn hardtanh_(self, min_val: f64, max_val: f64) -> &Self
ClikaRT::ops::hardtanh_: delegates to Api::f_op_hardtanh_inplace.
hash_128 / f_hash_128
fn f_hash_128(self, seed: u64) -> Result<Tensor>
fn hash_128(self, seed: u64) -> Tensor
ClikaRT::ops::hash_128: delegates to Api::f_op_hash_128.
hash_256 / f_hash_256
fn f_hash_256(self, seed: u64) -> Result<Tensor>
fn hash_256(self, seed: u64) -> Tensor
ClikaRT::ops::hash_256: delegates to Api::f_op_hash_256.
hash_64 / f_hash_64
fn f_hash_64(self, seed: u64) -> Result<Tensor>
fn hash_64(self, seed: u64) -> Tensor
ClikaRT::ops::hash_64: delegates to Api::f_op_hash_64.
hash_tensor / f_hash_tensor
fn f_hash_tensor(self, dims: &[i64], keepdim: bool, mode: clika_rt_hash_tensor_mode) -> Result<Tensor>
fn hash_tensor(self, dims: &[i64], keepdim: bool, mode: clika_rt_hash_tensor_mode) -> Tensor
ClikaRT::ops::hash_tensor: delegates to Api::f_op_hash_tensor.
histogram / f_histogram
fn f_histogram(self, bins: i64, range: Tensor, weight: Tensor, density: bool) -> Result<(Tensor, Tensor)>
fn histogram(self, bins: i64, range: Tensor, weight: Tensor, density: bool) -> (Tensor, Tensor)
ClikaRT::ops::histogram: delegates to Api::f_op_histogram.
huber_loss / f_huber_loss
fn f_huber_loss(self, target: Tensor, reduction: clika_rt_reduction, delta: f64) -> Result<Tensor>
fn huber_loss(self, target: Tensor, reduction: clika_rt_reduction, delta: f64) -> Tensor
ClikaRT::ops::huber_loss: delegates to Api::f_op_huber_loss.
hypot / f_hypot
fn f_hypot(self, other: Tensor) -> Result<Tensor>
fn hypot(self, other: Tensor) -> Tensor
ClikaRT::ops::hypot: delegates to Api::f_op_hypot.
hypot_ / f_hypot_
fn f_hypot_(self, other: Tensor) -> Result<&Self>
fn hypot_(self, other: Tensor) -> &Self
ClikaRT::ops::hypot_: delegates to Api::f_op_hypot_inplace.
index / f_index
fn f_index(self, indices: &[clika_rt_index_entry]) -> Result<Tensor>
fn index(self, indices: &[clika_rt_index_entry]) -> Tensor
ClikaRT::ops::index: delegates to Api::f_op_index.
index_add / f_index_add
fn f_index_add(self, dim: i64, indices: Tensor, src: Tensor) -> Result<Tensor>
fn index_add(self, dim: i64, indices: Tensor, src: Tensor) -> Tensor
ClikaRT::ops::index_add: delegates to Api::f_op_index_add.
index_add_ / f_index_add_
fn f_index_add_(self, dim: i64, indices: Tensor, src: Tensor) -> Result<&Self>
fn index_add_(self, dim: i64, indices: Tensor, src: Tensor) -> &Self
ClikaRT::ops::index_add_: delegates to Api::f_op_index_add_inplace.
index_copy / f_index_copy
fn f_index_copy(self, dim: i64, indices: Tensor, src: Tensor) -> Result<Tensor>
fn index_copy(self, dim: i64, indices: Tensor, src: Tensor) -> Tensor
ClikaRT::ops::index_copy: delegates to Api::f_op_index_copy.
index_copy_ / f_index_copy_
fn f_index_copy_(self, dim: i64, indices: Tensor, src: Tensor) -> Result<&Self>
fn index_copy_(self, dim: i64, indices: Tensor, src: Tensor) -> &Self
ClikaRT::ops::index_copy_: delegates to Api::f_op_index_copy_inplace.
index_fill / f_index_fill
fn f_index_fill(self, dim: i64, indices: Tensor, value: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn index_fill(self, dim: i64, indices: Tensor, value: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::index_fill: delegates to Api::f_op_index_fill.
index_fill_ / f_index_fill_
fn f_index_fill_(self, dim: i64, indices: Tensor, value: clika_rt_scalar_or_tensor) -> Result<&Self>
fn index_fill_(self, dim: i64, indices: Tensor, value: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::index_fill_: delegates to Api::f_op_index_fill_inplace.
index_put / f_index_put
fn f_index_put(self, indices: &[clika_rt_index_entry], value: clika_rt_scalar_or_tensor, accumulate: bool) -> Result<Tensor>
fn index_put(self, indices: &[clika_rt_index_entry], value: clika_rt_scalar_or_tensor, accumulate: bool) -> Tensor
ClikaRT::ops::index_put: delegates to Api::f_op_index_put.
index_put_ / f_index_put_
fn f_index_put_(self, indices: &[clika_rt_index_entry], value: clika_rt_scalar_or_tensor, accumulate: bool) -> Result<&Self>
fn index_put_(self, indices: &[clika_rt_index_entry], value: clika_rt_scalar_or_tensor, accumulate: bool) -> &Self
ClikaRT::ops::index_put_: delegates to Api::f_op_index_put_inplace.
index_select / f_index_select
fn f_index_select(self, dim: i64, index: Tensor) -> Result<Tensor>
fn index_select(self, dim: i64, index: Tensor) -> Tensor
ClikaRT::ops::index_select: delegates to Api::f_op_index_select.
inner / f_inner
fn f_inner(self, other: Tensor) -> Result<Tensor>
fn inner(self, other: Tensor) -> Tensor
ClikaRT::ops::inner: delegates to Api::f_op_inner.
instance_norm / f_instance_norm
fn f_instance_norm(self, weight: Tensor, bias: Tensor, running_mean: Tensor, running_var: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn instance_norm(self, weight: Tensor, bias: Tensor, running_mean: Tensor, running_var: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::instance_norm: delegates to Api::f_op_instance_norm.
interpolate / f_interpolate
fn f_interpolate(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], mode: clika_rt_interp_mode, align_corners_has: bool, align_corners: bool, recompute_scale_factor: bool, antialias: bool) -> Result<Tensor>
fn interpolate(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], mode: clika_rt_interp_mode, align_corners_has: bool, align_corners: bool, recompute_scale_factor: bool, antialias: bool) -> Tensor
ClikaRT::ops::interpolate: delegates to Api::f_op_interpolate.
isclose / f_isclose
fn f_isclose(self, other: Tensor, rtol: f64, atol: f64, equal_nan: bool) -> Result<Tensor>
fn isclose(self, other: Tensor, rtol: f64, atol: f64, equal_nan: bool) -> Tensor
ClikaRT::ops::isclose: delegates to Api::f_op_isclose.
isfinite / f_isfinite
fn f_isfinite(self) -> Result<Tensor>
fn isfinite(self) -> Tensor
ClikaRT::ops::isfinite: delegates to Api::f_op_isfinite.
isinf / f_isinf
fn f_isinf(self) -> Result<Tensor>
fn isinf(self) -> Tensor
ClikaRT::ops::isinf: delegates to Api::f_op_isinf.
isnan / f_isnan
fn f_isnan(self) -> Result<Tensor>
fn isnan(self) -> Tensor
ClikaRT::ops::isnan: delegates to Api::f_op_isnan.
isneginf / f_isneginf
fn f_isneginf(self) -> Result<Tensor>
fn isneginf(self) -> Tensor
ClikaRT::ops::isneginf: delegates to Api::f_op_isneginf.
isposinf / f_isposinf
fn f_isposinf(self) -> Result<Tensor>
fn isposinf(self) -> Tensor
ClikaRT::ops::isposinf: delegates to Api::f_op_isposinf.
kl_div / f_kl_div
fn f_kl_div(self, target: Tensor, reduction: clika_rt_reduction, log_target: bool) -> Result<Tensor>
fn kl_div(self, target: Tensor, reduction: clika_rt_reduction, log_target: bool) -> Tensor
ClikaRT::ops::kl_div: delegates to Api::f_op_kl_div.
kron / f_kron
fn f_kron(self, other: Tensor) -> Result<Tensor>
fn kron(self, other: Tensor) -> Tensor
ClikaRT::ops::kron: delegates to Api::f_op_kron.
kthvalue / f_kthvalue
fn f_kthvalue(self, k: i64, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn kthvalue(self, k: i64, dim: i64, keepdim: bool) -> (Tensor, Tensor)
ClikaRT::ops::kthvalue: delegates to Api::f_op_kthvalue.
l1_loss / f_l1_loss
fn f_l1_loss(self, target: Tensor, reduction: clika_rt_reduction) -> Result<Tensor>
fn l1_loss(self, target: Tensor, reduction: clika_rt_reduction) -> Tensor
ClikaRT::ops::l1_loss: delegates to Api::f_op_l1_loss.
layer_norm / f_layer_norm
fn f_layer_norm(self, normalized_shape: &[i64], weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn layer_norm(self, normalized_shape: &[i64], weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::layer_norm: delegates to Api::f_op_layer_norm.
le / f_le
fn f_le(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn le(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::le: delegates to Api::f_op_le.
le_ / f_le_
fn f_le_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn le_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::le_: delegates to Api::f_op_le_inplace.
leaky_relu / f_leaky_relu
fn f_leaky_relu(self, negative_slope: f64) -> Result<Tensor>
fn leaky_relu(self, negative_slope: f64) -> Tensor
ClikaRT::ops::leaky_relu: delegates to Api::f_op_leaky_relu.
leaky_relu_ / f_leaky_relu_
fn f_leaky_relu_(self, negative_slope: f64) -> Result<&Self>
fn leaky_relu_(self, negative_slope: f64) -> &Self
ClikaRT::ops::leaky_relu_: delegates to Api::f_op_leaky_relu_inplace.
linear / f_linear
fn f_linear(self, weight: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, situ_beta: f64, situ_linear_beta: f64) -> Result<Tensor>
fn linear(self, weight: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, situ_beta: f64, situ_linear_beta: f64) -> Tensor
ClikaRT::ops::linear: delegates to Api::f_op_linear.
log / f_log
fn f_log(self) -> Result<Tensor>
fn log(self) -> Tensor
ClikaRT::ops::log: delegates to Api::f_op_log.
log10 / f_log10
fn f_log10(self) -> Result<Tensor>
fn log10(self) -> Tensor
ClikaRT::ops::log10: delegates to Api::f_op_log10.
log10_ / f_log10_
fn f_log10_(self) -> Result<&Self>
fn log10_(self) -> &Self
ClikaRT::ops::log10_: delegates to Api::f_op_log10_inplace.
log1p / f_log1p
fn f_log1p(self) -> Result<Tensor>
fn log1p(self) -> Tensor
ClikaRT::ops::log1p: delegates to Api::f_op_log1p.
log1p_ / f_log1p_
fn f_log1p_(self) -> Result<&Self>
fn log1p_(self) -> &Self
ClikaRT::ops::log1p_: delegates to Api::f_op_log1p_inplace.
log2 / f_log2
fn f_log2(self) -> Result<Tensor>
fn log2(self) -> Tensor
ClikaRT::ops::log2: delegates to Api::f_op_log2.
log2_ / f_log2_
fn f_log2_(self) -> Result<&Self>
fn log2_(self) -> &Self
ClikaRT::ops::log2_: delegates to Api::f_op_log2_inplace.
log_ / f_log_
fn f_log_(self) -> Result<&Self>
fn log_(self) -> &Self
ClikaRT::ops::log_: delegates to Api::f_op_log_inplace.
log_sigmoid / f_log_sigmoid
fn f_log_sigmoid(self) -> Result<Tensor>
fn log_sigmoid(self) -> Tensor
ClikaRT::ops::log_sigmoid: delegates to Api::f_op_log_sigmoid.
log_sigmoid_ / f_log_sigmoid_
fn f_log_sigmoid_(self) -> Result<&Self>
fn log_sigmoid_(self) -> &Self
ClikaRT::ops::log_sigmoid_: delegates to Api::f_op_log_sigmoid_inplace.
log_softmax / f_log_softmax
fn f_log_softmax(self, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn log_softmax(self, dim: i64, dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::log_softmax: delegates to Api::f_op_log_softmax.
log_softmax_ / f_log_softmax_
fn f_log_softmax_(self, dim: i64) -> Result<&Self>
fn log_softmax_(self, dim: i64) -> &Self
ClikaRT::ops::log_softmax_: delegates to Api::f_op_log_softmax_inplace.
logaddexp / f_logaddexp
fn f_logaddexp(self, other: Tensor) -> Result<Tensor>
fn logaddexp(self, other: Tensor) -> Tensor
ClikaRT::ops::logaddexp: delegates to Api::f_op_logaddexp.
logaddexp2 / f_logaddexp2
fn f_logaddexp2(self, other: Tensor) -> Result<Tensor>
fn logaddexp2(self, other: Tensor) -> Tensor
ClikaRT::ops::logaddexp2: delegates to Api::f_op_logaddexp2.
logical_and / f_logical_and
fn f_logical_and(self, other: Tensor) -> Result<Tensor>
fn logical_and(self, other: Tensor) -> Tensor
ClikaRT::ops::logical_and: delegates to Api::f_op_logical_and.
logical_and_ / f_logical_and_
fn f_logical_and_(self, other: Tensor) -> Result<&Self>
fn logical_and_(self, other: Tensor) -> &Self
ClikaRT::ops::logical_and_: delegates to Api::f_op_logical_and_inplace.
logical_not / f_logical_not
fn f_logical_not(self) -> Result<Tensor>
fn logical_not(self) -> Tensor
ClikaRT::ops::logical_not: delegates to Api::f_op_logical_not.
logical_not_ / f_logical_not_
fn f_logical_not_(self) -> Result<&Self>
fn logical_not_(self) -> &Self
ClikaRT::ops::logical_not_: delegates to Api::f_op_logical_not_inplace.
logical_or / f_logical_or
fn f_logical_or(self, other: Tensor) -> Result<Tensor>
fn logical_or(self, other: Tensor) -> Tensor
ClikaRT::ops::logical_or: delegates to Api::f_op_logical_or.
logical_or_ / f_logical_or_
fn f_logical_or_(self, other: Tensor) -> Result<&Self>
fn logical_or_(self, other: Tensor) -> &Self
ClikaRT::ops::logical_or_: delegates to Api::f_op_logical_or_inplace.
logical_xor / f_logical_xor
fn f_logical_xor(self, other: Tensor) -> Result<Tensor>
fn logical_xor(self, other: Tensor) -> Tensor
ClikaRT::ops::logical_xor: delegates to Api::f_op_logical_xor.
logical_xor_ / f_logical_xor_
fn f_logical_xor_(self, other: Tensor) -> Result<&Self>
fn logical_xor_(self, other: Tensor) -> &Self
ClikaRT::ops::logical_xor_: delegates to Api::f_op_logical_xor_inplace.
logit / f_logit
fn f_logit(self, eps_has: bool, eps: f64) -> Result<Tensor>
fn logit(self, eps_has: bool, eps: f64) -> Tensor
ClikaRT::ops::logit: delegates to Api::f_op_logit.
logit_ / f_logit_
fn f_logit_(self, eps_has: bool, eps: f64) -> Result<&Self>
fn logit_(self, eps_has: bool, eps: f64) -> &Self
ClikaRT::ops::logit_: delegates to Api::f_op_logit_inplace.
logsumexp / f_logsumexp
fn f_logsumexp(self, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn logsumexp(self, dims: &[i64], keepdim: bool) -> Tensor
ClikaRT::ops::logsumexp: delegates to Api::f_op_logsumexp.
lt / f_lt
fn f_lt(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn lt(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::lt: delegates to Api::f_op_lt.
lt_ / f_lt_
fn f_lt_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn lt_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::lt_: delegates to Api::f_op_lt_inplace.
masked_fill / f_masked_fill
fn f_masked_fill(self, mask: Tensor, value: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn masked_fill(self, mask: Tensor, value: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::masked_fill: delegates to Api::f_op_masked_fill.
masked_fill_ / f_masked_fill_
fn f_masked_fill_(self, mask: Tensor, value: clika_rt_scalar_or_tensor) -> Result<&Self>
fn masked_fill_(self, mask: Tensor, value: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::masked_fill_: delegates to Api::f_op_masked_fill_inplace.
masked_scatter / f_masked_scatter
fn f_masked_scatter(self, mask: Tensor, source: Tensor) -> Result<Tensor>
fn masked_scatter(self, mask: Tensor, source: Tensor) -> Tensor
ClikaRT::ops::masked_scatter: delegates to Api::f_op_masked_scatter.
masked_scatter_ / f_masked_scatter_
fn f_masked_scatter_(self, mask: Tensor, source: Tensor) -> Result<&Self>
fn masked_scatter_(self, mask: Tensor, source: Tensor) -> &Self
ClikaRT::ops::masked_scatter_: delegates to Api::f_op_masked_scatter_inplace.
masked_select / f_masked_select
fn f_masked_select(self, mask: Tensor) -> Result<Tensor>
fn masked_select(self, mask: Tensor) -> Tensor
ClikaRT::ops::masked_select: delegates to Api::f_op_masked_select.
matmul / f_matmul
fn f_matmul(self, other: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, situ_beta: f64, situ_linear_beta: f64) -> Result<Tensor>
fn matmul(self, other: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, situ_beta: f64, situ_linear_beta: f64) -> Tensor
ClikaRT::ops::matmul: delegates to Api::f_op_matmul.
max / f_max
fn f_max(self, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn max(self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
ClikaRT::ops::max: delegates to Api::f_op_max.
max_pool / f_max_pool
fn f_max_pool(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<Tensor>
fn max_pool(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Tensor
ClikaRT::ops::max_pool: delegates to Api::f_op_max_pool.
max_pool1d / f_max_pool1d
fn f_max_pool1d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<Tensor>
fn max_pool1d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Tensor
ClikaRT::ops::max_pool1d: delegates to Api::f_op_max_pool1d.
max_pool1d_with_indices / f_max_pool1d_with_indices
fn f_max_pool1d_with_indices(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<(Tensor, Tensor)>
fn max_pool1d_with_indices(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> (Tensor, Tensor)
ClikaRT::ops::max_pool1d_with_indices: delegates to Api::f_op_max_pool1d_with_indices.
max_pool2d / f_max_pool2d
fn f_max_pool2d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<Tensor>
fn max_pool2d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Tensor
ClikaRT::ops::max_pool2d: delegates to Api::f_op_max_pool2d.
max_pool2d_with_indices / f_max_pool2d_with_indices
fn f_max_pool2d_with_indices(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<(Tensor, Tensor)>
fn max_pool2d_with_indices(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> (Tensor, Tensor)
ClikaRT::ops::max_pool2d_with_indices: delegates to Api::f_op_max_pool2d_with_indices.
max_pool3d / f_max_pool3d
fn f_max_pool3d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<Tensor>
fn max_pool3d(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Tensor
ClikaRT::ops::max_pool3d: delegates to Api::f_op_max_pool3d.
max_pool3d_with_indices / f_max_pool3d_with_indices
fn f_max_pool3d_with_indices(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<(Tensor, Tensor)>
fn max_pool3d_with_indices(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> (Tensor, Tensor)
ClikaRT::ops::max_pool3d_with_indices: delegates to Api::f_op_max_pool3d_with_indices.
max_pool_with_indices / f_max_pool_with_indices
fn f_max_pool_with_indices(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<(Tensor, Tensor)>
fn max_pool_with_indices(self, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> (Tensor, Tensor)
ClikaRT::ops::max_pool_with_indices: delegates to Api::f_op_max_pool_with_indices.
maximum / f_maximum
fn f_maximum(self, other: Tensor) -> Result<Tensor>
fn maximum(self, other: Tensor) -> Tensor
ClikaRT::ops::maximum: delegates to Api::f_op_maximum.
maximum_ / f_maximum_
fn f_maximum_(self, other: Tensor) -> Result<&Self>
fn maximum_(self, other: Tensor) -> &Self
ClikaRT::ops::maximum_: delegates to Api::f_op_maximum_inplace.
mean / f_mean
fn f_mean(self, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Result<Tensor>
fn mean(self, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::mean: delegates to Api::f_op_mean.
median / f_median
fn f_median(self, dim_has: bool, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn median(self, dim_has: bool, dim: i64, keepdim: bool) -> (Tensor, Tensor)
ClikaRT::ops::median: delegates to Api::f_op_median.
min / f_min
fn f_min(self, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn min(self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
ClikaRT::ops::min: delegates to Api::f_op_min.
minimum / f_minimum
fn f_minimum(self, other: Tensor) -> Result<Tensor>
fn minimum(self, other: Tensor) -> Tensor
ClikaRT::ops::minimum: delegates to Api::f_op_minimum.
minimum_ / f_minimum_
fn f_minimum_(self, other: Tensor) -> Result<&Self>
fn minimum_(self, other: Tensor) -> &Self
ClikaRT::ops::minimum_: delegates to Api::f_op_minimum_inplace.
mish / f_mish
fn f_mish(self) -> Result<Tensor>
fn mish(self) -> Tensor
ClikaRT::ops::mish: delegates to Api::f_op_mish.
mish_ / f_mish_
fn f_mish_(self) -> Result<&Self>
fn mish_(self) -> &Self
ClikaRT::ops::mish_: delegates to Api::f_op_mish_inplace.
mm / f_mm
fn f_mm(self, other: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn mm(self, other: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::mm: delegates to Api::f_op_mm.
mod / f_mod
fn f_mod(self, other: clika_rt_scalar_or_tensor, mode: clika_rt_mod_mode) -> Result<Tensor>
fn mod(self, other: clika_rt_scalar_or_tensor, mode: clika_rt_mod_mode) -> Tensor
ClikaRT::ops::mod: delegates to Api::f_op_mod.
mod_ / f_mod_
fn f_mod_(self, other: clika_rt_scalar_or_tensor, mode: clika_rt_mod_mode) -> Result<&Self>
fn mod_(self, other: clika_rt_scalar_or_tensor, mode: clika_rt_mod_mode) -> &Self
ClikaRT::ops::mod_: delegates to Api::f_op_mod_inplace.
moe / f_moe
fn f_moe(self, router_logits: Tensor, fc1_experts: Tensor, fc2_experts: Tensor, top_k: i64, fc1_bias: Tensor, fc2_bias: Tensor, fc3_experts: Tensor, fc3_bias: Tensor, e_score_correction_bias: Tensor, router_weights: Tensor, shared_output: Tensor, options: &MoeOptions) -> Result<Tensor>
fn moe(self, router_logits: Tensor, fc1_experts: Tensor, fc2_experts: Tensor, top_k: i64, fc1_bias: Tensor, fc2_bias: Tensor, fc3_experts: Tensor, fc3_bias: Tensor, e_score_correction_bias: Tensor, router_weights: Tensor, shared_output: Tensor, options: &MoeOptions) -> Tensor
ClikaRT::ops::moe: delegates to Api::f_op_moe.
mrope_rotary_embedding / f_mrope_rotary_embedding
fn f_mrope_rotary_embedding(self, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingOptions) -> Result<Tensor>
fn mrope_rotary_embedding(self, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingOptions) -> Tensor
ClikaRT::ops::mrope_rotary_embedding: delegates to Api::f_op_mrope_rotary_embedding.
mrope_rotary_embedding_varlen / f_mrope_rotary_embedding_varlen
fn f_mrope_rotary_embedding_varlen(self, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingVarlenOptions) -> Result<Tensor>
fn mrope_rotary_embedding_varlen(self, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingVarlenOptions) -> Tensor
ClikaRT::ops::mrope_rotary_embedding_varlen: delegates to Api::f_op_mrope_rotary_embedding_varlen.
mse_loss / f_mse_loss
fn f_mse_loss(self, target: Tensor, reduction: clika_rt_reduction) -> Result<Tensor>
fn mse_loss(self, target: Tensor, reduction: clika_rt_reduction) -> Tensor
ClikaRT::ops::mse_loss: delegates to Api::f_op_mse_loss.
mul_ / f_mul_
fn f_mul_(self, other: clika_rt_scalar_or_tensor, activation: clika_rt_activation) -> Result<&Self>
fn mul_(self, other: clika_rt_scalar_or_tensor, activation: clika_rt_activation) -> &Self
ClikaRT::ops::mul_: delegates to Api::f_op_mul_inplace.
mul_tensor / f_mul_tensor
fn f_mul_tensor(self, other: clika_rt_scalar_or_tensor, activation: clika_rt_activation) -> Result<Tensor>
fn mul_tensor(self, other: clika_rt_scalar_or_tensor, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::mul: delegates to Api::f_op_mul_tensor.
mv / f_mv
fn f_mv(self, vec: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn mv(self, vec: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::mv: delegates to Api::f_op_mv.
nan_to_num / f_nan_to_num
fn f_nan_to_num(self, nan_has: bool, nan: f64, posinf_has: bool, posinf: f64, neginf_has: bool, neginf: f64) -> Result<Tensor>
fn nan_to_num(self, nan_has: bool, nan: f64, posinf_has: bool, posinf: f64, neginf_has: bool, neginf: f64) -> Tensor
ClikaRT::ops::nan_to_num: delegates to Api::f_op_nan_to_num.
nan_to_num_ / f_nan_to_num_
fn f_nan_to_num_(self, nan_has: bool, nan: f64, posinf_has: bool, posinf: f64, neginf_has: bool, neginf: f64) -> Result<&Self>
fn nan_to_num_(self, nan_has: bool, nan: f64, posinf_has: bool, posinf: f64, neginf_has: bool, neginf: f64) -> &Self
ClikaRT::ops::nan_to_num_: delegates to Api::f_op_nan_to_num_inplace.
nanmean / f_nanmean
fn f_nanmean(self, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn nanmean(self, dims: &[i64], keepdim: bool) -> Tensor
ClikaRT::ops::nanmean: delegates to Api::f_op_nanmean.
nanmedian / f_nanmedian
fn f_nanmedian(self, dim_has: bool, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn nanmedian(self, dim_has: bool, dim: i64, keepdim: bool) -> (Tensor, Tensor)
ClikaRT::ops::nanmedian: delegates to Api::f_op_nanmedian.
nanquantile / f_nanquantile
fn f_nanquantile(self, q: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, keepdim: bool, interpolation: clika_rt_quantile_interp) -> Result<Tensor>
fn nanquantile(self, q: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, keepdim: bool, interpolation: clika_rt_quantile_interp) -> Tensor
ClikaRT::ops::nanquantile: delegates to Api::f_op_nanquantile.
nansum / f_nansum
fn f_nansum(self, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn nansum(self, dims: &[i64], keepdim: bool) -> Tensor
ClikaRT::ops::nansum: delegates to Api::f_op_nansum.
narrow / f_narrow
fn f_narrow(self, dim: i64, start: clika_rt_index_bound, length: clika_rt_index_bound) -> Result<Tensor>
fn narrow(self, dim: i64, start: clika_rt_index_bound, length: clika_rt_index_bound) -> Tensor
ClikaRT::ops::narrow: delegates to Api::f_op_narrow.
ndim / f_ndim
fn f_ndim(self) -> Result<Tensor>
fn ndim(self) -> Tensor
ClikaRT::ops::ndim: delegates to Api::f_op_ndim.
ndim_host / f_ndim_host
fn f_ndim_host(self) -> Result<Tensor>
fn ndim_host(self) -> Tensor
ClikaRT::ops::ndim_host: delegates to Api::f_op_ndim_host.
ne / f_ne
fn f_ne(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn ne(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::ne: delegates to Api::f_op_ne.
ne_ / f_ne_
fn f_ne_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn ne_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::ne_: delegates to Api::f_op_ne_inplace.
neg / f_neg
fn f_neg(self) -> Result<Tensor>
fn neg(self) -> Tensor
ClikaRT::ops::neg: delegates to Api::f_op_neg.
neg_ / f_neg_
fn f_neg_(self) -> Result<&Self>
fn neg_(self) -> &Self
ClikaRT::ops::neg_: delegates to Api::f_op_neg_inplace.
nll_loss / f_nll_loss
fn f_nll_loss(self, target: Tensor, weight: Tensor, ignore_index_has: bool, ignore_index: i64, reduction: clika_rt_reduction) -> Result<Tensor>
fn nll_loss(self, target: Tensor, weight: Tensor, ignore_index_has: bool, ignore_index: i64, reduction: clika_rt_reduction) -> Tensor
ClikaRT::ops::nll_loss: delegates to Api::f_op_nll_loss.
nonzero / f_nonzero
fn f_nonzero(self) -> Result<Tensor>
fn nonzero(self) -> Tensor
ClikaRT::ops::nonzero: delegates to Api::f_op_nonzero.
norm / f_norm
fn f_norm(self, p: clika_rt_scalar, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn norm(self, p: clika_rt_scalar, dims: &[i64], keepdim: bool) -> Tensor
ClikaRT::ops::norm: delegates to Api::f_op_norm.
normal_ / f_normal_
fn f_normal_(self, mean: clika_rt_scalar_or_tensor, stddev: clika_rt_scalar_or_tensor, device: clika_rt_stream_or_device) -> Result<&Self>
fn normal_(self, mean: clika_rt_scalar_or_tensor, stddev: clika_rt_scalar_or_tensor, device: clika_rt_stream_or_device) -> &Self
ClikaRT::ops::normal_: delegates to Api::f_op_normal_inplace.
normalize / f_normalize
fn f_normalize(self, p: clika_rt_scalar, dim: i64, eps_has: bool, eps: f64) -> Result<Tensor>
fn normalize(self, p: clika_rt_scalar, dim: i64, eps_has: bool, eps: f64) -> Tensor
ClikaRT::ops::normalize: delegates to Api::f_op_normalize.
normalize_ / f_normalize_
fn f_normalize_(self, p: clika_rt_scalar, dim: i64, eps_has: bool, eps: f64) -> Result<&Self>
fn normalize_(self, p: clika_rt_scalar, dim: i64, eps_has: bool, eps: f64) -> &Self
ClikaRT::ops::normalize_: delegates to Api::f_op_normalize_inplace.
numel / f_numel
fn f_numel(self) -> Result<Tensor>
fn numel(self) -> Tensor
ClikaRT::ops::numel: delegates to Api::f_op_numel.
numel_host / f_numel_host
fn f_numel_host(self) -> Result<Tensor>
fn numel_host(self) -> Tensor
ClikaRT::ops::numel_host: delegates to Api::f_op_numel_host.
outer / f_outer
fn f_outer(self, other: Tensor) -> Result<Tensor>
fn outer(self, other: Tensor) -> Tensor
ClikaRT::ops::outer: delegates to Api::f_op_outer.
pad / f_pad
fn f_pad(self, pad: &[clika_rt_scalar_or_tensor], mode: clika_rt_pad_mode, value: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn pad(self, pad: &[clika_rt_scalar_or_tensor], mode: clika_rt_pad_mode, value: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::pad: delegates to Api::f_op_pad.
pdist / f_pdist
fn f_pdist(self, p: clika_rt_scalar) -> Result<Tensor>
fn pdist(self, p: clika_rt_scalar) -> Tensor
ClikaRT::ops::pdist: delegates to Api::f_op_pdist.
permute / f_permute
fn f_permute(self, dims: &[i64]) -> Result<Tensor>
fn permute(self, dims: &[i64]) -> Tensor
ClikaRT::ops::permute: delegates to Api::f_op_permute.
pixel_shuffle / f_pixel_shuffle
fn f_pixel_shuffle(self, upscale_factor: i64, mode: clika_rt_pixel_shuffle_mode) -> Result<Tensor>
fn pixel_shuffle(self, upscale_factor: i64, mode: clika_rt_pixel_shuffle_mode) -> Tensor
ClikaRT::ops::pixel_shuffle: delegates to Api::f_op_pixel_shuffle.
pixel_unshuffle / f_pixel_unshuffle
fn f_pixel_unshuffle(self, downscale_factor: i64, mode: clika_rt_pixel_shuffle_mode) -> Result<Tensor>
fn pixel_unshuffle(self, downscale_factor: i64, mode: clika_rt_pixel_shuffle_mode) -> Tensor
ClikaRT::ops::pixel_unshuffle: delegates to Api::f_op_pixel_unshuffle.
pow / f_pow
fn f_pow(self, exponent: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn pow(self, exponent: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::pow: delegates to Api::f_op_pow.
pow_ / f_pow_
fn f_pow_(self, exponent: clika_rt_scalar_or_tensor) -> Result<&Self>
fn pow_(self, exponent: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::pow_: delegates to Api::f_op_pow_inplace.
prelu / f_prelu
fn f_prelu(self, weight: Tensor) -> Result<Tensor>
fn prelu(self, weight: Tensor) -> Tensor
ClikaRT::ops::prelu: delegates to Api::f_op_prelu.
prelu_ / f_prelu_
fn f_prelu_(self, weight: Tensor) -> Result<&Self>
fn prelu_(self, weight: Tensor) -> &Self
ClikaRT::ops::prelu_: delegates to Api::f_op_prelu_inplace.
prod / f_prod
fn f_prod(self, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Result<Tensor>
fn prod(self, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::prod: delegates to Api::f_op_prod.
put / f_put
fn f_put(self, index: Tensor, source: Tensor, accumulate: bool) -> Result<Tensor>
fn put(self, index: Tensor, source: Tensor, accumulate: bool) -> Tensor
ClikaRT::ops::put: delegates to Api::f_op_put.
put_ / f_put_
fn f_put_(self, index: Tensor, source: Tensor, accumulate: bool) -> Result<&Self>
fn put_(self, index: Tensor, source: Tensor, accumulate: bool) -> &Self
ClikaRT::ops::put_: delegates to Api::f_op_put_inplace.
qconv1d_woq / f_qconv1d_woq
fn f_qconv1d_woq(self, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn qconv1d_woq(self, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::qconv1d_woq: delegates to Api::f_op_qconv1d_woq.
qconv2d_woq / f_qconv2d_woq
fn f_qconv2d_woq(self, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn qconv2d_woq(self, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::qconv2d_woq: delegates to Api::f_op_qconv2d_woq.
qconv3d_woq / f_qconv3d_woq
fn f_qconv3d_woq(self, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn qconv3d_woq(self, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::qconv3d_woq: delegates to Api::f_op_qconv3d_woq.
qconv_transpose1d_woq / f_qconv_transpose1d_woq
fn f_qconv_transpose1d_woq(self, weight: QTensor, bias: Tensor, options: &QconvTranspose1dWoqOptions) -> Result<Tensor>
fn qconv_transpose1d_woq(self, weight: QTensor, bias: Tensor, options: &QconvTranspose1dWoqOptions) -> Tensor
ClikaRT::ops::qconv_transpose1d_woq: delegates to Api::f_op_qconv_transpose1d_woq.
qconv_transpose2d_woq / f_qconv_transpose2d_woq
fn f_qconv_transpose2d_woq(self, weight: QTensor, bias: Tensor, options: &QconvTranspose2dWoqOptions) -> Result<Tensor>
fn qconv_transpose2d_woq(self, weight: QTensor, bias: Tensor, options: &QconvTranspose2dWoqOptions) -> Tensor
ClikaRT::ops::qconv_transpose2d_woq: delegates to Api::f_op_qconv_transpose2d_woq.
qconv_transpose3d_woq / f_qconv_transpose3d_woq
fn f_qconv_transpose3d_woq(self, weight: QTensor, bias: Tensor, options: &QconvTranspose3dWoqOptions) -> Result<Tensor>
fn qconv_transpose3d_woq(self, weight: QTensor, bias: Tensor, options: &QconvTranspose3dWoqOptions) -> Tensor
ClikaRT::ops::qconv_transpose3d_woq: delegates to Api::f_op_qconv_transpose3d_woq.
qconv_transpose_woq / f_qconv_transpose_woq
fn f_qconv_transpose_woq(self, weight: QTensor, bias: Tensor, compute_mode: clika_rt_qcompute_mode, options: &QconvTransposeWoqOptions) -> Result<Tensor>
fn qconv_transpose_woq(self, weight: QTensor, bias: Tensor, compute_mode: clika_rt_qcompute_mode, options: &QconvTransposeWoqOptions) -> Tensor
ClikaRT::ops::qconv_transpose_woq: delegates to Api::f_op_qconv_transpose_woq.
qconv_woq / f_qconv_woq
fn f_qconv_woq(self, weight: QTensor, bias: Tensor, compute_mode: clika_rt_qcompute_mode, options: &QconvWoqOptions) -> Result<Tensor>
fn qconv_woq(self, weight: QTensor, bias: Tensor, compute_mode: clika_rt_qcompute_mode, options: &QconvWoqOptions) -> Tensor
ClikaRT::ops::qconv_woq: delegates to Api::f_op_qconv_woq.
qdeform_conv_woq / f_qdeform_conv_woq
fn f_qdeform_conv_woq(self, weight: QTensor, offset: Tensor, mask: Tensor, bias: Tensor, compute_mode: clika_rt_qcompute_mode, options: &QdeformConvWoqOptions) -> Result<Tensor>
fn qdeform_conv_woq(self, weight: QTensor, offset: Tensor, mask: Tensor, bias: Tensor, compute_mode: clika_rt_qcompute_mode, options: &QdeformConvWoqOptions) -> Tensor
ClikaRT::ops::qdeform_conv_woq: delegates to Api::f_op_qdeform_conv_woq.
qlinear_woq / f_qlinear_woq
fn f_qlinear_woq(self, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, compute_mode: clika_rt_qcompute_mode) -> Result<Tensor>
fn qlinear_woq(self, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, compute_mode: clika_rt_qcompute_mode) -> Tensor
ClikaRT::ops::qlinear_woq: delegates to Api::f_op_qlinear_woq.
qlinear_woq_ / f_qlinear_woq_
fn f_qlinear_woq_(self, weight: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, compute_mode: clika_rt_qcompute_mode) -> Result<()>
fn qlinear_woq_(self, weight: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, compute_mode: clika_rt_qcompute_mode)
ClikaRT::ops::qlinear_woq_: delegates to Api::f_op_qlinear_woq_inplace.
qmatmul_woq / f_qmatmul_woq
fn f_qmatmul_woq(self, other: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, compute_mode: clika_rt_qcompute_mode) -> Result<Tensor>
fn qmatmul_woq(self, other: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, compute_mode: clika_rt_qcompute_mode) -> Tensor
ClikaRT::ops::qmatmul_woq: delegates to Api::f_op_qmatmul_woq.
qmatmul_woq_ / f_qmatmul_woq_
fn f_qmatmul_woq_(self, other: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, compute_mode: clika_rt_qcompute_mode) -> Result<()>
fn qmatmul_woq_(self, other: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, compute_mode: clika_rt_qcompute_mode)
ClikaRT::ops::qmatmul_woq_: delegates to Api::f_op_qmatmul_woq_inplace.
qmoe_woq / f_qmoe_woq
fn f_qmoe_woq(self, router_logits: Tensor, fc1_experts: QTensor, fc2_experts: QTensor, top_k: i64, fc1_bias: Tensor, fc2_bias: Tensor, fc3_experts: QTensor, fc3_bias: Tensor, e_score_correction_bias: Tensor, router_weights: Tensor, shared_output: Tensor, options: &QmoeWoqOptions) -> Result<Tensor>
fn qmoe_woq(self, router_logits: Tensor, fc1_experts: QTensor, fc2_experts: QTensor, top_k: i64, fc1_bias: Tensor, fc2_bias: Tensor, fc3_experts: QTensor, fc3_bias: Tensor, e_score_correction_bias: Tensor, router_weights: Tensor, shared_output: Tensor, options: &QmoeWoqOptions) -> Tensor
ClikaRT::ops::qmoe_woq: delegates to Api::f_op_qmoe_woq.
quantile / f_quantile
fn f_quantile(self, q: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, keepdim: bool, interpolation: clika_rt_quantile_interp) -> Result<Tensor>
fn quantile(self, q: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, keepdim: bool, interpolation: clika_rt_quantile_interp) -> Tensor
ClikaRT::ops::quantile: delegates to Api::f_op_quantile.
quantize / f_quantize
fn f_quantize(self, scale: Tensor, zero_point: Tensor, quant_axis: i64, out_dtype: clika_rt_data_type, block_size: i64) -> Result<QTensor>
fn quantize(self, scale: Tensor, zero_point: Tensor, quant_axis: i64, out_dtype: clika_rt_data_type, block_size: i64) -> QTensor
ClikaRT::ops::quantize: delegates to Api::f_op_quantize.
quantize_dequantize / f_quantize_dequantize
fn f_quantize_dequantize(self, scale: Tensor, zero_point: Tensor, quant_axis: i64, code_dtype: clika_rt_data_type, out_dtype: clika_rt_data_type, block_size: i64) -> Result<Tensor>
fn quantize_dequantize(self, scale: Tensor, zero_point: Tensor, quant_axis: i64, code_dtype: clika_rt_data_type, out_dtype: clika_rt_data_type, block_size: i64) -> Tensor
ClikaRT::ops::quantize_dequantize: delegates to Api::f_op_quantize_dequantize.
quantize_inplace_to_dense / f_quantize_inplace_to_dense
fn f_quantize_inplace_to_dense(self, out: &Tensor, scale: Tensor, zero_point: Tensor, quant_axis: i64, block_size: i64) -> Result<()>
fn quantize_inplace_to_dense(self, out: &Tensor, scale: Tensor, zero_point: Tensor, quant_axis: i64, block_size: i64)
ClikaRT::ops::quantize_: delegates to Api::f_op_quantize_inplace_to_dense.
quantize_inplace_to_quantized / f_quantize_inplace_to_quantized
fn f_quantize_inplace_to_quantized(self, out: &QTensor) -> Result<()>
fn quantize_inplace_to_quantized(self, out: &QTensor)
ClikaRT::ops::quantize_: delegates to Api::f_op_quantize_inplace_to_quantized.
quantize_to_scheme / f_quantize_to_scheme
fn f_quantize_to_scheme(self, scheme: &str, scale: Tensor) -> Result<QTensor>
fn quantize_to_scheme(self, scheme: &str, scale: Tensor) -> QTensor
ClikaRT::ops::quantize_to_scheme: delegates to Api::f_op_quantize_to_scheme.
quick_gelu / f_quick_gelu
fn f_quick_gelu(self) -> Result<Tensor>
fn quick_gelu(self) -> Tensor
ClikaRT::ops::quick_gelu: delegates to Api::f_op_quick_gelu.
rad2deg / f_rad2deg
fn f_rad2deg(self) -> Result<Tensor>
fn rad2deg(self) -> Tensor
ClikaRT::ops::rad2deg: delegates to Api::f_op_rad2deg.
rad2deg_ / f_rad2deg_
fn f_rad2deg_(self) -> Result<&Self>
fn rad2deg_(self) -> &Self
ClikaRT::ops::rad2deg_: delegates to Api::f_op_rad2deg_inplace.
random_ / f_random_
fn f_random_(self, low_has: bool, low: i64, high_has: bool, high: i64, device: clika_rt_stream_or_device) -> Result<&Self>
fn random_(self, low_has: bool, low: i64, high_has: bool, high: i64, device: clika_rt_stream_or_device) -> &Self
ClikaRT::ops::random_: delegates to Api::f_op_random_inplace.
reciprocal / f_reciprocal
fn f_reciprocal(self) -> Result<Tensor>
fn reciprocal(self) -> Tensor
ClikaRT::ops::reciprocal: delegates to Api::f_op_reciprocal.
reciprocal_ / f_reciprocal_
fn f_reciprocal_(self) -> Result<&Self>
fn reciprocal_(self) -> &Self
ClikaRT::ops::reciprocal_: delegates to Api::f_op_reciprocal_inplace.
reflect_pad / f_reflect_pad
fn f_reflect_pad(self, pad: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn reflect_pad(self, pad: &[clika_rt_scalar_or_tensor]) -> Tensor
ClikaRT::ops::reflect_pad: delegates to Api::f_op_reflect_pad.
reglu / f_reglu
fn f_reglu(self) -> Result<Tensor>
fn reglu(self) -> Tensor
ClikaRT::ops::reglu: delegates to Api::f_op_reglu.
relu / f_relu
fn f_relu(self) -> Result<Tensor>
fn relu(self) -> Tensor
ClikaRT::ops::relu: delegates to Api::f_op_relu.
relu6 / f_relu6
fn f_relu6(self) -> Result<Tensor>
fn relu6(self) -> Tensor
ClikaRT::ops::relu6: delegates to Api::f_op_relu6.
relu6_ / f_relu6_
fn f_relu6_(self) -> Result<&Self>
fn relu6_(self) -> &Self
ClikaRT::ops::relu6_: delegates to Api::f_op_relu6_inplace.
relu_ / f_relu_
fn f_relu_(self) -> Result<&Self>
fn relu_(self) -> &Self
ClikaRT::ops::relu_: delegates to Api::f_op_relu_inplace.
remainder / f_remainder
fn f_remainder(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn remainder(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::remainder: delegates to Api::f_op_remainder.
remainder_ / f_remainder_
fn f_remainder_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn remainder_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::remainder_: delegates to Api::f_op_remainder_inplace.
renorm / f_renorm
fn f_renorm(self, p: clika_rt_scalar, dim: i64, maxnorm: clika_rt_scalar, eps_has: bool, eps: f64) -> Result<Tensor>
fn renorm(self, p: clika_rt_scalar, dim: i64, maxnorm: clika_rt_scalar, eps_has: bool, eps: f64) -> Tensor
ClikaRT::ops::renorm: delegates to Api::f_op_renorm.
renorm_ / f_renorm_
fn f_renorm_(self, p: clika_rt_scalar, dim: i64, maxnorm: clika_rt_scalar, eps_has: bool, eps: f64) -> Result<&Self>
fn renorm_(self, p: clika_rt_scalar, dim: i64, maxnorm: clika_rt_scalar, eps_has: bool, eps: f64) -> &Self
ClikaRT::ops::renorm_: delegates to Api::f_op_renorm_inplace.
repeat / f_repeat
fn f_repeat(self, sizes: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn repeat(self, sizes: &[clika_rt_scalar_or_tensor]) -> Tensor
ClikaRT::ops::repeat: delegates to Api::f_op_repeat.
repeat_interleave / f_repeat_interleave
fn f_repeat_interleave(self, repeats: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, output_size_has: bool, output_size: i64) -> Result<Tensor>
fn repeat_interleave(self, repeats: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, output_size_has: bool, output_size: i64) -> Tensor
ClikaRT::ops::repeat_interleave: delegates to Api::f_op_repeat_interleave.
replicate_pad / f_replicate_pad
fn f_replicate_pad(self, pad: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn replicate_pad(self, pad: &[clika_rt_scalar_or_tensor]) -> Tensor
ClikaRT::ops::replicate_pad: delegates to Api::f_op_replicate_pad.
resample / f_resample
fn f_resample(self, orig_freq: i64, new_freq: i64, lowpass_filter_width: i64, rolloff: f64, beta_has: bool, beta: f64) -> Result<Tensor>
fn resample(self, orig_freq: i64, new_freq: i64, lowpass_filter_width: i64, rolloff: f64, beta_has: bool, beta: f64) -> Tensor
ClikaRT::ops::resample: delegates to Api::f_op_resample.
reshape / f_reshape
fn f_reshape(self, shape: &[clika_rt_index_bound]) -> Result<Tensor>
fn reshape(self, shape: &[clika_rt_index_bound]) -> Tensor
ClikaRT::ops::reshape: delegates to Api::f_op_reshape.
reshape_as / f_reshape_as
fn f_reshape_as(self, other: Tensor) -> Result<Tensor>
fn reshape_as(self, other: Tensor) -> Tensor
ClikaRT::ops::reshape_as: delegates to Api::f_op_reshape_as.
rfft / f_rfft
fn f_rfft(self, n_fft_has: bool, n_fft: i64, normalized: bool) -> Result<Tensor>
fn rfft(self, n_fft_has: bool, n_fft: i64, normalized: bool) -> Tensor
ClikaRT::ops::rfft: delegates to Api::f_op_rfft.
rms_norm / f_rms_norm
fn f_rms_norm(self, normalized_shape: &[i64], weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn rms_norm(self, normalized_shape: &[i64], weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::rms_norm: delegates to Api::f_op_rms_norm.
roll / f_roll
fn f_roll(self, shifts: &[i64], dims: &[i64]) -> Result<Tensor>
fn roll(self, shifts: &[i64], dims: &[i64]) -> Tensor
ClikaRT::ops::roll: delegates to Api::f_op_roll.
rot90 / f_rot90
fn f_rot90(self, k: i64, dims: &[i64]) -> Result<Tensor>
fn rot90(self, k: i64, dims: &[i64]) -> Tensor
ClikaRT::ops::rot90: delegates to Api::f_op_rot90.
rotary_embedding / f_rotary_embedding
fn f_rotary_embedding(self, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingOptions) -> Result<Tensor>
fn rotary_embedding(self, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingOptions) -> Tensor
ClikaRT::ops::rotary_embedding: delegates to Api::f_op_rotary_embedding.
rotary_embedding_varlen / f_rotary_embedding_varlen
fn f_rotary_embedding_varlen(self, cu_seqlens: Tensor, seqlens: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingVarlenOptions) -> Result<Tensor>
fn rotary_embedding_varlen(self, cu_seqlens: Tensor, seqlens: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingVarlenOptions) -> Tensor
ClikaRT::ops::rotary_embedding_varlen: delegates to Api::f_op_rotary_embedding_varlen.
round / f_round
fn f_round(self, decimals: i64) -> Result<Tensor>
fn round(self, decimals: i64) -> Tensor
ClikaRT::ops::round: delegates to Api::f_op_round.
round_ / f_round_
fn f_round_(self, decimals: i64) -> Result<&Self>
fn round_(self, decimals: i64) -> &Self
ClikaRT::ops::round_: delegates to Api::f_op_round_inplace.
rsqrt / f_rsqrt
fn f_rsqrt(self) -> Result<Tensor>
fn rsqrt(self) -> Tensor
ClikaRT::ops::rsqrt: delegates to Api::f_op_rsqrt.
rsqrt_ / f_rsqrt_
fn f_rsqrt_(self) -> Result<&Self>
fn rsqrt_(self) -> &Self
ClikaRT::ops::rsqrt_: delegates to Api::f_op_rsqrt_inplace.
scatter / f_scatter
fn f_scatter(self, dim: i64, index: Tensor, src: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn scatter(self, dim: i64, index: Tensor, src: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::scatter: delegates to Api::f_op_scatter.
scatter_ / f_scatter_
fn f_scatter_(self, dim: i64, index: Tensor, src: clika_rt_scalar_or_tensor) -> Result<&Self>
fn scatter_(self, dim: i64, index: Tensor, src: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::scatter_: delegates to Api::f_op_scatter_inplace.
scatter_add / f_scatter_add
fn f_scatter_add(self, dim: i64, index: Tensor, src: Tensor, deterministic: bool) -> Result<Tensor>
fn scatter_add(self, dim: i64, index: Tensor, src: Tensor, deterministic: bool) -> Tensor
ClikaRT::ops::scatter_add: delegates to Api::f_op_scatter_add.
scatter_add_ / f_scatter_add_
fn f_scatter_add_(self, dim: i64, index: Tensor, src: Tensor, deterministic: bool) -> Result<&Self>
fn scatter_add_(self, dim: i64, index: Tensor, src: Tensor, deterministic: bool) -> &Self
ClikaRT::ops::scatter_add_: delegates to Api::f_op_scatter_add_inplace.
scatter_reduce / f_scatter_reduce
fn f_scatter_reduce(self, dim: i64, index: Tensor, src: Tensor, reduce: clika_rt_scatter_reduce_mode, include_self: bool, deterministic: bool) -> Result<Tensor>
fn scatter_reduce(self, dim: i64, index: Tensor, src: Tensor, reduce: clika_rt_scatter_reduce_mode, include_self: bool, deterministic: bool) -> Tensor
ClikaRT::ops::scatter_reduce: delegates to Api::f_op_scatter_reduce.
scatter_reduce_ / f_scatter_reduce_
fn f_scatter_reduce_(self, dim: i64, index: Tensor, src: Tensor, reduce: clika_rt_scatter_reduce_mode, include_self: bool, deterministic: bool) -> Result<&Self>
fn scatter_reduce_(self, dim: i64, index: Tensor, src: Tensor, reduce: clika_rt_scatter_reduce_mode, include_self: bool, deterministic: bool) -> &Self
ClikaRT::ops::scatter_reduce_: delegates to Api::f_op_scatter_reduce_inplace.
select / f_select
fn f_select(self, dim: i64, index: clika_rt_index_bound) -> Result<Tensor>
fn select(self, dim: i64, index: clika_rt_index_bound) -> Tensor
ClikaRT::ops::select: delegates to Api::f_op_select.
selu / f_selu
fn f_selu(self) -> Result<Tensor>
fn selu(self) -> Tensor
ClikaRT::ops::selu: delegates to Api::f_op_selu.
selu_ / f_selu_
fn f_selu_(self) -> Result<&Self>
fn selu_(self) -> &Self
ClikaRT::ops::selu_: delegates to Api::f_op_selu_inplace.
sgn / f_sgn
fn f_sgn(self) -> Result<Tensor>
fn sgn(self) -> Tensor
ClikaRT::ops::sgn: delegates to Api::f_op_sgn.
sgn_ / f_sgn_
fn f_sgn_(self) -> Result<&Self>
fn sgn_(self) -> &Self
ClikaRT::ops::sgn_: delegates to Api::f_op_sgn_inplace.
shallow_clone
fn shallow_clone(self) -> Tensor
A second handle to the SAME storage (no data copy): the underlying
tensor lives until the last handle drops. This is the deliberate
handle-copy spelling; Tensor implements no Clone, so a copy is
always visible at the call site.
shape_dim / f_shape_dim
fn f_shape_dim(self, dim_has: bool, dim: i64) -> Result<Tensor>
fn shape_dim(self, dim_has: bool, dim: i64) -> Tensor
ClikaRT::ops::shape: delegates to Api::f_op_shape_dim.
shape_host_all / f_shape_host_all
fn f_shape_host_all(self) -> Result<Tensor>
fn shape_host_all(self) -> Tensor
ClikaRT::ops::shape_host: delegates to Api::f_op_shape_host_all.
shape_host_dim / f_shape_host_dim
fn f_shape_host_dim(self, dim: i64) -> Result<Tensor>
fn shape_host_dim(self, dim: i64) -> Tensor
ClikaRT::ops::shape_host: delegates to Api::f_op_shape_host_dim.
shape_host_range / f_shape_host_range
fn f_shape_host_range(self, start_has: bool, start: i64, end_has: bool, end: i64) -> Result<Tensor>
fn shape_host_range(self, start_has: bool, start: i64, end_has: bool, end: i64) -> Tensor
ClikaRT::ops::shape_host: delegates to Api::f_op_shape_host_range.
shape_range / f_shape_range
fn f_shape_range(self, start_has: bool, start: i64, end_has: bool, end: i64) -> Result<Tensor>
fn shape_range(self, start_has: bool, start: i64, end_has: bool, end: i64) -> Tensor
ClikaRT::ops::shape: delegates to Api::f_op_shape_range.
sigmoid / f_sigmoid
fn f_sigmoid(self) -> Result<Tensor>
fn sigmoid(self) -> Tensor
ClikaRT::ops::sigmoid: delegates to Api::f_op_sigmoid.
sigmoid_ / f_sigmoid_
fn f_sigmoid_(self) -> Result<&Self>
fn sigmoid_(self) -> &Self
ClikaRT::ops::sigmoid_: delegates to Api::f_op_sigmoid_inplace.
sign / f_sign
fn f_sign(self) -> Result<Tensor>
fn sign(self) -> Tensor
ClikaRT::ops::sign: delegates to Api::f_op_sign.
sign_ / f_sign_
fn f_sign_(self) -> Result<&Self>
fn sign_(self) -> &Self
ClikaRT::ops::sign_: delegates to Api::f_op_sign_inplace.
silu / f_silu
fn f_silu(self) -> Result<Tensor>
fn silu(self) -> Tensor
ClikaRT::ops::silu: delegates to Api::f_op_silu.
silu_ / f_silu_
fn f_silu_(self) -> Result<&Self>
fn silu_(self) -> &Self
ClikaRT::ops::silu_: delegates to Api::f_op_silu_inplace.
sin / f_sin
fn f_sin(self) -> Result<Tensor>
fn sin(self) -> Tensor
ClikaRT::ops::sin: delegates to Api::f_op_sin.
sin_ / f_sin_
fn f_sin_(self) -> Result<&Self>
fn sin_(self) -> &Self
ClikaRT::ops::sin_: delegates to Api::f_op_sin_inplace.
sinc / f_sinc
fn f_sinc(self) -> Result<Tensor>
fn sinc(self) -> Tensor
ClikaRT::ops::sinc: delegates to Api::f_op_sinc.
sinc_ / f_sinc_
fn f_sinc_(self) -> Result<&Self>
fn sinc_(self) -> &Self
ClikaRT::ops::sinc_: delegates to Api::f_op_sinc_inplace.
sinh / f_sinh
fn f_sinh(self) -> Result<Tensor>
fn sinh(self) -> Tensor
ClikaRT::ops::sinh: delegates to Api::f_op_sinh.
sinh_ / f_sinh_
fn f_sinh_(self) -> Result<&Self>
fn sinh_(self) -> &Self
ClikaRT::ops::sinh_: delegates to Api::f_op_sinh_inplace.
slice_dim / f_slice_dim
fn f_slice_dim(self, dim: i64, start: clika_rt_index_bound, end: clika_rt_index_bound, step: clika_rt_index_bound) -> Result<Tensor>
fn slice_dim(self, dim: i64, start: clika_rt_index_bound, end: clika_rt_index_bound, step: clika_rt_index_bound) -> Tensor
ClikaRT::ops::slice: delegates to Api::f_op_slice_dim.
slice_dims / f_slice_dims
fn f_slice_dims(self, dim: &[i64], start: &[clika_rt_index_bound], end: &[clika_rt_index_bound], step: &[clika_rt_index_bound]) -> Result<Tensor>
fn slice_dims(self, dim: &[i64], start: &[clika_rt_index_bound], end: &[clika_rt_index_bound], step: &[clika_rt_index_bound]) -> Tensor
ClikaRT::ops::slice: delegates to Api::f_op_slice_dims.
smooth_l1_loss / f_smooth_l1_loss
fn f_smooth_l1_loss(self, target: Tensor, reduction: clika_rt_reduction, beta: f64) -> Result<Tensor>
fn smooth_l1_loss(self, target: Tensor, reduction: clika_rt_reduction, beta: f64) -> Tensor
ClikaRT::ops::smooth_l1_loss: delegates to Api::f_op_smooth_l1_loss.
snake / f_snake
fn f_snake(self, alpha: Tensor, beta: Tensor, eps: f64) -> Result<Tensor>
fn snake(self, alpha: Tensor, beta: Tensor, eps: f64) -> Tensor
ClikaRT::ops::snake: delegates to Api::f_op_snake.
snake_ / f_snake_
fn f_snake_(self, alpha: Tensor, beta: Tensor, eps: f64) -> Result<&Self>
fn snake_(self, alpha: Tensor, beta: Tensor, eps: f64) -> &Self
ClikaRT::ops::snake_: delegates to Api::f_op_snake_inplace.
softcap_logits / f_softcap_logits
fn f_softcap_logits(self, cap: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn softcap_logits(self, cap: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::softcap_logits: delegates to Api::f_op_softcap_logits.
softcap_logits_ / f_softcap_logits_
fn f_softcap_logits_(self, cap: clika_rt_scalar_or_tensor) -> Result<&Self>
fn softcap_logits_(self, cap: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::softcap_logits_: delegates to Api::f_op_softcap_logits_inplace.
softmax / f_softmax
fn f_softmax(self, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn softmax(self, dim: i64, dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::softmax: delegates to Api::f_op_softmax.
softmax_ / f_softmax_
fn f_softmax_(self, dim: i64) -> Result<&Self>
fn softmax_(self, dim: i64) -> &Self
ClikaRT::ops::softmax_: delegates to Api::f_op_softmax_inplace.
softmin / f_softmin
fn f_softmin(self, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn softmin(self, dim: i64, dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::softmin: delegates to Api::f_op_softmin.
softmin_ / f_softmin_
fn f_softmin_(self, dim: i64) -> Result<&Self>
fn softmin_(self, dim: i64) -> &Self
ClikaRT::ops::softmin_: delegates to Api::f_op_softmin_inplace.
softplus / f_softplus
fn f_softplus(self, beta: f64, threshold: f64) -> Result<Tensor>
fn softplus(self, beta: f64, threshold: f64) -> Tensor
ClikaRT::ops::softplus: delegates to Api::f_op_softplus.
softplus_ / f_softplus_
fn f_softplus_(self, beta: f64, threshold: f64) -> Result<&Self>
fn softplus_(self, beta: f64, threshold: f64) -> &Self
ClikaRT::ops::softplus_: delegates to Api::f_op_softplus_inplace.
softshrink / f_softshrink
fn f_softshrink(self, lambd: f64) -> Result<Tensor>
fn softshrink(self, lambd: f64) -> Tensor
ClikaRT::ops::softshrink: delegates to Api::f_op_softshrink.
softshrink_ / f_softshrink_
fn f_softshrink_(self, lambd: f64) -> Result<&Self>
fn softshrink_(self, lambd: f64) -> &Self
ClikaRT::ops::softshrink_: delegates to Api::f_op_softshrink_inplace.
softsign / f_softsign
fn f_softsign(self) -> Result<Tensor>
fn softsign(self) -> Tensor
ClikaRT::ops::softsign: delegates to Api::f_op_softsign.
softsign_ / f_softsign_
fn f_softsign_(self) -> Result<&Self>
fn softsign_(self) -> &Self
ClikaRT::ops::softsign_: delegates to Api::f_op_softsign_inplace.
sort / f_sort
fn f_sort(self, dim: i64, descending: bool, stable: bool) -> Result<(Tensor, Tensor)>
fn sort(self, dim: i64, descending: bool, stable: bool) -> (Tensor, Tensor)
ClikaRT::ops::sort: delegates to Api::f_op_sort.
split_by_size / f_split_by_size
fn f_split_by_size(self, chunk_size: i64, dim: i64) -> Result<TensorList>
fn split_by_size(self, chunk_size: i64, dim: i64) -> TensorList
ClikaRT::ops::split_by_size: delegates to Api::f_op_split_by_size.
split_with_sizes / f_split_with_sizes
fn f_split_with_sizes(self, sizes: &[clika_rt_scalar_or_tensor], dim: i64) -> Result<TensorList>
fn split_with_sizes(self, sizes: &[clika_rt_scalar_or_tensor], dim: i64) -> TensorList
ClikaRT::ops::split_with_sizes: delegates to Api::f_op_split_with_sizes.
sqrt / f_sqrt
fn f_sqrt(self) -> Result<Tensor>
fn sqrt(self) -> Tensor
ClikaRT::ops::sqrt: delegates to Api::f_op_sqrt.
sqrt_ / f_sqrt_
fn f_sqrt_(self) -> Result<&Self>
fn sqrt_(self) -> &Self
ClikaRT::ops::sqrt_: delegates to Api::f_op_sqrt_inplace.
square / f_square
fn f_square(self) -> Result<Tensor>
fn square(self) -> Tensor
ClikaRT::ops::square: delegates to Api::f_op_square.
square_ / f_square_
fn f_square_(self) -> Result<&Self>
fn square_(self) -> &Self
ClikaRT::ops::square_: delegates to Api::f_op_square_inplace.
squeeze / f_squeeze
fn f_squeeze(self, dim: &[i64]) -> Result<Tensor>
fn squeeze(self, dim: &[i64]) -> Tensor
ClikaRT::ops::squeeze: delegates to Api::f_op_squeeze.
squeeze_ / f_squeeze_
fn f_squeeze_(self, dim: &[i64]) -> Result<&Self>
fn squeeze_(self, dim: &[i64]) -> &Self
ClikaRT::ops::squeeze_: delegates to Api::f_op_squeeze_inplace.
ssd_update / f_ssd_update
fn f_ssd_update(self, dt: Tensor, a_rate: Tensor, b_mat: Tensor, c_mat: Tensor, d_skip: Tensor, dt_bias: Tensor, gate: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, dt_softplus: bool) -> Result<Tensor>
fn ssd_update(self, dt: Tensor, a_rate: Tensor, b_mat: Tensor, c_mat: Tensor, d_skip: Tensor, dt_bias: Tensor, gate: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, dt_softplus: bool) -> Tensor
ClikaRT::ops::ssd_update: delegates to Api::f_op_ssd_update.
std / f_std
fn f_std(self, dims: &[i64], correction: i64, keepdim: bool) -> Result<Tensor>
fn std(self, dims: &[i64], correction: i64, keepdim: bool) -> Tensor
ClikaRT::ops::std: delegates to Api::f_op_std.
stft / f_stft
fn f_stft(self, n_fft: i64, window: Tensor, options: &StftOptions) -> Result<Tensor>
fn stft(self, n_fft: i64, window: Tensor, options: &StftOptions) -> Tensor
ClikaRT::ops::stft: delegates to Api::f_op_stft.
sub_ / f_sub_
fn f_sub_(self, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Result<&Self>
fn sub_(self, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> &Self
ClikaRT::ops::sub_: delegates to Api::f_op_sub_inplace.
sub_tensor / f_sub_tensor
fn f_sub_tensor(self, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Result<Tensor>
fn sub_tensor(self, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Tensor
ClikaRT::ops::sub: delegates to Api::f_op_sub_tensor.
sum / f_sum
fn f_sum(self, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Result<Tensor>
fn sum(self, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Tensor
ClikaRT::ops::sum: delegates to Api::f_op_sum.
swiglu / f_swiglu
fn f_swiglu(self, alpha: f64, beta: f64, limit: f64) -> Result<Tensor>
fn swiglu(self, alpha: f64, beta: f64, limit: f64) -> Tensor
ClikaRT::ops::swiglu: delegates to Api::f_op_swiglu.
take / f_take
fn f_take(self, index: Tensor) -> Result<Tensor>
fn take(self, index: Tensor) -> Tensor
ClikaRT::ops::take: delegates to Api::f_op_take.
take_along_dim / f_take_along_dim
fn f_take_along_dim(self, index: Tensor, dim_has: bool, dim: i64) -> Result<Tensor>
fn take_along_dim(self, index: Tensor, dim_has: bool, dim: i64) -> Tensor
ClikaRT::ops::take_along_dim: delegates to Api::f_op_take_along_dim.
tan / f_tan
fn f_tan(self) -> Result<Tensor>
fn tan(self) -> Tensor
ClikaRT::ops::tan: delegates to Api::f_op_tan.
tan_ / f_tan_
fn f_tan_(self) -> Result<&Self>
fn tan_(self) -> &Self
ClikaRT::ops::tan_: delegates to Api::f_op_tan_inplace.
tanh / f_tanh
fn f_tanh(self) -> Result<Tensor>
fn tanh(self) -> Tensor
ClikaRT::ops::tanh: delegates to Api::f_op_tanh.
tanh_ / f_tanh_
fn f_tanh_(self) -> Result<&Self>
fn tanh_(self) -> &Self
ClikaRT::ops::tanh_: delegates to Api::f_op_tanh_inplace.
tensordot / f_tensordot
fn f_tensordot(self, b: Tensor, dims_a: &[i64], dims_b: &[i64]) -> Result<Tensor>
fn tensordot(self, b: Tensor, dims_a: &[i64], dims_b: &[i64]) -> Tensor
ClikaRT::ops::tensordot: delegates to Api::f_op_tensordot.
threshold / f_threshold
fn f_threshold(self, threshold: f64, value: f64) -> Result<Tensor>
fn threshold(self, threshold: f64, value: f64) -> Tensor
ClikaRT::ops::threshold: delegates to Api::f_op_threshold.
threshold_ / f_threshold_
fn f_threshold_(self, threshold: f64, value: f64) -> Result<&Self>
fn threshold_(self, threshold: f64, value: f64) -> &Self
ClikaRT::ops::threshold_: delegates to Api::f_op_threshold_inplace.
tile / f_tile
fn f_tile(self, dims: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn tile(self, dims: &[clika_rt_scalar_or_tensor]) -> Tensor
ClikaRT::ops::tile: delegates to Api::f_op_tile.
topk / f_topk
fn f_topk(self, k: i64, dim: i64, largest: bool, sorted: bool) -> Result<(Tensor, Tensor)>
fn topk(self, k: i64, dim: i64, largest: bool, sorted: bool) -> (Tensor, Tensor)
ClikaRT::ops::topk: delegates to Api::f_op_topk.
trace / f_trace
fn f_trace(self) -> Result<Tensor>
fn trace(self) -> Tensor
ClikaRT::ops::trace: delegates to Api::f_op_trace.
transpose / f_transpose
fn f_transpose(self, dim0: i64, dim1: i64) -> Result<Tensor>
fn transpose(self, dim0: i64, dim1: i64) -> Tensor
ClikaRT::ops::transpose: delegates to Api::f_op_transpose.
tril / f_tril
fn f_tril(self, diagonal: i64) -> Result<Tensor>
fn tril(self, diagonal: i64) -> Tensor
ClikaRT::ops::tril: delegates to Api::f_op_tril.
tril_ / f_tril_
fn f_tril_(self, diagonal: i64) -> Result<&Self>
fn tril_(self, diagonal: i64) -> &Self
ClikaRT::ops::tril_: delegates to Api::f_op_tril_inplace.
triu / f_triu
fn f_triu(self, diagonal: i64) -> Result<Tensor>
fn triu(self, diagonal: i64) -> Tensor
ClikaRT::ops::triu: delegates to Api::f_op_triu.
triu_ / f_triu_
fn f_triu_(self, diagonal: i64) -> Result<&Self>
fn triu_(self, diagonal: i64) -> &Self
ClikaRT::ops::triu_: delegates to Api::f_op_triu_inplace.
trunc / f_trunc
fn f_trunc(self) -> Result<Tensor>
fn trunc(self) -> Tensor
ClikaRT::ops::trunc: delegates to Api::f_op_trunc.
trunc_ / f_trunc_
fn f_trunc_(self) -> Result<&Self>
fn trunc_(self) -> &Self
ClikaRT::ops::trunc_: delegates to Api::f_op_trunc_inplace.
unflatten / f_unflatten
fn f_unflatten(self, dim: i64, sizes: &[i64]) -> Result<Tensor>
fn unflatten(self, dim: i64, sizes: &[i64]) -> Tensor
ClikaRT::ops::unflatten: delegates to Api::f_op_unflatten.
unfold / f_unfold
fn f_unfold(self, kernel_size: &[i64], dilation: &[i64], padding: &[i64], stride: &[i64], mode: clika_rt_pad_mode, value_has: bool, value: f64) -> Result<Tensor>
fn unfold(self, kernel_size: &[i64], dilation: &[i64], padding: &[i64], stride: &[i64], mode: clika_rt_pad_mode, value_has: bool, value: f64) -> Tensor
ClikaRT::ops::unfold: delegates to Api::f_op_unfold.
uniform_ / f_uniform_
fn f_uniform_(self, low: f64, high: f64, device: clika_rt_stream_or_device) -> Result<&Self>
fn uniform_(self, low: f64, high: f64, device: clika_rt_stream_or_device) -> &Self
ClikaRT::ops::uniform_: delegates to Api::f_op_uniform_inplace.
unique / f_unique
fn f_unique(self, sorted: bool, return_inverse: bool, return_counts: bool, dim_has: bool, dim: i64) -> Result<(Tensor, Tensor, Tensor)>
fn unique(self, sorted: bool, return_inverse: bool, return_counts: bool, dim_has: bool, dim: i64) -> (Tensor, Tensor, Tensor)
ClikaRT::ops::unique: delegates to Api::f_op_unique.
unique_consecutive / f_unique_consecutive
fn f_unique_consecutive(self, return_inverse: bool, return_counts: bool, dim_has: bool, dim: i64) -> Result<(Tensor, Tensor, Tensor)>
fn unique_consecutive(self, return_inverse: bool, return_counts: bool, dim_has: bool, dim: i64) -> (Tensor, Tensor, Tensor)
ClikaRT::ops::unique_consecutive: delegates to Api::f_op_unique_consecutive.
unsqueeze / f_unsqueeze
fn f_unsqueeze(self, dim: i64) -> Result<Tensor>
fn unsqueeze(self, dim: i64) -> Tensor
ClikaRT::ops::unsqueeze: delegates to Api::f_op_unsqueeze.
unsqueeze_ / f_unsqueeze_
fn f_unsqueeze_(self, dim: i64) -> Result<&Self>
fn unsqueeze_(self, dim: i64) -> &Self
ClikaRT::ops::unsqueeze_: delegates to Api::f_op_unsqueeze_inplace.
upsample_bicubic2d / f_upsample_bicubic2d
fn f_upsample_bicubic2d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Result<Tensor>
fn upsample_bicubic2d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Tensor
ClikaRT::ops::upsample_bicubic2d: delegates to Api::f_op_upsample_bicubic2d.
upsample_bilinear2d / f_upsample_bilinear2d
fn f_upsample_bilinear2d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Result<Tensor>
fn upsample_bilinear2d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Tensor
ClikaRT::ops::upsample_bilinear2d: delegates to Api::f_op_upsample_bilinear2d.
upsample_linear1d / f_upsample_linear1d
fn f_upsample_linear1d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Result<Tensor>
fn upsample_linear1d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Tensor
ClikaRT::ops::upsample_linear1d: delegates to Api::f_op_upsample_linear1d.
upsample_nearest1d / f_upsample_nearest1d
fn f_upsample_nearest1d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn upsample_nearest1d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Tensor
ClikaRT::ops::upsample_nearest1d: delegates to Api::f_op_upsample_nearest1d.
upsample_nearest2d / f_upsample_nearest2d
fn f_upsample_nearest2d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn upsample_nearest2d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Tensor
ClikaRT::ops::upsample_nearest2d: delegates to Api::f_op_upsample_nearest2d.
upsample_nearest3d / f_upsample_nearest3d
fn f_upsample_nearest3d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn upsample_nearest3d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Tensor
ClikaRT::ops::upsample_nearest3d: delegates to Api::f_op_upsample_nearest3d.
upsample_trilinear3d / f_upsample_trilinear3d
fn f_upsample_trilinear3d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Result<Tensor>
fn upsample_trilinear3d(self, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Tensor
ClikaRT::ops::upsample_trilinear3d: delegates to Api::f_op_upsample_trilinear3d.
var / f_var
fn f_var(self, dims: &[i64], correction: i64, keepdim: bool) -> Result<Tensor>
fn var(self, dims: &[i64], correction: i64, keepdim: bool) -> Tensor
ClikaRT::ops::var: delegates to Api::f_op_var.
xlog1py / f_xlog1py
fn f_xlog1py(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn xlog1py(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::xlog1py: delegates to Api::f_op_xlog1py.
xlogy / f_xlogy
fn f_xlogy(self, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn xlogy(self, other: clika_rt_scalar_or_tensor) -> Tensor
ClikaRT::ops::xlogy: delegates to Api::f_op_xlogy.
xlogy_ / f_xlogy_
fn f_xlogy_(self, other: clika_rt_scalar_or_tensor) -> Result<&Self>
fn xlogy_(self, other: clika_rt_scalar_or_tensor) -> &Self
ClikaRT::ops::xlogy_: delegates to Api::f_op_xlogy_inplace.
zero_ / f_zero_
fn f_zero_(self, device: clika_rt_stream_or_device) -> Result<&Self>
fn zero_(self, device: clika_rt_stream_or_device) -> &Self
ClikaRT::ops::zero_: delegates to Api::f_op_zero_inplace.