Api: op
Api members in the op family.
op_abs / f_op_abs
fn f_op_abs(self, x: Tensor) -> Result<Tensor>
fn op_abs(self, x: Tensor) -> Tensor
Wraps api-table member op_abs.
ClikaRT::ops::abs <- ClikaRT/compute/ops.h
op_abs_inplace / f_op_abs_inplace
fn f_op_abs_inplace(self, self_: &Tensor) -> Result<()>
fn op_abs_inplace(self, self_: &Tensor)
Wraps api-table member op_abs_inplace.
ClikaRT::ops::abs_ <- ClikaRT/compute/ops.h
op_acos / f_op_acos
fn f_op_acos(self, x: Tensor) -> Result<Tensor>
fn op_acos(self, x: Tensor) -> Tensor
Wraps api-table member op_acos.
ClikaRT::ops::acos <- ClikaRT/compute/ops.h
op_acos_inplace / f_op_acos_inplace
fn f_op_acos_inplace(self, self_: &Tensor) -> Result<()>
fn op_acos_inplace(self, self_: &Tensor)
Wraps api-table member op_acos_inplace.
ClikaRT::ops::acos_ <- ClikaRT/compute/ops.h
op_acosh / f_op_acosh
fn f_op_acosh(self, x: Tensor) -> Result<Tensor>
fn op_acosh(self, x: Tensor) -> Tensor
Wraps api-table member op_acosh.
ClikaRT::ops::acosh <- ClikaRT/compute/ops.h
op_acosh_inplace / f_op_acosh_inplace
fn f_op_acosh_inplace(self, self_: &Tensor) -> Result<()>
fn op_acosh_inplace(self, self_: &Tensor)
Wraps api-table member op_acosh_inplace.
ClikaRT::ops::acosh_ <- ClikaRT/compute/ops.h
op_adaptive_avg_pool / f_op_adaptive_avg_pool
fn f_op_adaptive_avg_pool(self, x: Tensor, output_size: &[i64]) -> Result<Tensor>
fn op_adaptive_avg_pool(self, x: Tensor, output_size: &[i64]) -> Tensor
Wraps api-table member op_adaptive_avg_pool.
ClikaRT::ops::adaptive_avg_pool <- ClikaRT/compute/ops.h
op_adaptive_avg_pool1d / f_op_adaptive_avg_pool1d
fn f_op_adaptive_avg_pool1d(self, x: Tensor, output_size: &[i64]) -> Result<Tensor>
fn op_adaptive_avg_pool1d(self, x: Tensor, output_size: &[i64]) -> Tensor
Wraps api-table member op_adaptive_avg_pool1d.
ClikaRT::ops::adaptive_avg_pool1d <- ClikaRT/compute/ops.h
op_adaptive_avg_pool2d / f_op_adaptive_avg_pool2d
fn f_op_adaptive_avg_pool2d(self, x: Tensor, output_size: &[i64]) -> Result<Tensor>
fn op_adaptive_avg_pool2d(self, x: Tensor, output_size: &[i64]) -> Tensor
Wraps api-table member op_adaptive_avg_pool2d.
ClikaRT::ops::adaptive_avg_pool2d <- ClikaRT/compute/ops.h
op_adaptive_avg_pool3d / f_op_adaptive_avg_pool3d
fn f_op_adaptive_avg_pool3d(self, x: Tensor, output_size: &[i64]) -> Result<Tensor>
fn op_adaptive_avg_pool3d(self, x: Tensor, output_size: &[i64]) -> Tensor
Wraps api-table member op_adaptive_avg_pool3d.
ClikaRT::ops::adaptive_avg_pool3d <- ClikaRT/compute/ops.h
op_adaptive_max_pool / f_op_adaptive_max_pool
fn f_op_adaptive_max_pool(self, x: Tensor, output_size: &[i64]) -> Result<Tensor>
fn op_adaptive_max_pool(self, x: Tensor, output_size: &[i64]) -> Tensor
Wraps api-table member op_adaptive_max_pool.
ClikaRT::ops::adaptive_max_pool <- ClikaRT/compute/ops.h
op_adaptive_max_pool1d / f_op_adaptive_max_pool1d
fn f_op_adaptive_max_pool1d(self, x: Tensor, output_size: &[i64]) -> Result<Tensor>
fn op_adaptive_max_pool1d(self, x: Tensor, output_size: &[i64]) -> Tensor
Wraps api-table member op_adaptive_max_pool1d.
ClikaRT::ops::adaptive_max_pool1d <- ClikaRT/compute/ops.h
op_adaptive_max_pool2d / f_op_adaptive_max_pool2d
fn f_op_adaptive_max_pool2d(self, x: Tensor, output_size: &[i64]) -> Result<Tensor>
fn op_adaptive_max_pool2d(self, x: Tensor, output_size: &[i64]) -> Tensor
Wraps api-table member op_adaptive_max_pool2d.
ClikaRT::ops::adaptive_max_pool2d <- ClikaRT/compute/ops.h
op_adaptive_max_pool3d / f_op_adaptive_max_pool3d
fn f_op_adaptive_max_pool3d(self, x: Tensor, output_size: &[i64]) -> Result<Tensor>
fn op_adaptive_max_pool3d(self, x: Tensor, output_size: &[i64]) -> Tensor
Wraps api-table member op_adaptive_max_pool3d.
ClikaRT::ops::adaptive_max_pool3d <- ClikaRT/compute/ops.h
op_add_inplace / f_op_add_inplace
fn f_op_add_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Result<()>
fn op_add_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation)
Wraps api-table member op_add_inplace.
ClikaRT::ops::add_ <- ClikaRT/compute/ops.h
op_add_layer_norm / f_op_add_layer_norm
fn f_op_add_layer_norm(self, x: Tensor, 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 op_add_layer_norm(self, x: Tensor, 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)
Wraps api-table member op_add_layer_norm.
ClikaRT::ops::add_layer_norm <- ClikaRT/compute/ops.h
op_add_rms_norm / f_op_add_rms_norm
fn f_op_add_rms_norm(self, x: Tensor, 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 op_add_rms_norm(self, x: Tensor, 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)
Wraps api-table member op_add_rms_norm.
ClikaRT::ops::add_rms_norm <- ClikaRT/compute/ops.h
op_add_scalar
fn op_add_scalar(self, a: Tensor, scalar: f64) -> Result<Tensor>
a + scalar, elementwise. CONSUMES a (the contract's donation law:
an op operand transfers the caller's reference; the by-value Tensor
here is the Rust spelling of exactly that).
op_add_scalar_lhs / f_op_add_scalar_lhs
fn f_op_add_scalar_lhs(self, a: clika_rt_scalar, b: Tensor, alpha: f64, activation: clika_rt_activation) -> Result<Tensor>
fn op_add_scalar_lhs(self, a: clika_rt_scalar, b: Tensor, alpha: f64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_add_scalar_lhs.
ClikaRT::ops::add <- ClikaRT/compute/ops.h
op_add_tensor / f_op_add_tensor
fn f_op_add_tensor(self, a: Tensor, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Result<Tensor>
fn op_add_tensor(self, a: Tensor, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_add_tensor.
ClikaRT::ops::add <- ClikaRT/compute/ops.h
op_all / f_op_all
fn f_op_all(self, x: Tensor, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn op_all(self, x: Tensor, dims: &[i64], keepdim: bool) -> Tensor
Wraps api-table member op_all.
ClikaRT::ops::all <- ClikaRT/compute/ops.h
op_allclose / f_op_allclose
fn f_op_allclose(self, a: Tensor, b: Tensor, rtol: f64, atol: f64, equal_nan: bool) -> Result<Tensor>
fn op_allclose(self, a: Tensor, b: Tensor, rtol: f64, atol: f64, equal_nan: bool) -> Tensor
Wraps api-table member op_allclose.
ClikaRT::ops::allclose <- ClikaRT/compute/ops.h
op_amax / f_op_amax
fn f_op_amax(self, x: Tensor, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn op_amax(self, x: Tensor, dims: &[i64], keepdim: bool) -> Tensor
Wraps api-table member op_amax.
ClikaRT::ops::amax <- ClikaRT/compute/ops.h
op_amin / f_op_amin
fn f_op_amin(self, x: Tensor, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn op_amin(self, x: Tensor, dims: &[i64], keepdim: bool) -> Tensor
Wraps api-table member op_amin.
ClikaRT::ops::amin <- ClikaRT/compute/ops.h
op_aminmax / f_op_aminmax
fn f_op_aminmax(self, x: Tensor, dim_has: bool, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn op_aminmax(self, x: Tensor, dim_has: bool, dim: i64, keepdim: bool) -> (Tensor, Tensor)
Wraps api-table member op_aminmax.
ClikaRT::ops::aminmax <- ClikaRT/compute/ops.h
op_any / f_op_any
fn f_op_any(self, x: Tensor, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn op_any(self, x: Tensor, dims: &[i64], keepdim: bool) -> Tensor
Wraps api-table member op_any.
ClikaRT::ops::any <- ClikaRT/compute/ops.h
op_arange / f_op_arange
fn f_op_arange(self, start: clika_rt_scalar_or_tensor, end: clika_rt_scalar_or_tensor, step: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_arange(self, start: clika_rt_scalar_or_tensor, end: clika_rt_scalar_or_tensor, step: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_arange.
ClikaRT::ops::arange <- ClikaRT/compute/ops.h
op_argmax / f_op_argmax
fn f_op_argmax(self, x: Tensor, dims: &[i64], keepdim: bool, index_dtype: clika_rt_data_type) -> Result<Tensor>
fn op_argmax(self, x: Tensor, dims: &[i64], keepdim: bool, index_dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_argmax.
ClikaRT::ops::argmax <- ClikaRT/compute/ops.h
op_argmin / f_op_argmin
fn f_op_argmin(self, x: Tensor, dims: &[i64], keepdim: bool, index_dtype: clika_rt_data_type) -> Result<Tensor>
fn op_argmin(self, x: Tensor, dims: &[i64], keepdim: bool, index_dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_argmin.
ClikaRT::ops::argmin <- ClikaRT/compute/ops.h
op_argsort / f_op_argsort
fn f_op_argsort(self, x: Tensor, dim: i64, descending: bool, stable: bool) -> Result<Tensor>
fn op_argsort(self, x: Tensor, dim: i64, descending: bool, stable: bool) -> Tensor
Wraps api-table member op_argsort.
ClikaRT::ops::argsort <- ClikaRT/compute/ops.h
op_asin / f_op_asin
fn f_op_asin(self, x: Tensor) -> Result<Tensor>
fn op_asin(self, x: Tensor) -> Tensor
Wraps api-table member op_asin.
ClikaRT::ops::asin <- ClikaRT/compute/ops.h
op_asin_inplace / f_op_asin_inplace
fn f_op_asin_inplace(self, self_: &Tensor) -> Result<()>
fn op_asin_inplace(self, self_: &Tensor)
Wraps api-table member op_asin_inplace.
ClikaRT::ops::asin_ <- ClikaRT/compute/ops.h
op_asinh / f_op_asinh
fn f_op_asinh(self, x: Tensor) -> Result<Tensor>
fn op_asinh(self, x: Tensor) -> Tensor
Wraps api-table member op_asinh.
ClikaRT::ops::asinh <- ClikaRT/compute/ops.h
op_asinh_inplace / f_op_asinh_inplace
fn f_op_asinh_inplace(self, self_: &Tensor) -> Result<()>
fn op_asinh_inplace(self, self_: &Tensor)
Wraps api-table member op_asinh_inplace.
ClikaRT::ops::asinh_ <- ClikaRT/compute/ops.h
op_atan / f_op_atan
fn f_op_atan(self, x: Tensor) -> Result<Tensor>
fn op_atan(self, x: Tensor) -> Tensor
Wraps api-table member op_atan.
ClikaRT::ops::atan <- ClikaRT/compute/ops.h
op_atan2 / f_op_atan2
fn f_op_atan2(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_atan2(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_atan2.
ClikaRT::ops::atan2 <- ClikaRT/compute/ops.h
op_atan2_inplace / f_op_atan2_inplace
fn f_op_atan2_inplace(self, self_: &Tensor, other: Tensor) -> Result<()>
fn op_atan2_inplace(self, self_: &Tensor, other: Tensor)
Wraps api-table member op_atan2_inplace.
ClikaRT::ops::atan2_ <- ClikaRT/compute/ops.h
op_atan_inplace / f_op_atan_inplace
fn f_op_atan_inplace(self, self_: &Tensor) -> Result<()>
fn op_atan_inplace(self, self_: &Tensor)
Wraps api-table member op_atan_inplace.
ClikaRT::ops::atan_ <- ClikaRT/compute/ops.h
op_atanh / f_op_atanh
fn f_op_atanh(self, x: Tensor) -> Result<Tensor>
fn op_atanh(self, x: Tensor) -> Tensor
Wraps api-table member op_atanh.
ClikaRT::ops::atanh <- ClikaRT/compute/ops.h
op_atanh_inplace / f_op_atanh_inplace
fn f_op_atanh_inplace(self, self_: &Tensor) -> Result<()>
fn op_atanh_inplace(self, self_: &Tensor)
Wraps api-table member op_atanh_inplace.
ClikaRT::ops::atanh_ <- ClikaRT/compute/ops.h
op_atleast_1d / f_op_atleast_1d
fn f_op_atleast_1d(self, x: Tensor) -> Result<Tensor>
fn op_atleast_1d(self, x: Tensor) -> Tensor
Wraps api-table member op_atleast_1d.
ClikaRT::ops::atleast_1d <- ClikaRT/compute/ops.h
op_atleast_2d / f_op_atleast_2d
fn f_op_atleast_2d(self, x: Tensor) -> Result<Tensor>
fn op_atleast_2d(self, x: Tensor) -> Tensor
Wraps api-table member op_atleast_2d.
ClikaRT::ops::atleast_2d <- ClikaRT/compute/ops.h
op_atleast_3d / f_op_atleast_3d
fn f_op_atleast_3d(self, x: Tensor) -> Result<Tensor>
fn op_atleast_3d(self, x: Tensor) -> Tensor
Wraps api-table member op_atleast_3d.
ClikaRT::ops::atleast_3d <- ClikaRT/compute/ops.h
op_attention / f_op_attention
fn f_op_attention(self, q: Tensor, k: Tensor, v: Tensor, attn_mask: Tensor, head_sink: Tensor, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, options: &AttentionOptions) -> Result<Tensor>
fn op_attention(self, q: Tensor, k: Tensor, v: Tensor, attn_mask: Tensor, head_sink: Tensor, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, options: &AttentionOptions) -> Tensor
Wraps api-table member op_attention.
ClikaRT::ops::attention <- ClikaRT/compute/ops.h
op_attention_over_cache / f_op_attention_over_cache
fn f_op_attention_over_cache(self, q: Tensor, cache_key: Tensor, cache_value: Tensor, kvcache_start: Tensor, cu_seqlens_q: Tensor, cu_seqlens_k: Tensor, max_seqlen_q: clika_rt_scalar_or_tensor, max_seqlen_k: clika_rt_scalar_or_tensor, rope_cos: Tensor, rope_sin: Tensor, position_ids: Tensor, attn_mask: Tensor, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, head_sink: Tensor, q_norm_gain: Tensor, k_norm_gain: Tensor, slot_ids: Tensor, options: &AttentionOverCacheOptions) -> Result<Tensor>
fn op_attention_over_cache(self, q: Tensor, cache_key: Tensor, cache_value: Tensor, kvcache_start: Tensor, cu_seqlens_q: Tensor, cu_seqlens_k: Tensor, max_seqlen_q: clika_rt_scalar_or_tensor, max_seqlen_k: clika_rt_scalar_or_tensor, rope_cos: Tensor, rope_sin: Tensor, position_ids: Tensor, attn_mask: Tensor, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, head_sink: Tensor, q_norm_gain: Tensor, k_norm_gain: Tensor, slot_ids: Tensor, options: &AttentionOverCacheOptions) -> Tensor
Wraps api-table member op_attention_over_cache.
ClikaRT::ops::attention_over_cache <- ClikaRT/compute/ops.h
op_attention_varlen / f_op_attention_varlen
fn f_op_attention_varlen(self, q: Tensor, k: Tensor, v: Tensor, cu_seqlens_q: Tensor, cu_seqlens_k: Tensor, max_seqlen_q: clika_rt_scalar_or_tensor, max_seqlen_k: clika_rt_scalar_or_tensor, attn_mask: Tensor, head_sink: Tensor, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, options: &AttentionVarlenOptions) -> Result<Tensor>
fn op_attention_varlen(self, q: Tensor, k: Tensor, v: Tensor, cu_seqlens_q: Tensor, cu_seqlens_k: Tensor, max_seqlen_q: clika_rt_scalar_or_tensor, max_seqlen_k: clika_rt_scalar_or_tensor, attn_mask: Tensor, head_sink: Tensor, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, options: &AttentionVarlenOptions) -> Tensor
Wraps api-table member op_attention_varlen.
ClikaRT::ops::attention_varlen <- ClikaRT/compute/ops.h
op_avg_pool / f_op_avg_pool
fn f_op_avg_pool(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Result<Tensor>
fn op_avg_pool(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Tensor
Wraps api-table member op_avg_pool.
ClikaRT::ops::avg_pool <- ClikaRT/compute/ops.h
op_avg_pool1d / f_op_avg_pool1d
fn f_op_avg_pool1d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool) -> Result<Tensor>
fn op_avg_pool1d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool) -> Tensor
Wraps api-table member op_avg_pool1d.
ClikaRT::ops::avg_pool1d <- ClikaRT/compute/ops.h
op_avg_pool2d / f_op_avg_pool2d
fn f_op_avg_pool2d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Result<Tensor>
fn op_avg_pool2d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Tensor
Wraps api-table member op_avg_pool2d.
ClikaRT::ops::avg_pool2d <- ClikaRT/compute/ops.h
op_avg_pool3d / f_op_avg_pool3d
fn f_op_avg_pool3d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Result<Tensor>
fn op_avg_pool3d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], ceil_mode: bool, count_include_pad: bool, divisor_override_has: bool, divisor_override: i64) -> Tensor
Wraps api-table member op_avg_pool3d.
ClikaRT::ops::avg_pool3d <- ClikaRT/compute/ops.h
op_batch_norm / f_op_batch_norm
fn f_op_batch_norm(self, x: Tensor, 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 op_batch_norm(self, x: Tensor, weight: Tensor, bias: Tensor, running_mean: Tensor, running_var: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_batch_norm.
ClikaRT::ops::batch_norm <- ClikaRT/compute/ops.h
op_bernoulli / f_op_bernoulli
fn f_op_bernoulli(self, probabilities: Tensor, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_bernoulli(self, probabilities: Tensor, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_bernoulli.
ClikaRT::ops::bernoulli <- ClikaRT/compute/ops.h
op_bernoulli_inplace / f_op_bernoulli_inplace
fn f_op_bernoulli_inplace(self, self_: &Tensor, s: clika_rt_stream_or_device) -> Result<()>
fn op_bernoulli_inplace(self, self_: &Tensor, s: clika_rt_stream_or_device)
Wraps api-table member op_bernoulli_inplace.
ClikaRT::ops::bernoulli_ <- ClikaRT/compute/ops.h
op_binary_cross_entropy / f_op_binary_cross_entropy
fn f_op_binary_cross_entropy(self, input: Tensor, target: Tensor, weight: Tensor, reduction: clika_rt_reduction) -> Result<Tensor>
fn op_binary_cross_entropy(self, input: Tensor, target: Tensor, weight: Tensor, reduction: clika_rt_reduction) -> Tensor
Wraps api-table member op_binary_cross_entropy.
ClikaRT::ops::binary_cross_entropy <- ClikaRT/compute/ops.h
op_binary_cross_entropy_with_logits / f_op_binary_cross_entropy_with_logits
fn f_op_binary_cross_entropy_with_logits(self, input: Tensor, target: Tensor, weight: Tensor, reduction: clika_rt_reduction, pos_weight: Tensor) -> Result<Tensor>
fn op_binary_cross_entropy_with_logits(self, input: Tensor, target: Tensor, weight: Tensor, reduction: clika_rt_reduction, pos_weight: Tensor) -> Tensor
Wraps api-table member op_binary_cross_entropy_with_logits.
ClikaRT::ops::binary_cross_entropy_with_logits <- ClikaRT/compute/ops.h
op_bincount / f_op_bincount
fn f_op_bincount(self, x: Tensor, weights: Tensor, minlength: i64) -> Result<Tensor>
fn op_bincount(self, x: Tensor, weights: Tensor, minlength: i64) -> Tensor
Wraps api-table member op_bincount.
ClikaRT::ops::bincount <- ClikaRT/compute/ops.h
op_bitwise_and / f_op_bitwise_and
fn f_op_bitwise_and(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_bitwise_and(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_bitwise_and.
ClikaRT::ops::bitwise_and <- ClikaRT/compute/ops.h
op_bitwise_and_inplace / f_op_bitwise_and_inplace
fn f_op_bitwise_and_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_bitwise_and_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_bitwise_and_inplace.
ClikaRT::ops::bitwise_and_ <- ClikaRT/compute/ops.h
op_bitwise_left_shift / f_op_bitwise_left_shift
fn f_op_bitwise_left_shift(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_bitwise_left_shift(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_bitwise_left_shift.
ClikaRT::ops::bitwise_left_shift <- ClikaRT/compute/ops.h
op_bitwise_left_shift_inplace / f_op_bitwise_left_shift_inplace
fn f_op_bitwise_left_shift_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_bitwise_left_shift_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_bitwise_left_shift_inplace.
ClikaRT::ops::bitwise_left_shift_ <- ClikaRT/compute/ops.h
op_bitwise_not / f_op_bitwise_not
fn f_op_bitwise_not(self, x: Tensor) -> Result<Tensor>
fn op_bitwise_not(self, x: Tensor) -> Tensor
Wraps api-table member op_bitwise_not.
ClikaRT::ops::bitwise_not <- ClikaRT/compute/ops.h
op_bitwise_not_inplace / f_op_bitwise_not_inplace
fn f_op_bitwise_not_inplace(self, self_: &Tensor) -> Result<()>
fn op_bitwise_not_inplace(self, self_: &Tensor)
Wraps api-table member op_bitwise_not_inplace.
ClikaRT::ops::bitwise_not_ <- ClikaRT/compute/ops.h
op_bitwise_or / f_op_bitwise_or
fn f_op_bitwise_or(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_bitwise_or(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_bitwise_or.
ClikaRT::ops::bitwise_or <- ClikaRT/compute/ops.h
op_bitwise_or_inplace / f_op_bitwise_or_inplace
fn f_op_bitwise_or_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_bitwise_or_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_bitwise_or_inplace.
ClikaRT::ops::bitwise_or_ <- ClikaRT/compute/ops.h
op_bitwise_right_shift / f_op_bitwise_right_shift
fn f_op_bitwise_right_shift(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_bitwise_right_shift(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_bitwise_right_shift.
ClikaRT::ops::bitwise_right_shift <- ClikaRT/compute/ops.h
op_bitwise_right_shift_inplace / f_op_bitwise_right_shift_inplace
fn f_op_bitwise_right_shift_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_bitwise_right_shift_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_bitwise_right_shift_inplace.
ClikaRT::ops::bitwise_right_shift_ <- ClikaRT/compute/ops.h
op_bitwise_xor / f_op_bitwise_xor
fn f_op_bitwise_xor(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_bitwise_xor(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_bitwise_xor.
ClikaRT::ops::bitwise_xor <- ClikaRT/compute/ops.h
op_bitwise_xor_inplace / f_op_bitwise_xor_inplace
fn f_op_bitwise_xor_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_bitwise_xor_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_bitwise_xor_inplace.
ClikaRT::ops::bitwise_xor_ <- ClikaRT/compute/ops.h
op_bmm / f_op_bmm
fn f_op_bmm(self, a: Tensor, b: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn op_bmm(self, a: Tensor, b: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_bmm.
ClikaRT::ops::bmm <- ClikaRT/compute/ops.h
op_broadcast_tensors / f_op_broadcast_tensors
fn f_op_broadcast_tensors(self, tensors: &[&Tensor]) -> Result<TensorList>
fn op_broadcast_tensors(self, tensors: &[&Tensor]) -> TensorList
Wraps api-table member op_broadcast_tensors.
ClikaRT::ops::broadcast_tensors <- ClikaRT/compute/ops.h
op_broadcast_to / f_op_broadcast_to
fn f_op_broadcast_to(self, x: Tensor, shape: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn op_broadcast_to(self, x: Tensor, shape: &[clika_rt_scalar_or_tensor]) -> Tensor
Wraps api-table member op_broadcast_to.
ClikaRT::ops::broadcast_to <- ClikaRT/compute/ops.h
op_bucketize / f_op_bucketize
fn f_op_bucketize(self, x: Tensor, boundaries: Tensor, out_int32: bool, right: bool) -> Result<Tensor>
fn op_bucketize(self, x: Tensor, boundaries: Tensor, out_int32: bool, right: bool) -> Tensor
Wraps api-table member op_bucketize.
ClikaRT::ops::bucketize <- ClikaRT/compute/ops.h
op_cast / f_op_cast
fn f_op_cast(self, x: Tensor, target: clika_rt_data_type, force_copy: bool) -> Result<Tensor>
fn op_cast(self, x: Tensor, target: clika_rt_data_type, force_copy: bool) -> Tensor
Wraps api-table member op_cast.
ClikaRT::ops::cast <- ClikaRT/compute/ops.h
op_cast_like / f_op_cast_like
fn f_op_cast_like(self, x: Tensor, reference: Tensor) -> Result<Tensor>
fn op_cast_like(self, x: Tensor, reference: Tensor) -> Tensor
Wraps api-table member op_cast_like.
ClikaRT::ops::cast_like <- ClikaRT/compute/ops.h
op_causal_conv_update / f_op_causal_conv_update
fn f_op_causal_conv_update(self, x: Tensor, weight: Tensor, bias: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn op_causal_conv_update(self, x: Tensor, weight: Tensor, bias: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_causal_conv_update.
ClikaRT::ops::causal_conv_update <- ClikaRT/compute/ops.h
op_cdist / f_op_cdist
fn f_op_cdist(self, a: Tensor, b: Tensor, p: clika_rt_scalar) -> Result<Tensor>
fn op_cdist(self, a: Tensor, b: Tensor, p: clika_rt_scalar) -> Tensor
Wraps api-table member op_cdist.
ClikaRT::ops::cdist <- ClikaRT/compute/ops.h
op_ceil / f_op_ceil
fn f_op_ceil(self, x: Tensor) -> Result<Tensor>
fn op_ceil(self, x: Tensor) -> Tensor
Wraps api-table member op_ceil.
ClikaRT::ops::ceil <- ClikaRT/compute/ops.h
op_ceil_inplace / f_op_ceil_inplace
fn f_op_ceil_inplace(self, self_: &Tensor) -> Result<()>
fn op_ceil_inplace(self, self_: &Tensor)
Wraps api-table member op_ceil_inplace.
ClikaRT::ops::ceil_ <- ClikaRT/compute/ops.h
op_celu / f_op_celu
fn f_op_celu(self, x: Tensor, alpha: f64) -> Result<Tensor>
fn op_celu(self, x: Tensor, alpha: f64) -> Tensor
Wraps api-table member op_celu.
ClikaRT::ops::celu <- ClikaRT/compute/ops.h
op_celu_inplace / f_op_celu_inplace
fn f_op_celu_inplace(self, self_: &Tensor, alpha: f64) -> Result<()>
fn op_celu_inplace(self, self_: &Tensor, alpha: f64)
Wraps api-table member op_celu_inplace.
ClikaRT::ops::celu_ <- ClikaRT/compute/ops.h
op_chunk / f_op_chunk
fn f_op_chunk(self, x: Tensor, num_chunks: i64, dim: i64) -> Result<TensorList>
fn op_chunk(self, x: Tensor, num_chunks: i64, dim: i64) -> TensorList
Wraps api-table member op_chunk.
ClikaRT::ops::chunk <- ClikaRT/compute/ops.h
op_circular_pad / f_op_circular_pad
fn f_op_circular_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn op_circular_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor]) -> Tensor
Wraps api-table member op_circular_pad.
ClikaRT::ops::circular_pad <- ClikaRT/compute/ops.h
op_clamp / f_op_clamp
fn f_op_clamp(self, x: Tensor, min: clika_rt_scalar_or_tensor, max: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_clamp(self, x: Tensor, min: clika_rt_scalar_or_tensor, max: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_clamp.
ClikaRT::ops::clamp <- ClikaRT/compute/ops.h
op_clamp_inplace / f_op_clamp_inplace
fn f_op_clamp_inplace(self, self_: &Tensor, min: clika_rt_scalar_or_tensor, max: clika_rt_scalar_or_tensor) -> Result<()>
fn op_clamp_inplace(self, self_: &Tensor, min: clika_rt_scalar_or_tensor, max: clika_rt_scalar_or_tensor)
Wraps api-table member op_clamp_inplace.
ClikaRT::ops::clamp_ <- ClikaRT/compute/ops.h
op_clamp_max / f_op_clamp_max
fn f_op_clamp_max(self, x: Tensor, max: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_clamp_max(self, x: Tensor, max: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_clamp_max.
ClikaRT::ops::clamp_max <- ClikaRT/compute/ops.h
op_clamp_max_inplace / f_op_clamp_max_inplace
fn f_op_clamp_max_inplace(self, self_: &Tensor, max: clika_rt_scalar_or_tensor) -> Result<()>
fn op_clamp_max_inplace(self, self_: &Tensor, max: clika_rt_scalar_or_tensor)
Wraps api-table member op_clamp_max_inplace.
ClikaRT::ops::clamp_max_ <- ClikaRT/compute/ops.h
op_clamp_min / f_op_clamp_min
fn f_op_clamp_min(self, x: Tensor, min: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_clamp_min(self, x: Tensor, min: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_clamp_min.
ClikaRT::ops::clamp_min <- ClikaRT/compute/ops.h
op_clamp_min_inplace / f_op_clamp_min_inplace
fn f_op_clamp_min_inplace(self, self_: &Tensor, min: clika_rt_scalar_or_tensor) -> Result<()>
fn op_clamp_min_inplace(self, self_: &Tensor, min: clika_rt_scalar_or_tensor)
Wraps api-table member op_clamp_min_inplace.
ClikaRT::ops::clamp_min_ <- ClikaRT/compute/ops.h
op_clone / f_op_clone
fn f_op_clone(self, src: Tensor) -> Result<Tensor>
fn op_clone(self, src: Tensor) -> Tensor
Wraps api-table member op_clone.
ClikaRT::ops::clone <- ClikaRT/compute/ops.h
op_concat / f_op_concat
fn f_op_concat(self, tensors: &[&Tensor], dim: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_concat(self, tensors: &[&Tensor], dim: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_concat.
ClikaRT::ops::concat <- ClikaRT/compute/ops.h
op_constant_pad / f_op_constant_pad
fn f_op_constant_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor], value: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_constant_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor], value: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_constant_pad.
ClikaRT::ops::constant_pad <- ClikaRT/compute/ops.h
op_contiguous / f_op_contiguous
fn f_op_contiguous(self, x: Tensor, force_copy: bool) -> Result<Tensor>
fn op_contiguous(self, x: Tensor, force_copy: bool) -> Tensor
Wraps api-table member op_contiguous.
ClikaRT::ops::contiguous <- ClikaRT/compute/ops.h
op_conv / f_op_conv
fn f_op_conv(self, x: Tensor, 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 op_conv(self, x: Tensor, 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
Wraps api-table member op_conv.
ClikaRT::ops::conv <- ClikaRT/compute/ops.h
op_conv1d / f_op_conv1d
fn f_op_conv1d(self, x: Tensor, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_conv1d(self, x: Tensor, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_conv1d.
ClikaRT::ops::conv1d <- ClikaRT/compute/ops.h
op_conv2d / f_op_conv2d
fn f_op_conv2d(self, x: Tensor, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_conv2d(self, x: Tensor, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_conv2d.
ClikaRT::ops::conv2d <- ClikaRT/compute/ops.h
op_conv3d / f_op_conv3d
fn f_op_conv3d(self, x: Tensor, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_conv3d(self, x: Tensor, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_conv3d.
ClikaRT::ops::conv3d <- ClikaRT/compute/ops.h
op_conv_transpose / f_op_conv_transpose
fn f_op_conv_transpose(self, x: Tensor, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], groups: i64, dilation: &[i64], activation: clika_rt_activation) -> Result<Tensor>
fn op_conv_transpose(self, x: Tensor, weight: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], groups: i64, dilation: &[i64], activation: clika_rt_activation) -> Tensor
Wraps api-table member op_conv_transpose.
ClikaRT::ops::conv_transpose <- ClikaRT/compute/ops.h
op_conv_transpose1d / f_op_conv_transpose1d
fn f_op_conv_transpose1d(self, x: Tensor, weight: Tensor, bias: Tensor, options: &ConvTranspose1dOptions) -> Result<Tensor>
fn op_conv_transpose1d(self, x: Tensor, weight: Tensor, bias: Tensor, options: &ConvTranspose1dOptions) -> Tensor
Wraps api-table member op_conv_transpose1d.
ClikaRT::ops::conv_transpose1d <- ClikaRT/compute/ops.h
op_conv_transpose2d / f_op_conv_transpose2d
fn f_op_conv_transpose2d(self, x: Tensor, weight: Tensor, bias: Tensor, options: &ConvTranspose2dOptions) -> Result<Tensor>
fn op_conv_transpose2d(self, x: Tensor, weight: Tensor, bias: Tensor, options: &ConvTranspose2dOptions) -> Tensor
Wraps api-table member op_conv_transpose2d.
ClikaRT::ops::conv_transpose2d <- ClikaRT/compute/ops.h
op_conv_transpose3d / f_op_conv_transpose3d
fn f_op_conv_transpose3d(self, x: Tensor, weight: Tensor, bias: Tensor, options: &ConvTranspose3dOptions) -> Result<Tensor>
fn op_conv_transpose3d(self, x: Tensor, weight: Tensor, bias: Tensor, options: &ConvTranspose3dOptions) -> Tensor
Wraps api-table member op_conv_transpose3d.
ClikaRT::ops::conv_transpose3d <- ClikaRT/compute/ops.h
op_copy / f_op_copy
fn f_op_copy(self, src: Tensor, target: clika_rt_stream_or_device, force_copy: bool) -> Result<Tensor>
fn op_copy(self, src: Tensor, target: clika_rt_stream_or_device, force_copy: bool) -> Tensor
Wraps api-table member op_copy.
ClikaRT::ops::copy <- ClikaRT/compute/ops.h
op_copy_inplace / f_op_copy_inplace
fn f_op_copy_inplace(self, self_: &Tensor, src: Tensor, target: clika_rt_stream_or_device) -> Result<()>
fn op_copy_inplace(self, self_: &Tensor, src: Tensor, target: clika_rt_stream_or_device)
Wraps api-table member op_copy_inplace.
ClikaRT::ops::copy_ <- ClikaRT/compute/ops.h
op_copy_into / f_op_copy_into
fn f_op_copy_into(self, out: &Tensor, src: Tensor, target: clika_rt_stream_or_device) -> Result<()>
fn op_copy_into(self, out: &Tensor, src: Tensor, target: clika_rt_stream_or_device)
Wraps api-table member op_copy_into.
ClikaRT::ops::copy_into <- ClikaRT/compute/ops.h
op_copy_to_cpu / f_op_copy_to_cpu
fn f_op_copy_to_cpu(self, src: Tensor) -> Result<Tensor>
fn op_copy_to_cpu(self, src: Tensor) -> Tensor
Wraps api-table member op_copy_to_cpu.
ClikaRT::ops::copy_to_cpu <- ClikaRT/compute/ops.h
op_copysign / f_op_copysign
fn f_op_copysign(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_copysign(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_copysign.
ClikaRT::ops::copysign <- ClikaRT/compute/ops.h
op_copysign_inplace / f_op_copysign_inplace
fn f_op_copysign_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_copysign_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_copysign_inplace.
ClikaRT::ops::copysign_ <- ClikaRT/compute/ops.h
op_cos / f_op_cos
fn f_op_cos(self, x: Tensor) -> Result<Tensor>
fn op_cos(self, x: Tensor) -> Tensor
Wraps api-table member op_cos.
ClikaRT::ops::cos <- ClikaRT/compute/ops.h
op_cos_inplace / f_op_cos_inplace
fn f_op_cos_inplace(self, self_: &Tensor) -> Result<()>
fn op_cos_inplace(self, self_: &Tensor)
Wraps api-table member op_cos_inplace.
ClikaRT::ops::cos_ <- ClikaRT/compute/ops.h
op_cosh / f_op_cosh
fn f_op_cosh(self, x: Tensor) -> Result<Tensor>
fn op_cosh(self, x: Tensor) -> Tensor
Wraps api-table member op_cosh.
ClikaRT::ops::cosh <- ClikaRT/compute/ops.h
op_cosh_inplace / f_op_cosh_inplace
fn f_op_cosh_inplace(self, self_: &Tensor) -> Result<()>
fn op_cosh_inplace(self, self_: &Tensor)
Wraps api-table member op_cosh_inplace.
ClikaRT::ops::cosh_ <- ClikaRT/compute/ops.h
op_cosine_similarity / f_op_cosine_similarity
fn f_op_cosine_similarity(self, a: Tensor, b: Tensor, dim: i64, eps_has: bool, eps: f64) -> Result<Tensor>
fn op_cosine_similarity(self, a: Tensor, b: Tensor, dim: i64, eps_has: bool, eps: f64) -> Tensor
Wraps api-table member op_cosine_similarity.
ClikaRT::ops::cosine_similarity <- ClikaRT/compute/ops.h
op_count_nonzero / f_op_count_nonzero
fn f_op_count_nonzero(self, x: Tensor, dims: &[i64]) -> Result<Tensor>
fn op_count_nonzero(self, x: Tensor, dims: &[i64]) -> Tensor
Wraps api-table member op_count_nonzero.
ClikaRT::ops::count_nonzero <- ClikaRT/compute/ops.h
op_cross / f_op_cross
fn f_op_cross(self, a: Tensor, b: Tensor, dim_has: bool, dim: i64) -> Result<Tensor>
fn op_cross(self, a: Tensor, b: Tensor, dim_has: bool, dim: i64) -> Tensor
Wraps api-table member op_cross.
ClikaRT::ops::cross <- ClikaRT/compute/ops.h
op_cross_entropy / f_op_cross_entropy
fn f_op_cross_entropy(self, input: Tensor, target: Tensor, weight: Tensor, ignore_index_has: bool, ignore_index: i64, reduction: clika_rt_reduction) -> Result<Tensor>
fn op_cross_entropy(self, input: Tensor, target: Tensor, weight: Tensor, ignore_index_has: bool, ignore_index: i64, reduction: clika_rt_reduction) -> Tensor
Wraps api-table member op_cross_entropy.
ClikaRT::ops::cross_entropy <- ClikaRT/compute/ops.h
op_cummax / f_op_cummax
fn f_op_cummax(self, x: Tensor, dim: i64) -> Result<(Tensor, Tensor)>
fn op_cummax(self, x: Tensor, dim: i64) -> (Tensor, Tensor)
Wraps api-table member op_cummax.
ClikaRT::ops::cummax <- ClikaRT/compute/ops.h
op_cummin / f_op_cummin
fn f_op_cummin(self, x: Tensor, dim: i64) -> Result<(Tensor, Tensor)>
fn op_cummin(self, x: Tensor, dim: i64) -> (Tensor, Tensor)
Wraps api-table member op_cummin.
ClikaRT::ops::cummin <- ClikaRT/compute/ops.h
op_cumprod / f_op_cumprod
fn f_op_cumprod(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn op_cumprod(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_cumprod.
ClikaRT::ops::cumprod <- ClikaRT/compute/ops.h
op_cumprod_inplace / f_op_cumprod_inplace
fn f_op_cumprod_inplace(self, self_: &Tensor, dim: i64, dtype: clika_rt_data_type) -> Result<()>
fn op_cumprod_inplace(self, self_: &Tensor, dim: i64, dtype: clika_rt_data_type)
Wraps api-table member op_cumprod_inplace.
ClikaRT::ops::cumprod_ <- ClikaRT/compute/ops.h
op_cumsum / f_op_cumsum
fn f_op_cumsum(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn op_cumsum(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_cumsum.
ClikaRT::ops::cumsum <- ClikaRT/compute/ops.h
op_cumsum_inplace / f_op_cumsum_inplace
fn f_op_cumsum_inplace(self, self_: &Tensor, dim: i64, dtype: clika_rt_data_type) -> Result<()>
fn op_cumsum_inplace(self, self_: &Tensor, dim: i64, dtype: clika_rt_data_type)
Wraps api-table member op_cumsum_inplace.
ClikaRT::ops::cumsum_ <- ClikaRT/compute/ops.h
op_deform_conv / f_op_deform_conv
fn f_op_deform_conv(self, x: Tensor, weight: Tensor, offset: Tensor, mask: Tensor, bias: Tensor, options: &DeformConvOptions) -> Result<Tensor>
fn op_deform_conv(self, x: Tensor, weight: Tensor, offset: Tensor, mask: Tensor, bias: Tensor, options: &DeformConvOptions) -> Tensor
Wraps api-table member op_deform_conv.
ClikaRT::ops::deform_conv <- ClikaRT/compute/ops.h
op_deg2rad / f_op_deg2rad
fn f_op_deg2rad(self, x: Tensor) -> Result<Tensor>
fn op_deg2rad(self, x: Tensor) -> Tensor
Wraps api-table member op_deg2rad.
ClikaRT::ops::deg2rad <- ClikaRT/compute/ops.h
op_deg2rad_inplace / f_op_deg2rad_inplace
fn f_op_deg2rad_inplace(self, self_: &Tensor) -> Result<()>
fn op_deg2rad_inplace(self, self_: &Tensor)
Wraps api-table member op_deg2rad_inplace.
ClikaRT::ops::deg2rad_ <- ClikaRT/compute/ops.h
op_dequantize / f_op_dequantize
fn f_op_dequantize(self, x: QTensor, target_dtype: clika_rt_data_type) -> Result<Tensor>
fn op_dequantize(self, x: QTensor, target_dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_dequantize.
ClikaRT::ops::dequantize <- ClikaRT/compute/q_tensor.h
op_dequantize_inplace / f_op_dequantize_inplace
fn f_op_dequantize_inplace(self, x: QTensor, out: &Tensor) -> Result<()>
fn op_dequantize_inplace(self, x: QTensor, out: &Tensor)
Wraps api-table member op_dequantize_inplace.
ClikaRT::ops::dequantize_ <- ClikaRT/compute/q_tensor.h
op_diag / f_op_diag
fn f_op_diag(self, x: Tensor, diagonal: i64) -> Result<Tensor>
fn op_diag(self, x: Tensor, diagonal: i64) -> Tensor
Wraps api-table member op_diag.
ClikaRT::ops::diag <- ClikaRT/compute/ops.h
op_diag_embed / f_op_diag_embed
fn f_op_diag_embed(self, x: Tensor, offset: i64, dim1: i64, dim2: i64) -> Result<Tensor>
fn op_diag_embed(self, x: Tensor, offset: i64, dim1: i64, dim2: i64) -> Tensor
Wraps api-table member op_diag_embed.
ClikaRT::ops::diag_embed <- ClikaRT/compute/ops.h
op_diagonal / f_op_diagonal
fn f_op_diagonal(self, x: Tensor, offset: i64, dim1: i64, dim2: i64) -> Result<Tensor>
fn op_diagonal(self, x: Tensor, offset: i64, dim1: i64, dim2: i64) -> Tensor
Wraps api-table member op_diagonal.
ClikaRT::ops::diagonal <- ClikaRT/compute/ops.h
op_diff / f_op_diff
fn f_op_diff(self, x: Tensor, n: i64, dim: i64, prepend: Tensor, append: Tensor) -> Result<Tensor>
fn op_diff(self, x: Tensor, n: i64, dim: i64, prepend: Tensor, append: Tensor) -> Tensor
Wraps api-table member op_diff.
ClikaRT::ops::diff <- ClikaRT/compute/ops.h
op_div_inplace / f_op_div_inplace
fn f_op_div_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation) -> Result<()>
fn op_div_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation)
Wraps api-table member op_div_inplace.
ClikaRT::ops::div_ <- ClikaRT/compute/ops.h
op_div_scalar_lhs / f_op_div_scalar_lhs
fn f_op_div_scalar_lhs(self, a: clika_rt_scalar, b: Tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation) -> Result<Tensor>
fn op_div_scalar_lhs(self, a: clika_rt_scalar, b: Tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_div_scalar_lhs.
ClikaRT::ops::div <- ClikaRT/compute/ops.h
op_div_tensor / f_op_div_tensor
fn f_op_div_tensor(self, a: Tensor, other: clika_rt_scalar_or_tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation) -> Result<Tensor>
fn op_div_tensor(self, a: Tensor, other: clika_rt_scalar_or_tensor, rounding_mode: clika_rt_rounding_mode, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_div_tensor.
ClikaRT::ops::div <- ClikaRT/compute/ops.h
op_dot / f_op_dot
fn f_op_dot(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_dot(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_dot.
ClikaRT::ops::dot <- ClikaRT/compute/ops.h
op_dynamic_quantize / f_op_dynamic_quantize
fn f_op_dynamic_quantize(self, x: Tensor) -> Result<(Tensor, Tensor, Tensor)>
fn op_dynamic_quantize(self, x: Tensor) -> (Tensor, Tensor, Tensor)
Wraps api-table member op_dynamic_quantize.
ClikaRT::ops::dynamic_quantize <- ClikaRT/compute/q_tensor.h
op_einsum / f_op_einsum
fn f_op_einsum(self, equation: &str, operands: &[&Tensor]) -> Result<Tensor>
fn op_einsum(self, equation: &str, operands: &[&Tensor]) -> Tensor
Wraps api-table member op_einsum.
ClikaRT::ops::einsum <- ClikaRT/compute/ops.h
op_elu / f_op_elu
fn f_op_elu(self, x: Tensor, alpha: f64, scale: f64, input_scale: f64) -> Result<Tensor>
fn op_elu(self, x: Tensor, alpha: f64, scale: f64, input_scale: f64) -> Tensor
Wraps api-table member op_elu.
ClikaRT::ops::elu <- ClikaRT/compute/ops.h
op_elu_inplace / f_op_elu_inplace
fn f_op_elu_inplace(self, self_: &Tensor, alpha: f64, scale: f64, input_scale: f64) -> Result<()>
fn op_elu_inplace(self, self_: &Tensor, alpha: f64, scale: f64, input_scale: f64)
Wraps api-table member op_elu_inplace.
ClikaRT::ops::elu_ <- ClikaRT/compute/ops.h
op_embedding / f_op_embedding
fn f_op_embedding(self, indices: Tensor, weight: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn op_embedding(self, indices: Tensor, weight: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_embedding.
ClikaRT::ops::embedding <- ClikaRT/compute/ops.h
op_empty / f_op_empty
fn f_op_empty(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device, pinned_for: clika_rt_stream_or_device) -> Result<Tensor>
fn op_empty(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device, pinned_for: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_empty.
ClikaRT::ops::empty <- ClikaRT/compute/ops.h
op_empty_like / f_op_empty_like
fn f_op_empty_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_empty_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_empty_like.
ClikaRT::ops::empty_like <- ClikaRT/compute/ops.h
op_empty_strided / f_op_empty_strided
fn f_op_empty_strided(self, size: &[i64], stride: &[i64], dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_empty_strided(self, size: &[i64], stride: &[i64], dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_empty_strided.
ClikaRT::ops::empty_strided <- ClikaRT/compute/ops.h
op_eq / f_op_eq
fn f_op_eq(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_eq(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_eq.
ClikaRT::ops::eq <- ClikaRT/compute/ops.h
op_eq_inplace / f_op_eq_inplace
fn f_op_eq_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_eq_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_eq_inplace.
ClikaRT::ops::eq_ <- ClikaRT/compute/ops.h
op_erf / f_op_erf
fn f_op_erf(self, x: Tensor) -> Result<Tensor>
fn op_erf(self, x: Tensor) -> Tensor
Wraps api-table member op_erf.
ClikaRT::ops::erf <- ClikaRT/compute/ops.h
op_erf_inplace / f_op_erf_inplace
fn f_op_erf_inplace(self, self_: &Tensor) -> Result<()>
fn op_erf_inplace(self, self_: &Tensor)
Wraps api-table member op_erf_inplace.
ClikaRT::ops::erf_ <- ClikaRT/compute/ops.h
op_erfc / f_op_erfc
fn f_op_erfc(self, x: Tensor) -> Result<Tensor>
fn op_erfc(self, x: Tensor) -> Tensor
Wraps api-table member op_erfc.
ClikaRT::ops::erfc <- ClikaRT/compute/ops.h
op_erfc_inplace / f_op_erfc_inplace
fn f_op_erfc_inplace(self, self_: &Tensor) -> Result<()>
fn op_erfc_inplace(self, self_: &Tensor)
Wraps api-table member op_erfc_inplace.
ClikaRT::ops::erfc_ <- ClikaRT/compute/ops.h
op_erfinv / f_op_erfinv
fn f_op_erfinv(self, x: Tensor) -> Result<Tensor>
fn op_erfinv(self, x: Tensor) -> Tensor
Wraps api-table member op_erfinv.
ClikaRT::ops::erfinv <- ClikaRT/compute/ops.h
op_erfinv_inplace / f_op_erfinv_inplace
fn f_op_erfinv_inplace(self, self_: &Tensor) -> Result<()>
fn op_erfinv_inplace(self, self_: &Tensor)
Wraps api-table member op_erfinv_inplace.
ClikaRT::ops::erfinv_ <- ClikaRT/compute/ops.h
op_exp / f_op_exp
fn f_op_exp(self, x: Tensor) -> Result<Tensor>
fn op_exp(self, x: Tensor) -> Tensor
Wraps api-table member op_exp.
ClikaRT::ops::exp <- ClikaRT/compute/ops.h
op_exp_inplace / f_op_exp_inplace
fn f_op_exp_inplace(self, self_: &Tensor) -> Result<()>
fn op_exp_inplace(self, self_: &Tensor)
Wraps api-table member op_exp_inplace.
ClikaRT::ops::exp_ <- ClikaRT/compute/ops.h
op_expand / f_op_expand
fn f_op_expand(self, x: Tensor, shape: &[clika_rt_scalar_or_tensor], bidirectional: bool) -> Result<Tensor>
fn op_expand(self, x: Tensor, shape: &[clika_rt_scalar_or_tensor], bidirectional: bool) -> Tensor
Wraps api-table member op_expand.
ClikaRT::ops::expand <- ClikaRT/compute/ops.h
op_expand_as / f_op_expand_as
fn f_op_expand_as(self, x: Tensor, other: Tensor) -> Result<Tensor>
fn op_expand_as(self, x: Tensor, other: Tensor) -> Tensor
Wraps api-table member op_expand_as.
ClikaRT::ops::expand_as <- ClikaRT/compute/ops.h
op_exponential_inplace / f_op_exponential_inplace
fn f_op_exponential_inplace(self, self_: &Tensor, lambd: f64, s: clika_rt_stream_or_device) -> Result<()>
fn op_exponential_inplace(self, self_: &Tensor, lambd: f64, s: clika_rt_stream_or_device)
Wraps api-table member op_exponential_inplace.
ClikaRT::ops::exponential_ <- ClikaRT/compute/ops.h
op_eye / f_op_eye
fn f_op_eye(self, n: clika_rt_scalar_or_tensor, m: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_eye(self, n: clika_rt_scalar_or_tensor, m: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_eye.
ClikaRT::ops::eye <- ClikaRT/compute/ops.h
op_fast_gelu / f_op_fast_gelu
fn f_op_fast_gelu(self, x: Tensor) -> Result<Tensor>
fn op_fast_gelu(self, x: Tensor) -> Tensor
Wraps api-table member op_fast_gelu.
ClikaRT::ops::fast_gelu <- ClikaRT/compute/ops.h
op_fill / f_op_fill
fn f_op_fill(self, x: Tensor, value: clika_rt_scalar_or_tensor, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_fill(self, x: Tensor, value: clika_rt_scalar_or_tensor, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_fill.
ClikaRT::ops::fill <- ClikaRT/compute/ops.h
op_fill_diagonal / f_op_fill_diagonal
fn f_op_fill_diagonal(self, x: Tensor, fill_value: clika_rt_scalar, wrap: bool, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_fill_diagonal(self, x: Tensor, fill_value: clika_rt_scalar, wrap: bool, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_fill_diagonal.
ClikaRT::ops::fill_diagonal <- ClikaRT/compute/ops.h
op_fill_diagonal_inplace / f_op_fill_diagonal_inplace
fn f_op_fill_diagonal_inplace(self, self_: &Tensor, fill_value: clika_rt_scalar, wrap: bool, s: clika_rt_stream_or_device) -> Result<()>
fn op_fill_diagonal_inplace(self, self_: &Tensor, fill_value: clika_rt_scalar, wrap: bool, s: clika_rt_stream_or_device)
Wraps api-table member op_fill_diagonal_inplace.
ClikaRT::ops::fill_diagonal_ <- ClikaRT/compute/ops.h
op_fill_inplace / f_op_fill_inplace
fn f_op_fill_inplace(self, self_: &Tensor, value: clika_rt_scalar_or_tensor, s: clika_rt_stream_or_device) -> Result<()>
fn op_fill_inplace(self, self_: &Tensor, value: clika_rt_scalar_or_tensor, s: clika_rt_stream_or_device)
Wraps api-table member op_fill_inplace.
ClikaRT::ops::fill_ <- ClikaRT/compute/ops.h
op_flatten / f_op_flatten
fn f_op_flatten(self, x: Tensor, start_dim: i64, end_dim: i64) -> Result<Tensor>
fn op_flatten(self, x: Tensor, start_dim: i64, end_dim: i64) -> Tensor
Wraps api-table member op_flatten.
ClikaRT::ops::flatten <- ClikaRT/compute/ops.h
op_flip / f_op_flip
fn f_op_flip(self, x: Tensor, dims: &[i64]) -> Result<Tensor>
fn op_flip(self, x: Tensor, dims: &[i64]) -> Tensor
Wraps api-table member op_flip.
ClikaRT::ops::flip <- ClikaRT/compute/ops.h
op_fliplr / f_op_fliplr
fn f_op_fliplr(self, x: Tensor) -> Result<Tensor>
fn op_fliplr(self, x: Tensor) -> Tensor
Wraps api-table member op_fliplr.
ClikaRT::ops::fliplr <- ClikaRT/compute/ops.h
op_flipud / f_op_flipud
fn f_op_flipud(self, x: Tensor) -> Result<Tensor>
fn op_flipud(self, x: Tensor) -> Tensor
Wraps api-table member op_flipud.
ClikaRT::ops::flipud <- ClikaRT/compute/ops.h
op_floor / f_op_floor
fn f_op_floor(self, x: Tensor) -> Result<Tensor>
fn op_floor(self, x: Tensor) -> Tensor
Wraps api-table member op_floor.
ClikaRT::ops::floor <- ClikaRT/compute/ops.h
op_floor_divide / f_op_floor_divide
fn f_op_floor_divide(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_floor_divide(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_floor_divide.
ClikaRT::ops::floor_divide <- ClikaRT/compute/ops.h
op_floor_divide_inplace / f_op_floor_divide_inplace
fn f_op_floor_divide_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_floor_divide_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_floor_divide_inplace.
ClikaRT::ops::floor_divide_ <- ClikaRT/compute/ops.h
op_floor_inplace / f_op_floor_inplace
fn f_op_floor_inplace(self, self_: &Tensor) -> Result<()>
fn op_floor_inplace(self, self_: &Tensor)
Wraps api-table member op_floor_inplace.
ClikaRT::ops::floor_ <- ClikaRT/compute/ops.h
op_fmax / f_op_fmax
fn f_op_fmax(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_fmax(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_fmax.
ClikaRT::ops::fmax <- ClikaRT/compute/ops.h
op_fmin / f_op_fmin
fn f_op_fmin(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_fmin(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_fmin.
ClikaRT::ops::fmin <- ClikaRT/compute/ops.h
op_fmod / f_op_fmod
fn f_op_fmod(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_fmod(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_fmod.
ClikaRT::ops::fmod <- ClikaRT/compute/ops.h
op_fmod_inplace / f_op_fmod_inplace
fn f_op_fmod_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_fmod_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_fmod_inplace.
ClikaRT::ops::fmod_ <- ClikaRT/compute/ops.h
op_fold / f_op_fold
fn f_op_fold(self, x: Tensor, 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 op_fold(self, x: Tensor, output_size: &[i64], kernel_size: &[i64], dilation: &[i64], padding: &[i64], stride: &[i64], mode: clika_rt_pad_mode, value_has: bool, value: f64) -> Tensor
Wraps api-table member op_fold.
ClikaRT::ops::fold <- ClikaRT/compute/ops.h
op_frac / f_op_frac
fn f_op_frac(self, x: Tensor) -> Result<Tensor>
fn op_frac(self, x: Tensor) -> Tensor
Wraps api-table member op_frac.
ClikaRT::ops::frac <- ClikaRT/compute/ops.h
op_frac_inplace / f_op_frac_inplace
fn f_op_frac_inplace(self, self_: &Tensor) -> Result<()>
fn op_frac_inplace(self, self_: &Tensor)
Wraps api-table member op_frac_inplace.
ClikaRT::ops::frac_ <- ClikaRT/compute/ops.h
op_frexp / f_op_frexp
fn f_op_frexp(self, x: Tensor) -> Result<(Tensor, Tensor)>
fn op_frexp(self, x: Tensor) -> (Tensor, Tensor)
Wraps api-table member op_frexp.
ClikaRT::ops::frexp <- ClikaRT/compute/ops.h
op_from_blob / f_op_from_blob
fn f_op_from_blob(self, data: *mut c_void, shape: &[i64], dtype: clika_rt_data_type, s: clika_rt_stream_or_device, strides: &[i64], deleter: Option<VoidCallback>, pinned_for: clika_rt_stream_or_device) -> Result<Tensor>
fn op_from_blob(self, data: *mut c_void, shape: &[i64], dtype: clika_rt_data_type, s: clika_rt_stream_or_device, strides: &[i64], deleter: Option<VoidCallback>, pinned_for: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_from_blob.
ClikaRT::ops::from_blob <- ClikaRT/compute/ops.h
op_full / f_op_full
fn f_op_full(self, shape: &[clika_rt_scalar_or_tensor], fill_value: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device, pinned_for: clika_rt_stream_or_device) -> Result<Tensor>
fn op_full(self, shape: &[clika_rt_scalar_or_tensor], fill_value: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device, pinned_for: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_full.
ClikaRT::ops::full <- ClikaRT/compute/ops.h
op_full_like / f_op_full_like
fn f_op_full_like(self, reference: Tensor, fill_value: clika_rt_scalar_or_tensor, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_full_like(self, reference: Tensor, fill_value: clika_rt_scalar_or_tensor, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_full_like.
ClikaRT::ops::full_like <- ClikaRT/compute/ops.h
op_gated_delta_update / f_op_gated_delta_update
fn f_op_gated_delta_update(self, q: Tensor, k: Tensor, v: Tensor, beta: Tensor, g: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, scale_has: bool, scale: f64, gate_bias: Tensor, gate_scale: Tensor) -> Result<Tensor>
fn op_gated_delta_update(self, q: Tensor, k: Tensor, v: Tensor, beta: Tensor, g: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, scale_has: bool, scale: f64, gate_bias: Tensor, gate_scale: Tensor) -> Tensor
Wraps api-table member op_gated_delta_update.
ClikaRT::ops::gated_delta_update <- ClikaRT/compute/ops.h
op_gated_rms_norm / f_op_gated_rms_norm
fn f_op_gated_rms_norm(self, x: Tensor, z: Tensor, normalized_shape: &[i64], weight: Tensor, eps_has: bool, eps: f64) -> Result<Tensor>
fn op_gated_rms_norm(self, x: Tensor, z: Tensor, normalized_shape: &[i64], weight: Tensor, eps_has: bool, eps: f64) -> Tensor
Wraps api-table member op_gated_rms_norm.
ClikaRT::ops::gated_rms_norm <- ClikaRT/compute/ops.h
op_gather / f_op_gather
fn f_op_gather(self, x: Tensor, dim: i64, index: Tensor) -> Result<Tensor>
fn op_gather(self, x: Tensor, dim: i64, index: Tensor) -> Tensor
Wraps api-table member op_gather.
ClikaRT::ops::gather <- ClikaRT/compute/ops.h
op_ge / f_op_ge
fn f_op_ge(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_ge(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_ge.
ClikaRT::ops::ge <- ClikaRT/compute/ops.h
op_ge_inplace / f_op_ge_inplace
fn f_op_ge_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_ge_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_ge_inplace.
ClikaRT::ops::ge_ <- ClikaRT/compute/ops.h
op_geglu / f_op_geglu
fn f_op_geglu(self, x: Tensor, approximate: clika_rt_gelu_mode) -> Result<Tensor>
fn op_geglu(self, x: Tensor, approximate: clika_rt_gelu_mode) -> Tensor
Wraps api-table member op_geglu.
ClikaRT::ops::geglu <- ClikaRT/compute/ops.h
op_gelu / f_op_gelu
fn f_op_gelu(self, x: Tensor, approximate: clika_rt_gelu_mode) -> Result<Tensor>
fn op_gelu(self, x: Tensor, approximate: clika_rt_gelu_mode) -> Tensor
Wraps api-table member op_gelu.
ClikaRT::ops::gelu <- ClikaRT/compute/ops.h
op_gelu_inplace / f_op_gelu_inplace
fn f_op_gelu_inplace(self, self_: &Tensor, approximate: clika_rt_gelu_mode) -> Result<()>
fn op_gelu_inplace(self, self_: &Tensor, approximate: clika_rt_gelu_mode)
Wraps api-table member op_gelu_inplace.
ClikaRT::ops::gelu_ <- ClikaRT/compute/ops.h
op_generate_rotary_cache / f_op_generate_rotary_cache
fn f_op_generate_rotary_cache(self, rotary_dim: i64, max_positions: i64, freq_factors: Tensor, s: clika_rt_stream_or_device, options: &GenerateRotaryCacheOptions) -> Result<(Tensor, Tensor)>
fn op_generate_rotary_cache(self, rotary_dim: i64, max_positions: i64, freq_factors: Tensor, s: clika_rt_stream_or_device, options: &GenerateRotaryCacheOptions) -> (Tensor, Tensor)
Wraps api-table member op_generate_rotary_cache.
ClikaRT::ops::generate_rotary_cache <- ClikaRT/compute/ops.h
op_glu / f_op_glu
fn f_op_glu(self, x: Tensor, dim: i64) -> Result<Tensor>
fn op_glu(self, x: Tensor, dim: i64) -> Tensor
Wraps api-table member op_glu.
ClikaRT::ops::glu <- ClikaRT/compute/ops.h
op_grid_sample / f_op_grid_sample
fn f_op_grid_sample(self, x: Tensor, grid: Tensor, mode: clika_rt_grid_sample_mode, padding_mode: clika_rt_grid_sample_padding_mode, align_corners: bool) -> Result<Tensor>
fn op_grid_sample(self, x: Tensor, grid: Tensor, mode: clika_rt_grid_sample_mode, padding_mode: clika_rt_grid_sample_padding_mode, align_corners: bool) -> Tensor
Wraps api-table member op_grid_sample.
ClikaRT::ops::grid_sample <- ClikaRT/compute/ops.h
op_group_norm / f_op_group_norm
fn f_op_group_norm(self, x: Tensor, 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 op_group_norm(self, x: Tensor, 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
Wraps api-table member op_group_norm.
ClikaRT::ops::group_norm <- ClikaRT/compute/ops.h
op_group_query_attention / f_op_group_query_attention
fn f_op_group_query_attention(self, q: Tensor, k: Tensor, v: Tensor, past_key: Tensor, past_value: Tensor, kvcache_start: Tensor, rope_cos: Tensor, rope_sin: Tensor, position_ids: Tensor, attn_mask: Tensor, q_scale: clika_rt_scalar_or_tensor, out_present_key: Tensor, out_present_value: Tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, head_sink: Tensor, q_norm_gain: Tensor, k_norm_gain: Tensor, slot_ids: Tensor, options: &GroupQueryAttentionOptions) -> Result<(Tensor, Tensor, Tensor)>
fn op_group_query_attention(self, q: Tensor, k: Tensor, v: Tensor, past_key: Tensor, past_value: Tensor, kvcache_start: Tensor, rope_cos: Tensor, rope_sin: Tensor, position_ids: Tensor, attn_mask: Tensor, q_scale: clika_rt_scalar_or_tensor, out_present_key: Tensor, out_present_value: Tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, head_sink: Tensor, q_norm_gain: Tensor, k_norm_gain: Tensor, slot_ids: Tensor, options: &GroupQueryAttentionOptions) -> (Tensor, Tensor, Tensor)
Wraps api-table member op_group_query_attention.
ClikaRT::ops::group_query_attention <- ClikaRT/compute/ops.h
op_group_query_attention_varlen / f_op_group_query_attention_varlen
fn f_op_group_query_attention_varlen(self, q: Tensor, k: Tensor, v: Tensor, cu_seqlens_q: Tensor, cu_seqlens_k: Tensor, max_seqlen_q: clika_rt_scalar_or_tensor, max_seqlen_k: clika_rt_scalar_or_tensor, past_key: Tensor, past_value: Tensor, kvcache_start: Tensor, rope_cos: Tensor, rope_sin: Tensor, position_ids: Tensor, attn_mask: Tensor, head_sink: Tensor, q_scale: clika_rt_scalar_or_tensor, out_present_key: Tensor, out_present_value: Tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, q_norm_gain: Tensor, k_norm_gain: Tensor, slot_ids: Tensor, options: &GroupQueryAttentionVarlenOptions) -> Result<(Tensor, Tensor, Tensor)>
fn op_group_query_attention_varlen(self, q: Tensor, k: Tensor, v: Tensor, cu_seqlens_q: Tensor, cu_seqlens_k: Tensor, max_seqlen_q: clika_rt_scalar_or_tensor, max_seqlen_k: clika_rt_scalar_or_tensor, past_key: Tensor, past_value: Tensor, kvcache_start: Tensor, rope_cos: Tensor, rope_sin: Tensor, position_ids: Tensor, attn_mask: Tensor, head_sink: Tensor, q_scale: clika_rt_scalar_or_tensor, out_present_key: Tensor, out_present_value: Tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor, q_norm_gain: Tensor, k_norm_gain: Tensor, slot_ids: Tensor, options: &GroupQueryAttentionVarlenOptions) -> (Tensor, Tensor, Tensor)
Wraps api-table member op_group_query_attention_varlen.
ClikaRT::ops::group_query_attention_varlen <- ClikaRT/compute/ops.h
op_gt / f_op_gt
fn f_op_gt(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_gt(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_gt.
ClikaRT::ops::gt <- ClikaRT/compute/ops.h
op_gt_inplace / f_op_gt_inplace
fn f_op_gt_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_gt_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_gt_inplace.
ClikaRT::ops::gt_ <- ClikaRT/compute/ops.h
op_hardshrink / f_op_hardshrink
fn f_op_hardshrink(self, x: Tensor, lambd: f64) -> Result<Tensor>
fn op_hardshrink(self, x: Tensor, lambd: f64) -> Tensor
Wraps api-table member op_hardshrink.
ClikaRT::ops::hardshrink <- ClikaRT/compute/ops.h
op_hardshrink_inplace / f_op_hardshrink_inplace
fn f_op_hardshrink_inplace(self, self_: &Tensor, lambd: f64) -> Result<()>
fn op_hardshrink_inplace(self, self_: &Tensor, lambd: f64)
Wraps api-table member op_hardshrink_inplace.
ClikaRT::ops::hardshrink_ <- ClikaRT/compute/ops.h
op_hardsigmoid / f_op_hardsigmoid
fn f_op_hardsigmoid(self, x: Tensor) -> Result<Tensor>
fn op_hardsigmoid(self, x: Tensor) -> Tensor
Wraps api-table member op_hardsigmoid.
ClikaRT::ops::hardsigmoid <- ClikaRT/compute/ops.h
op_hardsigmoid_inplace / f_op_hardsigmoid_inplace
fn f_op_hardsigmoid_inplace(self, self_: &Tensor) -> Result<()>
fn op_hardsigmoid_inplace(self, self_: &Tensor)
Wraps api-table member op_hardsigmoid_inplace.
ClikaRT::ops::hardsigmoid_ <- ClikaRT/compute/ops.h
op_hardswish / f_op_hardswish
fn f_op_hardswish(self, x: Tensor) -> Result<Tensor>
fn op_hardswish(self, x: Tensor) -> Tensor
Wraps api-table member op_hardswish.
ClikaRT::ops::hardswish <- ClikaRT/compute/ops.h
op_hardswish_inplace / f_op_hardswish_inplace
fn f_op_hardswish_inplace(self, self_: &Tensor) -> Result<()>
fn op_hardswish_inplace(self, self_: &Tensor)
Wraps api-table member op_hardswish_inplace.
ClikaRT::ops::hardswish_ <- ClikaRT/compute/ops.h
op_hardtanh / f_op_hardtanh
fn f_op_hardtanh(self, x: Tensor, min_val: f64, max_val: f64) -> Result<Tensor>
fn op_hardtanh(self, x: Tensor, min_val: f64, max_val: f64) -> Tensor
Wraps api-table member op_hardtanh.
ClikaRT::ops::hardtanh <- ClikaRT/compute/ops.h
op_hardtanh_inplace / f_op_hardtanh_inplace
fn f_op_hardtanh_inplace(self, self_: &Tensor, min_val: f64, max_val: f64) -> Result<()>
fn op_hardtanh_inplace(self, self_: &Tensor, min_val: f64, max_val: f64)
Wraps api-table member op_hardtanh_inplace.
ClikaRT::ops::hardtanh_ <- ClikaRT/compute/ops.h
op_hash_128 / f_op_hash_128
fn f_op_hash_128(self, x: Tensor, seed: u64) -> Result<Tensor>
fn op_hash_128(self, x: Tensor, seed: u64) -> Tensor
Wraps api-table member op_hash_128.
ClikaRT::ops::hash_128 <- ClikaRT/compute/ops.h
op_hash_256 / f_op_hash_256
fn f_op_hash_256(self, x: Tensor, seed: u64) -> Result<Tensor>
fn op_hash_256(self, x: Tensor, seed: u64) -> Tensor
Wraps api-table member op_hash_256.
ClikaRT::ops::hash_256 <- ClikaRT/compute/ops.h
op_hash_64 / f_op_hash_64
fn f_op_hash_64(self, x: Tensor, seed: u64) -> Result<Tensor>
fn op_hash_64(self, x: Tensor, seed: u64) -> Tensor
Wraps api-table member op_hash_64.
ClikaRT::ops::hash_64 <- ClikaRT/compute/ops.h
op_hash_chain / f_op_hash_chain
fn f_op_hash_chain(self, rows: Tensor, parent: Tensor, seed: u64) -> Result<Tensor>
fn op_hash_chain(self, rows: Tensor, parent: Tensor, seed: u64) -> Tensor
Wraps api-table member op_hash_chain.
ClikaRT::ops::hash_chain <- ClikaRT/compute/ops.h
op_hash_tensor / f_op_hash_tensor
fn f_op_hash_tensor(self, x: Tensor, dims: &[i64], keepdim: bool, mode: clika_rt_hash_tensor_mode) -> Result<Tensor>
fn op_hash_tensor(self, x: Tensor, dims: &[i64], keepdim: bool, mode: clika_rt_hash_tensor_mode) -> Tensor
Wraps api-table member op_hash_tensor.
ClikaRT::ops::hash_tensor <- ClikaRT/compute/ops.h
op_histogram / f_op_histogram
fn f_op_histogram(self, x: Tensor, bins: i64, range: Tensor, weight: Tensor, density: bool) -> Result<(Tensor, Tensor)>
fn op_histogram(self, x: Tensor, bins: i64, range: Tensor, weight: Tensor, density: bool) -> (Tensor, Tensor)
Wraps api-table member op_histogram.
ClikaRT::ops::histogram <- ClikaRT/compute/ops.h
op_huber_loss / f_op_huber_loss
fn f_op_huber_loss(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction, delta: f64) -> Result<Tensor>
fn op_huber_loss(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction, delta: f64) -> Tensor
Wraps api-table member op_huber_loss.
ClikaRT::ops::huber_loss <- ClikaRT/compute/ops.h
op_hypot / f_op_hypot
fn f_op_hypot(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_hypot(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_hypot.
ClikaRT::ops::hypot <- ClikaRT/compute/ops.h
op_hypot_inplace / f_op_hypot_inplace
fn f_op_hypot_inplace(self, self_: &Tensor, other: Tensor) -> Result<()>
fn op_hypot_inplace(self, self_: &Tensor, other: Tensor)
Wraps api-table member op_hypot_inplace.
ClikaRT::ops::hypot_ <- ClikaRT/compute/ops.h
op_index / f_op_index
fn f_op_index(self, x: Tensor, indices: &[clika_rt_index_entry]) -> Result<Tensor>
fn op_index(self, x: Tensor, indices: &[clika_rt_index_entry]) -> Tensor
Wraps api-table member op_index.
ClikaRT::ops::index <- ClikaRT/compute/ops.h
op_index_add / f_op_index_add
fn f_op_index_add(self, x: Tensor, dim: i64, indices: Tensor, src: Tensor) -> Result<Tensor>
fn op_index_add(self, x: Tensor, dim: i64, indices: Tensor, src: Tensor) -> Tensor
Wraps api-table member op_index_add.
ClikaRT::ops::index_add <- ClikaRT/compute/ops.h
op_index_add_inplace / f_op_index_add_inplace
fn f_op_index_add_inplace(self, self_: &Tensor, dim: i64, indices: Tensor, src: Tensor) -> Result<()>
fn op_index_add_inplace(self, self_: &Tensor, dim: i64, indices: Tensor, src: Tensor)
Wraps api-table member op_index_add_inplace.
ClikaRT::ops::index_add_ <- ClikaRT/compute/ops.h
op_index_copy / f_op_index_copy
fn f_op_index_copy(self, x: Tensor, dim: i64, indices: Tensor, src: Tensor) -> Result<Tensor>
fn op_index_copy(self, x: Tensor, dim: i64, indices: Tensor, src: Tensor) -> Tensor
Wraps api-table member op_index_copy.
ClikaRT::ops::index_copy <- ClikaRT/compute/ops.h
op_index_copy_inplace / f_op_index_copy_inplace
fn f_op_index_copy_inplace(self, self_: &Tensor, dim: i64, indices: Tensor, src: Tensor) -> Result<()>
fn op_index_copy_inplace(self, self_: &Tensor, dim: i64, indices: Tensor, src: Tensor)
Wraps api-table member op_index_copy_inplace.
ClikaRT::ops::index_copy_ <- ClikaRT/compute/ops.h
op_index_fill / f_op_index_fill
fn f_op_index_fill(self, x: Tensor, dim: i64, indices: Tensor, value: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_index_fill(self, x: Tensor, dim: i64, indices: Tensor, value: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_index_fill.
ClikaRT::ops::index_fill <- ClikaRT/compute/ops.h
op_index_fill_inplace / f_op_index_fill_inplace
fn f_op_index_fill_inplace(self, self_: &Tensor, dim: i64, indices: Tensor, value: clika_rt_scalar_or_tensor) -> Result<()>
fn op_index_fill_inplace(self, self_: &Tensor, dim: i64, indices: Tensor, value: clika_rt_scalar_or_tensor)
Wraps api-table member op_index_fill_inplace.
ClikaRT::ops::index_fill_ <- ClikaRT/compute/ops.h
op_index_put / f_op_index_put
fn f_op_index_put(self, x: Tensor, indices: &[clika_rt_index_entry], value: clika_rt_scalar_or_tensor, accumulate: bool) -> Result<Tensor>
fn op_index_put(self, x: Tensor, indices: &[clika_rt_index_entry], value: clika_rt_scalar_or_tensor, accumulate: bool) -> Tensor
Wraps api-table member op_index_put.
ClikaRT::ops::index_put <- ClikaRT/compute/ops.h
op_index_put_inplace / f_op_index_put_inplace
fn f_op_index_put_inplace(self, self_: &Tensor, indices: &[clika_rt_index_entry], value: clika_rt_scalar_or_tensor, accumulate: bool) -> Result<()>
fn op_index_put_inplace(self, self_: &Tensor, indices: &[clika_rt_index_entry], value: clika_rt_scalar_or_tensor, accumulate: bool)
Wraps api-table member op_index_put_inplace.
ClikaRT::ops::index_put_ <- ClikaRT/compute/ops.h
op_index_select / f_op_index_select
fn f_op_index_select(self, x: Tensor, dim: i64, index: Tensor) -> Result<Tensor>
fn op_index_select(self, x: Tensor, dim: i64, index: Tensor) -> Tensor
Wraps api-table member op_index_select.
ClikaRT::ops::index_select <- ClikaRT/compute/ops.h
op_inner / f_op_inner
fn f_op_inner(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_inner(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_inner.
ClikaRT::ops::inner <- ClikaRT/compute/ops.h
op_instance_norm / f_op_instance_norm
fn f_op_instance_norm(self, x: Tensor, 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 op_instance_norm(self, x: Tensor, weight: Tensor, bias: Tensor, running_mean: Tensor, running_var: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_instance_norm.
ClikaRT::ops::instance_norm <- ClikaRT/compute/ops.h
op_interpolate / f_op_interpolate
fn f_op_interpolate(self, x: Tensor, 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 op_interpolate(self, x: Tensor, 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
Wraps api-table member op_interpolate.
ClikaRT::ops::interpolate <- ClikaRT/compute/ops.h
op_isclose / f_op_isclose
fn f_op_isclose(self, a: Tensor, b: Tensor, rtol: f64, atol: f64, equal_nan: bool) -> Result<Tensor>
fn op_isclose(self, a: Tensor, b: Tensor, rtol: f64, atol: f64, equal_nan: bool) -> Tensor
Wraps api-table member op_isclose.
ClikaRT::ops::isclose <- ClikaRT/compute/ops.h
op_isfinite / f_op_isfinite
fn f_op_isfinite(self, x: Tensor) -> Result<Tensor>
fn op_isfinite(self, x: Tensor) -> Tensor
Wraps api-table member op_isfinite.
ClikaRT::ops::isfinite <- ClikaRT/compute/ops.h
op_isinf / f_op_isinf
fn f_op_isinf(self, x: Tensor) -> Result<Tensor>
fn op_isinf(self, x: Tensor) -> Tensor
Wraps api-table member op_isinf.
ClikaRT::ops::isinf <- ClikaRT/compute/ops.h
op_isnan / f_op_isnan
fn f_op_isnan(self, x: Tensor) -> Result<Tensor>
fn op_isnan(self, x: Tensor) -> Tensor
Wraps api-table member op_isnan.
ClikaRT::ops::isnan <- ClikaRT/compute/ops.h
op_isneginf / f_op_isneginf
fn f_op_isneginf(self, x: Tensor) -> Result<Tensor>
fn op_isneginf(self, x: Tensor) -> Tensor
Wraps api-table member op_isneginf.
ClikaRT::ops::isneginf <- ClikaRT/compute/ops.h
op_isposinf / f_op_isposinf
fn f_op_isposinf(self, x: Tensor) -> Result<Tensor>
fn op_isposinf(self, x: Tensor) -> Tensor
Wraps api-table member op_isposinf.
ClikaRT::ops::isposinf <- ClikaRT/compute/ops.h
op_kl_div / f_op_kl_div
fn f_op_kl_div(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction, log_target: bool) -> Result<Tensor>
fn op_kl_div(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction, log_target: bool) -> Tensor
Wraps api-table member op_kl_div.
ClikaRT::ops::kl_div <- ClikaRT/compute/ops.h
op_kron / f_op_kron
fn f_op_kron(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_kron(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_kron.
ClikaRT::ops::kron <- ClikaRT/compute/ops.h
op_kthvalue / f_op_kthvalue
fn f_op_kthvalue(self, x: Tensor, k: i64, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn op_kthvalue(self, x: Tensor, k: i64, dim: i64, keepdim: bool) -> (Tensor, Tensor)
Wraps api-table member op_kthvalue.
ClikaRT::ops::kthvalue <- ClikaRT/compute/ops.h
op_l1_loss / f_op_l1_loss
fn f_op_l1_loss(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction) -> Result<Tensor>
fn op_l1_loss(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction) -> Tensor
Wraps api-table member op_l1_loss.
ClikaRT::ops::l1_loss <- ClikaRT/compute/ops.h
op_layer_norm / f_op_layer_norm
fn f_op_layer_norm(self, x: Tensor, normalized_shape: &[i64], weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn op_layer_norm(self, x: Tensor, normalized_shape: &[i64], weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_layer_norm.
ClikaRT::ops::layer_norm <- ClikaRT/compute/ops.h
op_le / f_op_le
fn f_op_le(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_le(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_le.
ClikaRT::ops::le <- ClikaRT/compute/ops.h
op_le_inplace / f_op_le_inplace
fn f_op_le_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_le_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_le_inplace.
ClikaRT::ops::le_ <- ClikaRT/compute/ops.h
op_leaky_relu / f_op_leaky_relu
fn f_op_leaky_relu(self, x: Tensor, negative_slope: f64) -> Result<Tensor>
fn op_leaky_relu(self, x: Tensor, negative_slope: f64) -> Tensor
Wraps api-table member op_leaky_relu.
ClikaRT::ops::leaky_relu <- ClikaRT/compute/ops.h
op_leaky_relu_inplace / f_op_leaky_relu_inplace
fn f_op_leaky_relu_inplace(self, self_: &Tensor, negative_slope: f64) -> Result<()>
fn op_leaky_relu_inplace(self, self_: &Tensor, negative_slope: f64)
Wraps api-table member op_leaky_relu_inplace.
ClikaRT::ops::leaky_relu_ <- ClikaRT/compute/ops.h
op_linear / f_op_linear
fn f_op_linear(self, x: Tensor, weight: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, situ_beta: f64, situ_linear_beta: f64) -> Result<Tensor>
fn op_linear(self, x: Tensor, weight: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, situ_beta: f64, situ_linear_beta: f64) -> Tensor
Wraps api-table member op_linear.
ClikaRT::ops::linear <- ClikaRT/compute/ops.h
op_linspace / f_op_linspace
fn f_op_linspace(self, start: clika_rt_scalar_or_tensor, end: clika_rt_scalar_or_tensor, steps: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_linspace(self, start: clika_rt_scalar_or_tensor, end: clika_rt_scalar_or_tensor, steps: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_linspace.
ClikaRT::ops::linspace <- ClikaRT/compute/ops.h
op_log / f_op_log
fn f_op_log(self, x: Tensor) -> Result<Tensor>
fn op_log(self, x: Tensor) -> Tensor
Wraps api-table member op_log.
ClikaRT::ops::log <- ClikaRT/compute/ops.h
op_log10 / f_op_log10
fn f_op_log10(self, x: Tensor) -> Result<Tensor>
fn op_log10(self, x: Tensor) -> Tensor
Wraps api-table member op_log10.
ClikaRT::ops::log10 <- ClikaRT/compute/ops.h
op_log10_inplace / f_op_log10_inplace
fn f_op_log10_inplace(self, self_: &Tensor) -> Result<()>
fn op_log10_inplace(self, self_: &Tensor)
Wraps api-table member op_log10_inplace.
ClikaRT::ops::log10_ <- ClikaRT/compute/ops.h
op_log1p / f_op_log1p
fn f_op_log1p(self, x: Tensor) -> Result<Tensor>
fn op_log1p(self, x: Tensor) -> Tensor
Wraps api-table member op_log1p.
ClikaRT::ops::log1p <- ClikaRT/compute/ops.h
op_log1p_inplace / f_op_log1p_inplace
fn f_op_log1p_inplace(self, self_: &Tensor) -> Result<()>
fn op_log1p_inplace(self, self_: &Tensor)
Wraps api-table member op_log1p_inplace.
ClikaRT::ops::log1p_ <- ClikaRT/compute/ops.h
op_log2 / f_op_log2
fn f_op_log2(self, x: Tensor) -> Result<Tensor>
fn op_log2(self, x: Tensor) -> Tensor
Wraps api-table member op_log2.
ClikaRT::ops::log2 <- ClikaRT/compute/ops.h
op_log2_inplace / f_op_log2_inplace
fn f_op_log2_inplace(self, self_: &Tensor) -> Result<()>
fn op_log2_inplace(self, self_: &Tensor)
Wraps api-table member op_log2_inplace.
ClikaRT::ops::log2_ <- ClikaRT/compute/ops.h
op_log_inplace / f_op_log_inplace
fn f_op_log_inplace(self, self_: &Tensor) -> Result<()>
fn op_log_inplace(self, self_: &Tensor)
Wraps api-table member op_log_inplace.
ClikaRT::ops::log_ <- ClikaRT/compute/ops.h
op_log_sigmoid / f_op_log_sigmoid
fn f_op_log_sigmoid(self, x: Tensor) -> Result<Tensor>
fn op_log_sigmoid(self, x: Tensor) -> Tensor
Wraps api-table member op_log_sigmoid.
ClikaRT::ops::log_sigmoid <- ClikaRT/compute/ops.h
op_log_sigmoid_inplace / f_op_log_sigmoid_inplace
fn f_op_log_sigmoid_inplace(self, self_: &Tensor) -> Result<()>
fn op_log_sigmoid_inplace(self, self_: &Tensor)
Wraps api-table member op_log_sigmoid_inplace.
ClikaRT::ops::log_sigmoid_ <- ClikaRT/compute/ops.h
op_log_softmax / f_op_log_softmax
fn f_op_log_softmax(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn op_log_softmax(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_log_softmax.
ClikaRT::ops::log_softmax <- ClikaRT/compute/ops.h
op_log_softmax_inplace / f_op_log_softmax_inplace
fn f_op_log_softmax_inplace(self, self_: &Tensor, dim: i64) -> Result<()>
fn op_log_softmax_inplace(self, self_: &Tensor, dim: i64)
Wraps api-table member op_log_softmax_inplace.
ClikaRT::ops::log_softmax_ <- ClikaRT/compute/ops.h
op_logaddexp / f_op_logaddexp
fn f_op_logaddexp(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_logaddexp(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_logaddexp.
ClikaRT::ops::logaddexp <- ClikaRT/compute/ops.h
op_logaddexp2 / f_op_logaddexp2
fn f_op_logaddexp2(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_logaddexp2(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_logaddexp2.
ClikaRT::ops::logaddexp2 <- ClikaRT/compute/ops.h
op_logical_and / f_op_logical_and
fn f_op_logical_and(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_logical_and(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_logical_and.
ClikaRT::ops::logical_and <- ClikaRT/compute/ops.h
op_logical_and_inplace / f_op_logical_and_inplace
fn f_op_logical_and_inplace(self, self_: &Tensor, other: Tensor) -> Result<()>
fn op_logical_and_inplace(self, self_: &Tensor, other: Tensor)
Wraps api-table member op_logical_and_inplace.
ClikaRT::ops::logical_and_ <- ClikaRT/compute/ops.h
op_logical_not / f_op_logical_not
fn f_op_logical_not(self, x: Tensor) -> Result<Tensor>
fn op_logical_not(self, x: Tensor) -> Tensor
Wraps api-table member op_logical_not.
ClikaRT::ops::logical_not <- ClikaRT/compute/ops.h
op_logical_not_inplace / f_op_logical_not_inplace
fn f_op_logical_not_inplace(self, self_: &Tensor) -> Result<()>
fn op_logical_not_inplace(self, self_: &Tensor)
Wraps api-table member op_logical_not_inplace.
ClikaRT::ops::logical_not_ <- ClikaRT/compute/ops.h
op_logical_or / f_op_logical_or
fn f_op_logical_or(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_logical_or(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_logical_or.
ClikaRT::ops::logical_or <- ClikaRT/compute/ops.h
op_logical_or_inplace / f_op_logical_or_inplace
fn f_op_logical_or_inplace(self, self_: &Tensor, other: Tensor) -> Result<()>
fn op_logical_or_inplace(self, self_: &Tensor, other: Tensor)
Wraps api-table member op_logical_or_inplace.
ClikaRT::ops::logical_or_ <- ClikaRT/compute/ops.h
op_logical_xor / f_op_logical_xor
fn f_op_logical_xor(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_logical_xor(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_logical_xor.
ClikaRT::ops::logical_xor <- ClikaRT/compute/ops.h
op_logical_xor_inplace / f_op_logical_xor_inplace
fn f_op_logical_xor_inplace(self, self_: &Tensor, other: Tensor) -> Result<()>
fn op_logical_xor_inplace(self, self_: &Tensor, other: Tensor)
Wraps api-table member op_logical_xor_inplace.
ClikaRT::ops::logical_xor_ <- ClikaRT/compute/ops.h
op_logit / f_op_logit
fn f_op_logit(self, x: Tensor, eps_has: bool, eps: f64) -> Result<Tensor>
fn op_logit(self, x: Tensor, eps_has: bool, eps: f64) -> Tensor
Wraps api-table member op_logit.
ClikaRT::ops::logit <- ClikaRT/compute/ops.h
op_logit_inplace / f_op_logit_inplace
fn f_op_logit_inplace(self, self_: &Tensor, eps_has: bool, eps: f64) -> Result<()>
fn op_logit_inplace(self, self_: &Tensor, eps_has: bool, eps: f64)
Wraps api-table member op_logit_inplace.
ClikaRT::ops::logit_ <- ClikaRT/compute/ops.h
op_logsumexp / f_op_logsumexp
fn f_op_logsumexp(self, x: Tensor, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn op_logsumexp(self, x: Tensor, dims: &[i64], keepdim: bool) -> Tensor
Wraps api-table member op_logsumexp.
ClikaRT::ops::logsumexp <- ClikaRT/compute/ops.h
op_lt / f_op_lt
fn f_op_lt(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_lt(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_lt.
ClikaRT::ops::lt <- ClikaRT/compute/ops.h
op_lt_inplace / f_op_lt_inplace
fn f_op_lt_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_lt_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_lt_inplace.
ClikaRT::ops::lt_ <- ClikaRT/compute/ops.h
op_masked_fill / f_op_masked_fill
fn f_op_masked_fill(self, x: Tensor, mask: Tensor, value: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_masked_fill(self, x: Tensor, mask: Tensor, value: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_masked_fill.
ClikaRT::ops::masked_fill <- ClikaRT/compute/ops.h
op_masked_fill_inplace / f_op_masked_fill_inplace
fn f_op_masked_fill_inplace(self, self_: &Tensor, mask: Tensor, value: clika_rt_scalar_or_tensor) -> Result<()>
fn op_masked_fill_inplace(self, self_: &Tensor, mask: Tensor, value: clika_rt_scalar_or_tensor)
Wraps api-table member op_masked_fill_inplace.
ClikaRT::ops::masked_fill_ <- ClikaRT/compute/ops.h
op_masked_scatter / f_op_masked_scatter
fn f_op_masked_scatter(self, x: Tensor, mask: Tensor, source: Tensor) -> Result<Tensor>
fn op_masked_scatter(self, x: Tensor, mask: Tensor, source: Tensor) -> Tensor
Wraps api-table member op_masked_scatter.
ClikaRT::ops::masked_scatter <- ClikaRT/compute/ops.h
op_masked_scatter_inplace / f_op_masked_scatter_inplace
fn f_op_masked_scatter_inplace(self, self_: &Tensor, mask: Tensor, source: Tensor) -> Result<()>
fn op_masked_scatter_inplace(self, self_: &Tensor, mask: Tensor, source: Tensor)
Wraps api-table member op_masked_scatter_inplace.
ClikaRT::ops::masked_scatter_ <- ClikaRT/compute/ops.h
op_masked_select / f_op_masked_select
fn f_op_masked_select(self, x: Tensor, mask: Tensor) -> Result<Tensor>
fn op_masked_select(self, x: Tensor, mask: Tensor) -> Tensor
Wraps api-table member op_masked_select.
ClikaRT::ops::masked_select <- ClikaRT/compute/ops.h
op_matmul / f_op_matmul
fn f_op_matmul(self, a: Tensor, b: 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 op_matmul(self, a: Tensor, b: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, situ_beta: f64, situ_linear_beta: f64) -> Tensor
Wraps api-table member op_matmul.
ClikaRT::ops::matmul <- ClikaRT/compute/ops.h
op_max / f_op_max
fn f_op_max(self, x: Tensor, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn op_max(self, x: Tensor, dim: i64, keepdim: bool) -> (Tensor, Tensor)
Wraps api-table member op_max.
ClikaRT::ops::max <- ClikaRT/compute/ops.h
op_max_pool / f_op_max_pool
fn f_op_max_pool(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<Tensor>
fn op_max_pool(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Tensor
Wraps api-table member op_max_pool.
ClikaRT::ops::max_pool <- ClikaRT/compute/ops.h
op_max_pool1d / f_op_max_pool1d
fn f_op_max_pool1d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<Tensor>
fn op_max_pool1d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Tensor
Wraps api-table member op_max_pool1d.
ClikaRT::ops::max_pool1d <- ClikaRT/compute/ops.h
op_max_pool1d_with_indices / f_op_max_pool1d_with_indices
fn f_op_max_pool1d_with_indices(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<(Tensor, Tensor)>
fn op_max_pool1d_with_indices(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> (Tensor, Tensor)
Wraps api-table member op_max_pool1d_with_indices.
ClikaRT::ops::max_pool1d_with_indices <- ClikaRT/compute/ops.h
op_max_pool2d / f_op_max_pool2d
fn f_op_max_pool2d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<Tensor>
fn op_max_pool2d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Tensor
Wraps api-table member op_max_pool2d.
ClikaRT::ops::max_pool2d <- ClikaRT/compute/ops.h
op_max_pool2d_with_indices / f_op_max_pool2d_with_indices
fn f_op_max_pool2d_with_indices(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<(Tensor, Tensor)>
fn op_max_pool2d_with_indices(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> (Tensor, Tensor)
Wraps api-table member op_max_pool2d_with_indices.
ClikaRT::ops::max_pool2d_with_indices <- ClikaRT/compute/ops.h
op_max_pool3d / f_op_max_pool3d
fn f_op_max_pool3d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<Tensor>
fn op_max_pool3d(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Tensor
Wraps api-table member op_max_pool3d.
ClikaRT::ops::max_pool3d <- ClikaRT/compute/ops.h
op_max_pool3d_with_indices / f_op_max_pool3d_with_indices
fn f_op_max_pool3d_with_indices(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<(Tensor, Tensor)>
fn op_max_pool3d_with_indices(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> (Tensor, Tensor)
Wraps api-table member op_max_pool3d_with_indices.
ClikaRT::ops::max_pool3d_with_indices <- ClikaRT/compute/ops.h
op_max_pool_with_indices / f_op_max_pool_with_indices
fn f_op_max_pool_with_indices(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> Result<(Tensor, Tensor)>
fn op_max_pool_with_indices(self, x: Tensor, kernel_size: &[i64], stride: &[i64], padding: &[i64], dilation: &[i64], ceil_mode: bool) -> (Tensor, Tensor)
Wraps api-table member op_max_pool_with_indices.
ClikaRT::ops::max_pool_with_indices <- ClikaRT/compute/ops.h
op_maximum / f_op_maximum
fn f_op_maximum(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_maximum(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_maximum.
ClikaRT::ops::maximum <- ClikaRT/compute/ops.h
op_maximum_inplace / f_op_maximum_inplace
fn f_op_maximum_inplace(self, self_: &Tensor, other: Tensor) -> Result<()>
fn op_maximum_inplace(self, self_: &Tensor, other: Tensor)
Wraps api-table member op_maximum_inplace.
ClikaRT::ops::maximum_ <- ClikaRT/compute/ops.h
op_mean / f_op_mean
fn f_op_mean(self, x: Tensor, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Result<Tensor>
fn op_mean(self, x: Tensor, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_mean.
ClikaRT::ops::mean <- ClikaRT/compute/ops.h
op_median / f_op_median
fn f_op_median(self, x: Tensor, dim_has: bool, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn op_median(self, x: Tensor, dim_has: bool, dim: i64, keepdim: bool) -> (Tensor, Tensor)
Wraps api-table member op_median.
ClikaRT::ops::median <- ClikaRT/compute/ops.h
op_meshgrid / f_op_meshgrid
fn f_op_meshgrid(self, tensors: &[&Tensor], indexing: clika_rt_meshgrid_indexing) -> Result<TensorList>
fn op_meshgrid(self, tensors: &[&Tensor], indexing: clika_rt_meshgrid_indexing) -> TensorList
Wraps api-table member op_meshgrid.
ClikaRT::ops::meshgrid <- ClikaRT/compute/ops.h
op_min / f_op_min
fn f_op_min(self, x: Tensor, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn op_min(self, x: Tensor, dim: i64, keepdim: bool) -> (Tensor, Tensor)
Wraps api-table member op_min.
ClikaRT::ops::min <- ClikaRT/compute/ops.h
op_minimum / f_op_minimum
fn f_op_minimum(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_minimum(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_minimum.
ClikaRT::ops::minimum <- ClikaRT/compute/ops.h
op_minimum_inplace / f_op_minimum_inplace
fn f_op_minimum_inplace(self, self_: &Tensor, other: Tensor) -> Result<()>
fn op_minimum_inplace(self, self_: &Tensor, other: Tensor)
Wraps api-table member op_minimum_inplace.
ClikaRT::ops::minimum_ <- ClikaRT/compute/ops.h
op_mish / f_op_mish
fn f_op_mish(self, x: Tensor) -> Result<Tensor>
fn op_mish(self, x: Tensor) -> Tensor
Wraps api-table member op_mish.
ClikaRT::ops::mish <- ClikaRT/compute/ops.h
op_mish_inplace / f_op_mish_inplace
fn f_op_mish_inplace(self, self_: &Tensor) -> Result<()>
fn op_mish_inplace(self, self_: &Tensor)
Wraps api-table member op_mish_inplace.
ClikaRT::ops::mish_ <- ClikaRT/compute/ops.h
op_mla_attention / f_op_mla_attention
fn f_op_mla_attention(self, q_nope: Tensor, q_pe: Tensor, new_ckv: Tensor, new_kpe: Tensor, ckv_cache: Tensor, kpe_cache: Tensor, kvcache_start: Tensor, cu_seqlens_q: Tensor, scale: f64, slot_ids: Tensor) -> Result<Tensor>
fn op_mla_attention(self, q_nope: Tensor, q_pe: Tensor, new_ckv: Tensor, new_kpe: Tensor, ckv_cache: Tensor, kpe_cache: Tensor, kvcache_start: Tensor, cu_seqlens_q: Tensor, scale: f64, slot_ids: Tensor) -> Tensor
Wraps api-table member op_mla_attention.
ClikaRT::ops::mla_attention <- ClikaRT/compute/ops.h
op_mm / f_op_mm
fn f_op_mm(self, a: Tensor, b: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn op_mm(self, a: Tensor, b: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_mm.
ClikaRT::ops::mm <- ClikaRT/compute/ops.h
op_mod / f_op_mod
fn f_op_mod(self, a: Tensor, other: clika_rt_scalar_or_tensor, mode: clika_rt_mod_mode) -> Result<Tensor>
fn op_mod(self, a: Tensor, other: clika_rt_scalar_or_tensor, mode: clika_rt_mod_mode) -> Tensor
Wraps api-table member op_mod.
ClikaRT::ops::mod <- ClikaRT/compute/ops.h
op_mod_inplace / f_op_mod_inplace
fn f_op_mod_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, mode: clika_rt_mod_mode) -> Result<()>
fn op_mod_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, mode: clika_rt_mod_mode)
Wraps api-table member op_mod_inplace.
ClikaRT::ops::mod_ <- ClikaRT/compute/ops.h
op_moe / f_op_moe
fn f_op_moe(self, input: Tensor, 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 op_moe(self, input: Tensor, 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
Wraps api-table member op_moe.
ClikaRT::ops::moe <- ClikaRT/compute/ops.h
op_mrope_rotary_embedding / f_op_mrope_rotary_embedding
fn f_op_mrope_rotary_embedding(self, x0: Tensor, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingOptions) -> Result<Tensor>
fn op_mrope_rotary_embedding(self, x0: Tensor, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingOptions) -> Tensor
Wraps api-table member op_mrope_rotary_embedding.
ClikaRT::ops::mrope_rotary_embedding <- ClikaRT/compute/ops.h
op_mrope_rotary_embedding_qk_varlen / f_op_mrope_rotary_embedding_qk_varlen
fn f_op_mrope_rotary_embedding_qk_varlen(self, q: Tensor, k: Tensor, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingQkVarlenOptions) -> Result<(Tensor, Tensor)>
fn op_mrope_rotary_embedding_qk_varlen(self, q: Tensor, k: Tensor, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingQkVarlenOptions) -> (Tensor, Tensor)
Wraps api-table member op_mrope_rotary_embedding_qk_varlen.
ClikaRT::ops::mrope_rotary_embedding_qk_varlen <- ClikaRT/compute/ops.h
op_mrope_rotary_embedding_varlen / f_op_mrope_rotary_embedding_varlen
fn f_op_mrope_rotary_embedding_varlen(self, x0: Tensor, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingVarlenOptions) -> Result<Tensor>
fn op_mrope_rotary_embedding_varlen(self, x0: Tensor, position_ids: Tensor, mrope_sections: &[i64], options: &MropeRotaryEmbeddingVarlenOptions) -> Tensor
Wraps api-table member op_mrope_rotary_embedding_varlen.
ClikaRT::ops::mrope_rotary_embedding_varlen <- ClikaRT/compute/ops.h
op_ms_deform_attention / f_op_ms_deform_attention
fn f_op_ms_deform_attention(self, value: Tensor, spatial_shapes: Tensor, level_start_index: Tensor, sampling_locations: Tensor, attention_weights: Tensor) -> Result<Tensor>
fn op_ms_deform_attention(self, value: Tensor, spatial_shapes: Tensor, level_start_index: Tensor, sampling_locations: Tensor, attention_weights: Tensor) -> Tensor
Wraps api-table member op_ms_deform_attention.
ClikaRT::ops::ms_deform_attention <- ClikaRT/compute/ops.h
op_mse_loss / f_op_mse_loss
fn f_op_mse_loss(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction) -> Result<Tensor>
fn op_mse_loss(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction) -> Tensor
Wraps api-table member op_mse_loss.
ClikaRT::ops::mse_loss <- ClikaRT/compute/ops.h
op_mul_inplace / f_op_mul_inplace
fn f_op_mul_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, activation: clika_rt_activation) -> Result<()>
fn op_mul_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, activation: clika_rt_activation)
Wraps api-table member op_mul_inplace.
ClikaRT::ops::mul_ <- ClikaRT/compute/ops.h
op_mul_scalar_lhs / f_op_mul_scalar_lhs
fn f_op_mul_scalar_lhs(self, a: clika_rt_scalar, b: Tensor, activation: clika_rt_activation) -> Result<Tensor>
fn op_mul_scalar_lhs(self, a: clika_rt_scalar, b: Tensor, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_mul_scalar_lhs.
ClikaRT::ops::mul <- ClikaRT/compute/ops.h
op_mul_tensor / f_op_mul_tensor
fn f_op_mul_tensor(self, a: Tensor, other: clika_rt_scalar_or_tensor, activation: clika_rt_activation) -> Result<Tensor>
fn op_mul_tensor(self, a: Tensor, other: clika_rt_scalar_or_tensor, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_mul_tensor.
ClikaRT::ops::mul <- ClikaRT/compute/ops.h
op_multinomial / f_op_multinomial
fn f_op_multinomial(self, probabilities: Tensor, num_samples: i64, replacement: bool, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_multinomial(self, probabilities: Tensor, num_samples: i64, replacement: bool, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_multinomial.
ClikaRT::ops::multinomial <- ClikaRT/compute/ops.h
op_mv / f_op_mv
fn f_op_mv(self, a: Tensor, vec: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn op_mv(self, a: Tensor, vec: Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_mv.
ClikaRT::ops::mv <- ClikaRT/compute/ops.h
op_nan_to_num / f_op_nan_to_num
fn f_op_nan_to_num(self, x: Tensor, nan_has: bool, nan: f64, posinf_has: bool, posinf: f64, neginf_has: bool, neginf: f64) -> Result<Tensor>
fn op_nan_to_num(self, x: Tensor, nan_has: bool, nan: f64, posinf_has: bool, posinf: f64, neginf_has: bool, neginf: f64) -> Tensor
Wraps api-table member op_nan_to_num.
ClikaRT::ops::nan_to_num <- ClikaRT/compute/ops.h
op_nan_to_num_inplace / f_op_nan_to_num_inplace
fn f_op_nan_to_num_inplace(self, self_: &Tensor, nan_has: bool, nan: f64, posinf_has: bool, posinf: f64, neginf_has: bool, neginf: f64) -> Result<()>
fn op_nan_to_num_inplace(self, self_: &Tensor, nan_has: bool, nan: f64, posinf_has: bool, posinf: f64, neginf_has: bool, neginf: f64)
Wraps api-table member op_nan_to_num_inplace.
ClikaRT::ops::nan_to_num_ <- ClikaRT/compute/ops.h
op_nanmean / f_op_nanmean
fn f_op_nanmean(self, x: Tensor, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn op_nanmean(self, x: Tensor, dims: &[i64], keepdim: bool) -> Tensor
Wraps api-table member op_nanmean.
ClikaRT::ops::nanmean <- ClikaRT/compute/ops.h
op_nanmedian / f_op_nanmedian
fn f_op_nanmedian(self, x: Tensor, dim_has: bool, dim: i64, keepdim: bool) -> Result<(Tensor, Tensor)>
fn op_nanmedian(self, x: Tensor, dim_has: bool, dim: i64, keepdim: bool) -> (Tensor, Tensor)
Wraps api-table member op_nanmedian.
ClikaRT::ops::nanmedian <- ClikaRT/compute/ops.h
op_nanquantile / f_op_nanquantile
fn f_op_nanquantile(self, x: Tensor, q: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, keepdim: bool, interpolation: clika_rt_quantile_interp) -> Result<Tensor>
fn op_nanquantile(self, x: Tensor, q: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, keepdim: bool, interpolation: clika_rt_quantile_interp) -> Tensor
Wraps api-table member op_nanquantile.
ClikaRT::ops::nanquantile <- ClikaRT/compute/ops.h
op_nansum / f_op_nansum
fn f_op_nansum(self, x: Tensor, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn op_nansum(self, x: Tensor, dims: &[i64], keepdim: bool) -> Tensor
Wraps api-table member op_nansum.
ClikaRT::ops::nansum <- ClikaRT/compute/ops.h
op_narrow / f_op_narrow
fn f_op_narrow(self, x: Tensor, dim: i64, start: clika_rt_index_bound, length: clika_rt_index_bound) -> Result<Tensor>
fn op_narrow(self, x: Tensor, dim: i64, start: clika_rt_index_bound, length: clika_rt_index_bound) -> Tensor
Wraps api-table member op_narrow.
ClikaRT::ops::narrow <- ClikaRT/compute/ops.h
op_ndim / f_op_ndim
fn f_op_ndim(self, x: Tensor) -> Result<Tensor>
fn op_ndim(self, x: Tensor) -> Tensor
Wraps api-table member op_ndim.
ClikaRT::ops::ndim <- ClikaRT/compute/ops.h
op_ndim_host / f_op_ndim_host
fn f_op_ndim_host(self, x: Tensor) -> Result<Tensor>
fn op_ndim_host(self, x: Tensor) -> Tensor
Wraps api-table member op_ndim_host.
ClikaRT::ops::ndim_host <- ClikaRT/compute/ops.h
op_ne / f_op_ne
fn f_op_ne(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_ne(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_ne.
ClikaRT::ops::ne <- ClikaRT/compute/ops.h
op_ne_inplace / f_op_ne_inplace
fn f_op_ne_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_ne_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_ne_inplace.
ClikaRT::ops::ne_ <- ClikaRT/compute/ops.h
op_neg / f_op_neg
fn f_op_neg(self, x: Tensor) -> Result<Tensor>
fn op_neg(self, x: Tensor) -> Tensor
Wraps api-table member op_neg.
ClikaRT::ops::neg <- ClikaRT/compute/ops.h
op_neg_inplace / f_op_neg_inplace
fn f_op_neg_inplace(self, self_: &Tensor) -> Result<()>
fn op_neg_inplace(self, self_: &Tensor)
Wraps api-table member op_neg_inplace.
ClikaRT::ops::neg_ <- ClikaRT/compute/ops.h
op_nll_loss / f_op_nll_loss
fn f_op_nll_loss(self, input: Tensor, target: Tensor, weight: Tensor, ignore_index_has: bool, ignore_index: i64, reduction: clika_rt_reduction) -> Result<Tensor>
fn op_nll_loss(self, input: Tensor, target: Tensor, weight: Tensor, ignore_index_has: bool, ignore_index: i64, reduction: clika_rt_reduction) -> Tensor
Wraps api-table member op_nll_loss.
ClikaRT::ops::nll_loss <- ClikaRT/compute/ops.h
op_nms / f_op_nms
fn f_op_nms(self, boxes: Tensor, scores: Tensor, max_output_boxes_per_class: clika_rt_scalar_or_tensor, iou_threshold: clika_rt_scalar_or_tensor, score_threshold: clika_rt_scalar_or_tensor, center_point_box: bool) -> Result<Tensor>
fn op_nms(self, boxes: Tensor, scores: Tensor, max_output_boxes_per_class: clika_rt_scalar_or_tensor, iou_threshold: clika_rt_scalar_or_tensor, score_threshold: clika_rt_scalar_or_tensor, center_point_box: bool) -> Tensor
Wraps api-table member op_nms.
ClikaRT::ops::nms <- ClikaRT/compute/ops.h
op_nonzero / f_op_nonzero
fn f_op_nonzero(self, x: Tensor) -> Result<Tensor>
fn op_nonzero(self, x: Tensor) -> Tensor
Wraps api-table member op_nonzero.
ClikaRT::ops::nonzero <- ClikaRT/compute/ops.h
op_norm / f_op_norm
fn f_op_norm(self, x: Tensor, p: clika_rt_scalar, dims: &[i64], keepdim: bool) -> Result<Tensor>
fn op_norm(self, x: Tensor, p: clika_rt_scalar, dims: &[i64], keepdim: bool) -> Tensor
Wraps api-table member op_norm.
ClikaRT::ops::norm <- ClikaRT/compute/ops.h
op_normal / f_op_normal
fn f_op_normal(self, mean: clika_rt_scalar_or_tensor, stddev: clika_rt_scalar_or_tensor, shape: &[clika_rt_scalar_or_tensor], s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_normal(self, mean: clika_rt_scalar_or_tensor, stddev: clika_rt_scalar_or_tensor, shape: &[clika_rt_scalar_or_tensor], s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_normal.
ClikaRT::ops::normal <- ClikaRT/compute/ops.h
op_normal_inplace / f_op_normal_inplace
fn f_op_normal_inplace(self, self_: &Tensor, mean: clika_rt_scalar_or_tensor, stddev: clika_rt_scalar_or_tensor, s: clika_rt_stream_or_device) -> Result<()>
fn op_normal_inplace(self, self_: &Tensor, mean: clika_rt_scalar_or_tensor, stddev: clika_rt_scalar_or_tensor, s: clika_rt_stream_or_device)
Wraps api-table member op_normal_inplace.
ClikaRT::ops::normal_ <- ClikaRT/compute/ops.h
op_normalize / f_op_normalize
fn f_op_normalize(self, x: Tensor, p: clika_rt_scalar, dim: i64, eps_has: bool, eps: f64) -> Result<Tensor>
fn op_normalize(self, x: Tensor, p: clika_rt_scalar, dim: i64, eps_has: bool, eps: f64) -> Tensor
Wraps api-table member op_normalize.
ClikaRT::ops::normalize <- ClikaRT/compute/ops.h
op_normalize_inplace / f_op_normalize_inplace
fn f_op_normalize_inplace(self, self_: &Tensor, p: clika_rt_scalar, dim: i64, eps_has: bool, eps: f64) -> Result<()>
fn op_normalize_inplace(self, self_: &Tensor, p: clika_rt_scalar, dim: i64, eps_has: bool, eps: f64)
Wraps api-table member op_normalize_inplace.
ClikaRT::ops::normalize_ <- ClikaRT/compute/ops.h
op_numel / f_op_numel
fn f_op_numel(self, x: Tensor) -> Result<Tensor>
fn op_numel(self, x: Tensor) -> Tensor
Wraps api-table member op_numel.
ClikaRT::ops::numel <- ClikaRT/compute/ops.h
op_numel_host / f_op_numel_host
fn f_op_numel_host(self, x: Tensor) -> Result<Tensor>
fn op_numel_host(self, x: Tensor) -> Tensor
Wraps api-table member op_numel_host.
ClikaRT::ops::numel_host <- ClikaRT/compute/ops.h
op_one_hot / f_op_one_hot
fn f_op_one_hot(self, indices: Tensor, num_classes: i64) -> Result<Tensor>
fn op_one_hot(self, indices: Tensor, num_classes: i64) -> Tensor
Wraps api-table member op_one_hot.
ClikaRT::ops::one_hot <- ClikaRT/compute/ops.h
op_ones / f_op_ones
fn f_op_ones(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device, pinned_for: clika_rt_stream_or_device) -> Result<Tensor>
fn op_ones(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device, pinned_for: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_ones.
ClikaRT::ops::ones <- ClikaRT/compute/ops.h
op_ones_like / f_op_ones_like
fn f_op_ones_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_ones_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_ones_like.
ClikaRT::ops::ones_like <- ClikaRT/compute/ops.h
op_outer / f_op_outer
fn f_op_outer(self, a: Tensor, b: Tensor) -> Result<Tensor>
fn op_outer(self, a: Tensor, b: Tensor) -> Tensor
Wraps api-table member op_outer.
ClikaRT::ops::outer <- ClikaRT/compute/ops.h
op_pad / f_op_pad
fn f_op_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor], mode: clika_rt_pad_mode, value: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor], mode: clika_rt_pad_mode, value: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_pad.
ClikaRT::ops::pad <- ClikaRT/compute/ops.h
op_pairwise_distance / f_op_pairwise_distance
fn f_op_pairwise_distance(self, a: Tensor, b: Tensor, p: clika_rt_scalar, eps_has: bool, eps: f64, keepdim: bool) -> Result<Tensor>
fn op_pairwise_distance(self, a: Tensor, b: Tensor, p: clika_rt_scalar, eps_has: bool, eps: f64, keepdim: bool) -> Tensor
Wraps api-table member op_pairwise_distance.
ClikaRT::ops::pairwise_distance <- ClikaRT/compute/ops.h
op_pdist / f_op_pdist
fn f_op_pdist(self, a: Tensor, p: clika_rt_scalar) -> Result<Tensor>
fn op_pdist(self, a: Tensor, p: clika_rt_scalar) -> Tensor
Wraps api-table member op_pdist.
ClikaRT::ops::pdist <- ClikaRT/compute/ops.h
op_permute / f_op_permute
fn f_op_permute(self, x: Tensor, dims: &[i64]) -> Result<Tensor>
fn op_permute(self, x: Tensor, dims: &[i64]) -> Tensor
Wraps api-table member op_permute.
ClikaRT::ops::permute <- ClikaRT/compute/ops.h
op_pixel_shuffle / f_op_pixel_shuffle
fn f_op_pixel_shuffle(self, x: Tensor, upscale_factor: i64, mode: clika_rt_pixel_shuffle_mode) -> Result<Tensor>
fn op_pixel_shuffle(self, x: Tensor, upscale_factor: i64, mode: clika_rt_pixel_shuffle_mode) -> Tensor
Wraps api-table member op_pixel_shuffle.
ClikaRT::ops::pixel_shuffle <- ClikaRT/compute/ops.h
op_pixel_unshuffle / f_op_pixel_unshuffle
fn f_op_pixel_unshuffle(self, x: Tensor, downscale_factor: i64, mode: clika_rt_pixel_shuffle_mode) -> Result<Tensor>
fn op_pixel_unshuffle(self, x: Tensor, downscale_factor: i64, mode: clika_rt_pixel_shuffle_mode) -> Tensor
Wraps api-table member op_pixel_unshuffle.
ClikaRT::ops::pixel_unshuffle <- ClikaRT/compute/ops.h
op_poisson / f_op_poisson
fn f_op_poisson(self, rates: Tensor, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_poisson(self, rates: Tensor, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_poisson.
ClikaRT::ops::poisson <- ClikaRT/compute/ops.h
op_pow / f_op_pow
fn f_op_pow(self, a: Tensor, exponent: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_pow(self, a: Tensor, exponent: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_pow.
ClikaRT::ops::pow <- ClikaRT/compute/ops.h
op_pow_inplace / f_op_pow_inplace
fn f_op_pow_inplace(self, self_: &Tensor, exponent: clika_rt_scalar_or_tensor) -> Result<()>
fn op_pow_inplace(self, self_: &Tensor, exponent: clika_rt_scalar_or_tensor)
Wraps api-table member op_pow_inplace.
ClikaRT::ops::pow_ <- ClikaRT/compute/ops.h
op_prelu / f_op_prelu
fn f_op_prelu(self, x: Tensor, weight: Tensor) -> Result<Tensor>
fn op_prelu(self, x: Tensor, weight: Tensor) -> Tensor
Wraps api-table member op_prelu.
ClikaRT::ops::prelu <- ClikaRT/compute/ops.h
op_prelu_inplace / f_op_prelu_inplace
fn f_op_prelu_inplace(self, self_: &Tensor, weight: Tensor) -> Result<()>
fn op_prelu_inplace(self, self_: &Tensor, weight: Tensor)
Wraps api-table member op_prelu_inplace.
ClikaRT::ops::prelu_ <- ClikaRT/compute/ops.h
op_prod / f_op_prod
fn f_op_prod(self, x: Tensor, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Result<Tensor>
fn op_prod(self, x: Tensor, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_prod.
ClikaRT::ops::prod <- ClikaRT/compute/ops.h
op_put / f_op_put
fn f_op_put(self, x: Tensor, index: Tensor, source: Tensor, accumulate: bool) -> Result<Tensor>
fn op_put(self, x: Tensor, index: Tensor, source: Tensor, accumulate: bool) -> Tensor
Wraps api-table member op_put.
ClikaRT::ops::put <- ClikaRT/compute/ops.h
op_put_inplace / f_op_put_inplace
fn f_op_put_inplace(self, self_: &Tensor, index: Tensor, source: Tensor, accumulate: bool) -> Result<()>
fn op_put_inplace(self, self_: &Tensor, index: Tensor, source: Tensor, accumulate: bool)
Wraps api-table member op_put_inplace.
ClikaRT::ops::put_ <- ClikaRT/compute/ops.h
op_q_embedding / f_op_q_embedding
fn f_op_q_embedding(self, indices: Tensor, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, out_dtype: clika_rt_data_type) -> Result<Tensor>
fn op_q_embedding(self, indices: Tensor, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, out_dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_q_embedding.
ClikaRT::ops::q_embedding <- ClikaRT/compute/q_tensor.h
op_qadd_inplace_to_dense / f_op_qadd_inplace_to_dense
fn f_op_qadd_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, activation: clika_rt_activation) -> Result<()>
fn op_qadd_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, activation: clika_rt_activation)
Wraps api-table member op_qadd_inplace_to_dense.
ClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h
op_qadd_inplace_to_dense_out_scale / f_op_qadd_inplace_to_dense_out_scale
fn f_op_qadd_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation) -> Result<()>
fn op_qadd_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation)
Wraps api-table member op_qadd_inplace_to_dense_out_scale.
ClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h
op_qadd_inplace_to_quantized / f_op_qadd_inplace_to_quantized
fn f_op_qadd_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, activation: clika_rt_activation) -> Result<()>
fn op_qadd_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, activation: clika_rt_activation)
Wraps api-table member op_qadd_inplace_to_quantized.
ClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h
op_qadd_to_dense / f_op_qadd_to_dense
fn f_op_qadd_to_dense(self, a: QTensor, b: QTensor, activation: clika_rt_activation) -> Result<Tensor>
fn op_qadd_to_dense(self, a: QTensor, b: QTensor, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qadd_to_dense.
ClikaRT::ops::qadd <- ClikaRT/compute/q_tensor.h
op_qadd_to_quantized / f_op_qadd_to_quantized
fn f_op_qadd_to_quantized(self, a: QTensor, b: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> Result<QTensor>
fn op_qadd_to_quantized(self, a: QTensor, b: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> QTensor
Wraps api-table member op_qadd_to_quantized.
ClikaRT::ops::qadd <- ClikaRT/compute/q_tensor.h
op_qconcat_inplace_to_dense / f_op_qconcat_inplace_to_dense
fn f_op_qconcat_inplace_to_dense(self, tensors: &[&QTensor], dim: i64, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation) -> Result<()>
fn op_qconcat_inplace_to_dense(self, tensors: &[&QTensor], dim: i64, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation)
Wraps api-table member op_qconcat_inplace_to_dense.
ClikaRT::ops::qconcat_ <- ClikaRT/compute/q_tensor.h
op_qconcat_inplace_to_quantized / f_op_qconcat_inplace_to_quantized
fn f_op_qconcat_inplace_to_quantized(self, tensors: &[&QTensor], dim: i64, out: &QTensor, activation: clika_rt_activation) -> Result<()>
fn op_qconcat_inplace_to_quantized(self, tensors: &[&QTensor], dim: i64, out: &QTensor, activation: clika_rt_activation)
Wraps api-table member op_qconcat_inplace_to_quantized.
ClikaRT::ops::qconcat_ <- ClikaRT/compute/q_tensor.h
op_qconcat_to_dense / f_op_qconcat_to_dense
fn f_op_qconcat_to_dense(self, tensors: &[&QTensor], dim: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_qconcat_to_dense(self, tensors: &[&QTensor], dim: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qconcat_to_dense.
ClikaRT::ops::qconcat <- ClikaRT/compute/q_tensor.h
op_qconcat_to_quantized / f_op_qconcat_to_quantized
fn f_op_qconcat_to_quantized(self, tensors: &[&QTensor], dim: i64, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> Result<QTensor>
fn op_qconcat_to_quantized(self, tensors: &[&QTensor], dim: i64, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> QTensor
Wraps api-table member op_qconcat_to_quantized.
ClikaRT::ops::qconcat <- ClikaRT/compute/q_tensor.h
op_qconv1d_to_dense / f_op_qconv1d_to_dense
fn f_op_qconv1d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_qconv1d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qconv1d_to_dense.
ClikaRT::ops::qconv1d <- ClikaRT/compute/q_tensor.h
op_qconv1d_to_quantized / f_op_qconv1d_to_quantized
fn f_op_qconv1d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qconv1d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qconv1d_to_quantized.
ClikaRT::ops::qconv1d <- ClikaRT/compute/q_tensor.h
op_qconv1d_woq / f_op_qconv1d_woq
fn f_op_qconv1d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_qconv1d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qconv1d_woq.
ClikaRT::ops::qconv1d_woq <- ClikaRT/compute/q_tensor.h
op_qconv2d_to_dense / f_op_qconv2d_to_dense
fn f_op_qconv2d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_qconv2d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qconv2d_to_dense.
ClikaRT::ops::qconv2d <- ClikaRT/compute/q_tensor.h
op_qconv2d_to_quantized / f_op_qconv2d_to_quantized
fn f_op_qconv2d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qconv2d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qconv2d_to_quantized.
ClikaRT::ops::qconv2d <- ClikaRT/compute/q_tensor.h
op_qconv2d_woq / f_op_qconv2d_woq
fn f_op_qconv2d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_qconv2d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qconv2d_woq.
ClikaRT::ops::qconv2d_woq <- ClikaRT/compute/q_tensor.h
op_qconv3d_to_dense / f_op_qconv3d_to_dense
fn f_op_qconv3d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_qconv3d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qconv3d_to_dense.
ClikaRT::ops::qconv3d <- ClikaRT/compute/q_tensor.h
op_qconv3d_to_quantized / f_op_qconv3d_to_quantized
fn f_op_qconv3d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qconv3d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qconv3d_to_quantized.
ClikaRT::ops::qconv3d <- ClikaRT/compute/q_tensor.h
op_qconv3d_woq / f_op_qconv3d_woq
fn f_op_qconv3d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Result<Tensor>
fn op_qconv3d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qconv3d_woq.
ClikaRT::ops::qconv3d_woq <- ClikaRT/compute/q_tensor.h
op_qconv_inplace_to_dense / f_op_qconv_inplace_to_dense
fn f_op_qconv_inplace_to_dense(self, a: QTensor, weight: QTensor, out: &Tensor, bias: Tensor, options: &QconvInplaceToDenseOptions) -> Result<()>
fn op_qconv_inplace_to_dense(self, a: QTensor, weight: QTensor, out: &Tensor, bias: Tensor, options: &QconvInplaceToDenseOptions)
Wraps api-table member op_qconv_inplace_to_dense.
ClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h
op_qconv_inplace_to_dense_out_scale / f_op_qconv_inplace_to_dense_out_scale
fn f_op_qconv_inplace_to_dense_out_scale(self, a: QTensor, weight: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, bias: Tensor, options: &QconvInplaceToDenseOutScaleOptions) -> Result<()>
fn op_qconv_inplace_to_dense_out_scale(self, a: QTensor, weight: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, bias: Tensor, options: &QconvInplaceToDenseOutScaleOptions)
Wraps api-table member op_qconv_inplace_to_dense_out_scale.
ClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h
op_qconv_inplace_to_quantized / f_op_qconv_inplace_to_quantized
fn f_op_qconv_inplace_to_quantized(self, a: QTensor, weight: QTensor, out: &QTensor, bias: Tensor, options: &QconvInplaceToQuantizedOptions) -> Result<()>
fn op_qconv_inplace_to_quantized(self, a: QTensor, weight: QTensor, out: &QTensor, bias: Tensor, options: &QconvInplaceToQuantizedOptions)
Wraps api-table member op_qconv_inplace_to_quantized.
ClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h
op_qconv_to_dense / f_op_qconv_to_dense
fn f_op_qconv_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvToDenseOptions) -> Result<Tensor>
fn op_qconv_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvToDenseOptions) -> Tensor
Wraps api-table member op_qconv_to_dense.
ClikaRT::ops::qconv <- ClikaRT/compute/q_tensor.h
op_qconv_to_quantized / f_op_qconv_to_quantized
fn f_op_qconv_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, mode: clika_rt_pad_mode, value_has: bool, value: f64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qconv_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, mode: clika_rt_pad_mode, value_has: bool, value: f64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qconv_to_quantized.
ClikaRT::ops::qconv <- ClikaRT/compute/q_tensor.h
op_qconv_transpose1d_to_dense / f_op_qconv_transpose1d_to_dense
fn f_op_qconv_transpose1d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvTranspose1dToDenseOptions) -> Result<Tensor>
fn op_qconv_transpose1d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvTranspose1dToDenseOptions) -> Tensor
Wraps api-table member op_qconv_transpose1d_to_dense.
ClikaRT::ops::qconv_transpose1d <- ClikaRT/compute/q_tensor.h
op_qconv_transpose1d_to_quantized / f_op_qconv_transpose1d_to_quantized
fn f_op_qconv_transpose1d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qconv_transpose1d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qconv_transpose1d_to_quantized.
ClikaRT::ops::qconv_transpose1d <- ClikaRT/compute/q_tensor.h
op_qconv_transpose1d_woq / f_op_qconv_transpose1d_woq
fn f_op_qconv_transpose1d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvTranspose1dWoqOptions) -> Result<Tensor>
fn op_qconv_transpose1d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvTranspose1dWoqOptions) -> Tensor
Wraps api-table member op_qconv_transpose1d_woq.
ClikaRT::ops::qconv_transpose1d_woq <- ClikaRT/compute/q_tensor.h
op_qconv_transpose2d_to_dense / f_op_qconv_transpose2d_to_dense
fn f_op_qconv_transpose2d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvTranspose2dToDenseOptions) -> Result<Tensor>
fn op_qconv_transpose2d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvTranspose2dToDenseOptions) -> Tensor
Wraps api-table member op_qconv_transpose2d_to_dense.
ClikaRT::ops::qconv_transpose2d <- ClikaRT/compute/q_tensor.h
op_qconv_transpose2d_to_quantized / f_op_qconv_transpose2d_to_quantized
fn f_op_qconv_transpose2d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qconv_transpose2d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qconv_transpose2d_to_quantized.
ClikaRT::ops::qconv_transpose2d <- ClikaRT/compute/q_tensor.h
op_qconv_transpose2d_woq / f_op_qconv_transpose2d_woq
fn f_op_qconv_transpose2d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvTranspose2dWoqOptions) -> Result<Tensor>
fn op_qconv_transpose2d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvTranspose2dWoqOptions) -> Tensor
Wraps api-table member op_qconv_transpose2d_woq.
ClikaRT::ops::qconv_transpose2d_woq <- ClikaRT/compute/q_tensor.h
op_qconv_transpose3d_to_dense / f_op_qconv_transpose3d_to_dense
fn f_op_qconv_transpose3d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvTranspose3dToDenseOptions) -> Result<Tensor>
fn op_qconv_transpose3d_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvTranspose3dToDenseOptions) -> Tensor
Wraps api-table member op_qconv_transpose3d_to_dense.
ClikaRT::ops::qconv_transpose3d <- ClikaRT/compute/q_tensor.h
op_qconv_transpose3d_to_quantized / f_op_qconv_transpose3d_to_quantized
fn f_op_qconv_transpose3d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qconv_transpose3d_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qconv_transpose3d_to_quantized.
ClikaRT::ops::qconv_transpose3d <- ClikaRT/compute/q_tensor.h
op_qconv_transpose3d_woq / f_op_qconv_transpose3d_woq
fn f_op_qconv_transpose3d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvTranspose3dWoqOptions) -> Result<Tensor>
fn op_qconv_transpose3d_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvTranspose3dWoqOptions) -> Tensor
Wraps api-table member op_qconv_transpose3d_woq.
ClikaRT::ops::qconv_transpose3d_woq <- ClikaRT/compute/q_tensor.h
op_qconv_transpose_inplace_to_dense / f_op_qconv_transpose_inplace_to_dense
fn f_op_qconv_transpose_inplace_to_dense(self, a: QTensor, weight: QTensor, out: &Tensor, bias: Tensor, options: &QconvTransposeInplaceToDenseOptions) -> Result<()>
fn op_qconv_transpose_inplace_to_dense(self, a: QTensor, weight: QTensor, out: &Tensor, bias: Tensor, options: &QconvTransposeInplaceToDenseOptions)
Wraps api-table member op_qconv_transpose_inplace_to_dense.
ClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h
op_qconv_transpose_inplace_to_dense_out_scale / f_op_qconv_transpose_inplace_to_dense_out_scale
fn f_op_qconv_transpose_inplace_to_dense_out_scale(self, a: QTensor, weight: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, bias: Tensor, options: &QconvTransposeInplaceToDenseOutScaleOptions) -> Result<()>
fn op_qconv_transpose_inplace_to_dense_out_scale(self, a: QTensor, weight: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, bias: Tensor, options: &QconvTransposeInplaceToDenseOutScaleOptions)
Wraps api-table member op_qconv_transpose_inplace_to_dense_out_scale.
ClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h
op_qconv_transpose_inplace_to_quantized / f_op_qconv_transpose_inplace_to_quantized
fn f_op_qconv_transpose_inplace_to_quantized(self, a: QTensor, weight: QTensor, out: &QTensor, bias: Tensor, options: &QconvTransposeInplaceToQuantizedOptions) -> Result<()>
fn op_qconv_transpose_inplace_to_quantized(self, a: QTensor, weight: QTensor, out: &QTensor, bias: Tensor, options: &QconvTransposeInplaceToQuantizedOptions)
Wraps api-table member op_qconv_transpose_inplace_to_quantized.
ClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h
op_qconv_transpose_to_dense / f_op_qconv_transpose_to_dense
fn f_op_qconv_transpose_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvTransposeToDenseOptions) -> Result<Tensor>
fn op_qconv_transpose_to_dense(self, a: QTensor, weight: QTensor, bias: Tensor, options: &QconvTransposeToDenseOptions) -> Tensor
Wraps api-table member op_qconv_transpose_to_dense.
ClikaRT::ops::qconv_transpose <- ClikaRT/compute/q_tensor.h
op_qconv_transpose_to_quantized / f_op_qconv_transpose_to_quantized
fn f_op_qconv_transpose_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qconv_transpose_to_quantized(self, a: QTensor, weight: QTensor, bias: Tensor, stride: &[i64], padding: &[i64], output_padding: &[i64], dilation: &[i64], groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qconv_transpose_to_quantized.
ClikaRT::ops::qconv_transpose <- ClikaRT/compute/q_tensor.h
op_qconv_transpose_woq / f_op_qconv_transpose_woq
fn f_op_qconv_transpose_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvTransposeWoqOptions) -> Result<Tensor>
fn op_qconv_transpose_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvTransposeWoqOptions) -> Tensor
Wraps api-table member op_qconv_transpose_woq.
ClikaRT::ops::qconv_transpose_woq <- ClikaRT/compute/q_tensor.h
op_qconv_woq / f_op_qconv_woq
fn f_op_qconv_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvWoqOptions) -> Result<Tensor>
fn op_qconv_woq(self, x: Tensor, weight: QTensor, bias: Tensor, options: &QconvWoqOptions) -> Tensor
Wraps api-table member op_qconv_woq.
ClikaRT::ops::qconv_woq <- ClikaRT/compute/q_tensor.h
op_qdeform_conv_to_dense / f_op_qdeform_conv_to_dense
fn f_op_qdeform_conv_to_dense(self, a: QTensor, weight: QTensor, offset: Tensor, mask: Tensor, bias: Tensor, options: &QdeformConvToDenseOptions) -> Result<Tensor>
fn op_qdeform_conv_to_dense(self, a: QTensor, weight: QTensor, offset: Tensor, mask: Tensor, bias: Tensor, options: &QdeformConvToDenseOptions) -> Tensor
Wraps api-table member op_qdeform_conv_to_dense.
ClikaRT::ops::qdeform_conv <- ClikaRT/compute/q_tensor.h
op_qdeform_conv_to_quantized / f_op_qdeform_conv_to_quantized
fn f_op_qdeform_conv_to_quantized(self, a: QTensor, weight: QTensor, offset: Tensor, mask: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, offset_groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qdeform_conv_to_quantized(self, a: QTensor, weight: QTensor, offset: Tensor, mask: Tensor, bias: Tensor, stride: &[i64], padding: &[i64], dilation: &[i64], groups: i64, offset_groups: i64, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qdeform_conv_to_quantized.
ClikaRT::ops::qdeform_conv <- ClikaRT/compute/q_tensor.h
op_qdeform_conv_woq / f_op_qdeform_conv_woq
fn f_op_qdeform_conv_woq(self, x: Tensor, weight: QTensor, offset: Tensor, mask: Tensor, bias: Tensor, options: &QdeformConvWoqOptions) -> Result<Tensor>
fn op_qdeform_conv_woq(self, x: Tensor, weight: QTensor, offset: Tensor, mask: Tensor, bias: Tensor, options: &QdeformConvWoqOptions) -> Tensor
Wraps api-table member op_qdeform_conv_woq.
ClikaRT::ops::qdeform_conv_woq <- ClikaRT/compute/q_tensor.h
op_qdiv_inplace_to_dense / f_op_qdiv_inplace_to_dense
fn f_op_qdiv_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, activation: clika_rt_activation) -> Result<()>
fn op_qdiv_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, activation: clika_rt_activation)
Wraps api-table member op_qdiv_inplace_to_dense.
ClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h
op_qdiv_inplace_to_dense_out_scale / f_op_qdiv_inplace_to_dense_out_scale
fn f_op_qdiv_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation) -> Result<()>
fn op_qdiv_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation)
Wraps api-table member op_qdiv_inplace_to_dense_out_scale.
ClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h
op_qdiv_inplace_to_quantized / f_op_qdiv_inplace_to_quantized
fn f_op_qdiv_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, activation: clika_rt_activation) -> Result<()>
fn op_qdiv_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, activation: clika_rt_activation)
Wraps api-table member op_qdiv_inplace_to_quantized.
ClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h
op_qdiv_to_dense / f_op_qdiv_to_dense
fn f_op_qdiv_to_dense(self, a: QTensor, b: QTensor, activation: clika_rt_activation) -> Result<Tensor>
fn op_qdiv_to_dense(self, a: QTensor, b: QTensor, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qdiv_to_dense.
ClikaRT::ops::qdiv <- ClikaRT/compute/q_tensor.h
op_qdiv_to_quantized / f_op_qdiv_to_quantized
fn f_op_qdiv_to_quantized(self, a: QTensor, b: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> Result<QTensor>
fn op_qdiv_to_quantized(self, a: QTensor, b: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> QTensor
Wraps api-table member op_qdiv_to_quantized.
ClikaRT::ops::qdiv <- ClikaRT/compute/q_tensor.h
op_qfast_gelu_inplace_to_dense / f_op_qfast_gelu_inplace_to_dense
fn f_op_qfast_gelu_inplace_to_dense(self, a: QTensor, out: &Tensor) -> Result<()>
fn op_qfast_gelu_inplace_to_dense(self, a: QTensor, out: &Tensor)
Wraps api-table member op_qfast_gelu_inplace_to_dense.
ClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h
op_qfast_gelu_inplace_to_dense_out_scale / f_op_qfast_gelu_inplace_to_dense_out_scale
fn f_op_qfast_gelu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_qfast_gelu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_qfast_gelu_inplace_to_dense_out_scale.
ClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h
op_qfast_gelu_inplace_to_quantized / f_op_qfast_gelu_inplace_to_quantized
fn f_op_qfast_gelu_inplace_to_quantized(self, a: QTensor, out: &QTensor) -> Result<()>
fn op_qfast_gelu_inplace_to_quantized(self, a: QTensor, out: &QTensor)
Wraps api-table member op_qfast_gelu_inplace_to_quantized.
ClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h
op_qfast_gelu_to_dense / f_op_qfast_gelu_to_dense
fn f_op_qfast_gelu_to_dense(self, a: QTensor) -> Result<Tensor>
fn op_qfast_gelu_to_dense(self, a: QTensor) -> Tensor
Wraps api-table member op_qfast_gelu_to_dense.
ClikaRT::ops::qfast_gelu <- ClikaRT/compute/q_tensor.h
op_qfast_gelu_to_quantized / f_op_qfast_gelu_to_quantized
fn f_op_qfast_gelu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qfast_gelu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qfast_gelu_to_quantized.
ClikaRT::ops::qfast_gelu <- ClikaRT/compute/q_tensor.h
op_qgelu_inplace_to_dense / f_op_qgelu_inplace_to_dense
fn f_op_qgelu_inplace_to_dense(self, a: QTensor, out: &Tensor) -> Result<()>
fn op_qgelu_inplace_to_dense(self, a: QTensor, out: &Tensor)
Wraps api-table member op_qgelu_inplace_to_dense.
ClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h
op_qgelu_inplace_to_dense_out_scale / f_op_qgelu_inplace_to_dense_out_scale
fn f_op_qgelu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_qgelu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_qgelu_inplace_to_dense_out_scale.
ClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h
op_qgelu_inplace_to_quantized / f_op_qgelu_inplace_to_quantized
fn f_op_qgelu_inplace_to_quantized(self, a: QTensor, out: &QTensor) -> Result<()>
fn op_qgelu_inplace_to_quantized(self, a: QTensor, out: &QTensor)
Wraps api-table member op_qgelu_inplace_to_quantized.
ClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h
op_qgelu_to_dense / f_op_qgelu_to_dense
fn f_op_qgelu_to_dense(self, a: QTensor) -> Result<Tensor>
fn op_qgelu_to_dense(self, a: QTensor) -> Tensor
Wraps api-table member op_qgelu_to_dense.
ClikaRT::ops::qgelu <- ClikaRT/compute/q_tensor.h
op_qgelu_to_quantized / f_op_qgelu_to_quantized
fn f_op_qgelu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qgelu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qgelu_to_quantized.
ClikaRT::ops::qgelu <- ClikaRT/compute/q_tensor.h
op_qhardswish_inplace_to_dense / f_op_qhardswish_inplace_to_dense
fn f_op_qhardswish_inplace_to_dense(self, a: QTensor, out: &Tensor) -> Result<()>
fn op_qhardswish_inplace_to_dense(self, a: QTensor, out: &Tensor)
Wraps api-table member op_qhardswish_inplace_to_dense.
ClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h
op_qhardswish_inplace_to_dense_out_scale / f_op_qhardswish_inplace_to_dense_out_scale
fn f_op_qhardswish_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_qhardswish_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_qhardswish_inplace_to_dense_out_scale.
ClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h
op_qhardswish_inplace_to_quantized / f_op_qhardswish_inplace_to_quantized
fn f_op_qhardswish_inplace_to_quantized(self, a: QTensor, out: &QTensor) -> Result<()>
fn op_qhardswish_inplace_to_quantized(self, a: QTensor, out: &QTensor)
Wraps api-table member op_qhardswish_inplace_to_quantized.
ClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h
op_qhardswish_to_dense / f_op_qhardswish_to_dense
fn f_op_qhardswish_to_dense(self, a: QTensor) -> Result<Tensor>
fn op_qhardswish_to_dense(self, a: QTensor) -> Tensor
Wraps api-table member op_qhardswish_to_dense.
ClikaRT::ops::qhardswish <- ClikaRT/compute/q_tensor.h
op_qhardswish_to_quantized / f_op_qhardswish_to_quantized
fn f_op_qhardswish_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qhardswish_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qhardswish_to_quantized.
ClikaRT::ops::qhardswish <- ClikaRT/compute/q_tensor.h
op_qk_layer_norm / f_op_qk_layer_norm
fn f_op_qk_layer_norm(self, q: Tensor, k: Tensor, v: Tensor, w_q: Tensor, b_q: Tensor, w_k: Tensor, b_k: Tensor, head_dim: i64, eps_has: bool, eps: f64) -> Result<(Tensor, Tensor, Tensor)>
fn op_qk_layer_norm(self, q: Tensor, k: Tensor, v: Tensor, w_q: Tensor, b_q: Tensor, w_k: Tensor, b_k: Tensor, head_dim: i64, eps_has: bool, eps: f64) -> (Tensor, Tensor, Tensor)
Wraps api-table member op_qk_layer_norm.
ClikaRT::ops::qk_layer_norm <- ClikaRT/compute/ops.h
op_qk_layer_norm_inplace / f_op_qk_layer_norm_inplace
fn f_op_qk_layer_norm_inplace(self, q: &Tensor, k: Tensor, v: Tensor, w_q: Tensor, b_q: Tensor, w_k: Tensor, b_k: Tensor, head_dim: i64, eps_has: bool, eps: f64) -> Result<()>
fn op_qk_layer_norm_inplace(self, q: &Tensor, k: Tensor, v: Tensor, w_q: Tensor, b_q: Tensor, w_k: Tensor, b_k: Tensor, head_dim: i64, eps_has: bool, eps: f64)
Wraps api-table member op_qk_layer_norm_inplace.
ClikaRT::ops::qk_layer_norm_ <- ClikaRT/compute/ops.h
op_qk_rms_norm / f_op_qk_rms_norm
fn f_op_qk_rms_norm(self, q: Tensor, k: Tensor, v: Tensor, w_q: Tensor, w_k: Tensor, head_dim: i64, eps_has: bool, eps: f64) -> Result<(Tensor, Tensor, Tensor)>
fn op_qk_rms_norm(self, q: Tensor, k: Tensor, v: Tensor, w_q: Tensor, w_k: Tensor, head_dim: i64, eps_has: bool, eps: f64) -> (Tensor, Tensor, Tensor)
Wraps api-table member op_qk_rms_norm.
ClikaRT::ops::qk_rms_norm <- ClikaRT/compute/ops.h
op_qk_rms_norm_inplace / f_op_qk_rms_norm_inplace
fn f_op_qk_rms_norm_inplace(self, q: &Tensor, k: Tensor, v: Tensor, w_q: Tensor, w_k: Tensor, head_dim: i64, eps_has: bool, eps: f64) -> Result<()>
fn op_qk_rms_norm_inplace(self, q: &Tensor, k: Tensor, v: Tensor, w_q: Tensor, w_k: Tensor, head_dim: i64, eps_has: bool, eps: f64)
Wraps api-table member op_qk_rms_norm_inplace.
ClikaRT::ops::qk_rms_norm_ <- ClikaRT/compute/ops.h
op_qleaky_relu_inplace_to_dense / f_op_qleaky_relu_inplace_to_dense
fn f_op_qleaky_relu_inplace_to_dense(self, a: QTensor, negative_slope: f64, out: &Tensor) -> Result<()>
fn op_qleaky_relu_inplace_to_dense(self, a: QTensor, negative_slope: f64, out: &Tensor)
Wraps api-table member op_qleaky_relu_inplace_to_dense.
ClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h
op_qleaky_relu_inplace_to_dense_out_scale / f_op_qleaky_relu_inplace_to_dense_out_scale
fn f_op_qleaky_relu_inplace_to_dense_out_scale(self, a: QTensor, negative_slope: f64, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_qleaky_relu_inplace_to_dense_out_scale(self, a: QTensor, negative_slope: f64, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_qleaky_relu_inplace_to_dense_out_scale.
ClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h
op_qleaky_relu_inplace_to_quantized / f_op_qleaky_relu_inplace_to_quantized
fn f_op_qleaky_relu_inplace_to_quantized(self, a: QTensor, negative_slope: f64, out: &QTensor) -> Result<()>
fn op_qleaky_relu_inplace_to_quantized(self, a: QTensor, negative_slope: f64, out: &QTensor)
Wraps api-table member op_qleaky_relu_inplace_to_quantized.
ClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h
op_qleaky_relu_to_dense / f_op_qleaky_relu_to_dense
fn f_op_qleaky_relu_to_dense(self, a: QTensor, negative_slope: f64) -> Result<Tensor>
fn op_qleaky_relu_to_dense(self, a: QTensor, negative_slope: f64) -> Tensor
Wraps api-table member op_qleaky_relu_to_dense.
ClikaRT::ops::qleaky_relu <- ClikaRT/compute/q_tensor.h
op_qleaky_relu_to_quantized / f_op_qleaky_relu_to_quantized
fn f_op_qleaky_relu_to_quantized(self, a: QTensor, negative_slope: f64, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qleaky_relu_to_quantized(self, a: QTensor, negative_slope: f64, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qleaky_relu_to_quantized.
ClikaRT::ops::qleaky_relu <- ClikaRT/compute/q_tensor.h
op_qlinear_inplace_to_dense / f_op_qlinear_inplace_to_dense
fn f_op_qlinear_inplace_to_dense(self, x: QTensor, weight: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<()>
fn op_qlinear_inplace_to_dense(self, x: QTensor, weight: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation)
Wraps api-table member op_qlinear_inplace_to_dense.
ClikaRT::ops::qlinear_ <- ClikaRT/compute/q_tensor.h
op_qlinear_inplace_to_quantized / f_op_qlinear_inplace_to_quantized
fn f_op_qlinear_inplace_to_quantized(self, x: QTensor, weight: QTensor, out: &QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<()>
fn op_qlinear_inplace_to_quantized(self, x: QTensor, weight: QTensor, out: &QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation)
Wraps api-table member op_qlinear_inplace_to_quantized.
ClikaRT::ops::qlinear_ <- ClikaRT/compute/q_tensor.h
op_qlinear_to_dense / f_op_qlinear_to_dense
fn f_op_qlinear_to_dense(self, x: QTensor, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn op_qlinear_to_dense(self, x: QTensor, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qlinear_to_dense.
ClikaRT::ops::qlinear <- ClikaRT/compute/q_tensor.h
op_qlinear_to_quantized / f_op_qlinear_to_quantized
fn f_op_qlinear_to_quantized(self, x: QTensor, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qlinear_to_quantized(self, x: QTensor, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qlinear_to_quantized.
ClikaRT::ops::qlinear <- ClikaRT/compute/q_tensor.h
op_qlinear_woq / f_op_qlinear_woq
fn f_op_qlinear_woq(self, x: Tensor, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, compute_mode: clika_rt_qcompute_mode) -> Result<Tensor>
fn op_qlinear_woq(self, x: Tensor, weight: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, compute_mode: clika_rt_qcompute_mode) -> Tensor
Wraps api-table member op_qlinear_woq.
ClikaRT::ops::qlinear_woq <- ClikaRT/compute/q_tensor.h
op_qlinear_woq_inplace / f_op_qlinear_woq_inplace
fn f_op_qlinear_woq_inplace(self, x: Tensor, weight: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, compute_mode: clika_rt_qcompute_mode) -> Result<()>
fn op_qlinear_woq_inplace(self, x: Tensor, weight: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, compute_mode: clika_rt_qcompute_mode)
Wraps api-table member op_qlinear_woq_inplace.
ClikaRT::ops::qlinear_woq_ <- ClikaRT/compute/q_tensor.h
op_qmatmul_inplace_to_dense / f_op_qmatmul_inplace_to_dense
fn f_op_qmatmul_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool) -> Result<()>
fn op_qmatmul_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool)
Wraps api-table member op_qmatmul_inplace_to_dense.
ClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h
op_qmatmul_inplace_to_dense_out_scale / f_op_qmatmul_inplace_to_dense_out_scale
fn f_op_qmatmul_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, bias: Tensor, options: &QmatmulInplaceToDenseOutScaleOptions) -> Result<()>
fn op_qmatmul_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, bias: Tensor, options: &QmatmulInplaceToDenseOutScaleOptions)
Wraps api-table member op_qmatmul_inplace_to_dense_out_scale.
ClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h
op_qmatmul_inplace_to_quantized / f_op_qmatmul_inplace_to_quantized
fn f_op_qmatmul_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool) -> Result<()>
fn op_qmatmul_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool)
Wraps api-table member op_qmatmul_inplace_to_quantized.
ClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h
op_qmatmul_to_dense / f_op_qmatmul_to_dense
fn f_op_qmatmul_to_dense(self, a: QTensor, b: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool) -> Result<Tensor>
fn op_qmatmul_to_dense(self, a: QTensor, b: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool) -> Tensor
Wraps api-table member op_qmatmul_to_dense.
ClikaRT::ops::qmatmul <- ClikaRT/compute/q_tensor.h
op_qmatmul_to_quantized / f_op_qmatmul_to_quantized
fn f_op_qmatmul_to_quantized(self, a: QTensor, b: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qmatmul_to_quantized(self, a: QTensor, b: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qmatmul_to_quantized.
ClikaRT::ops::qmatmul <- ClikaRT/compute/q_tensor.h
op_qmatmul_woq / f_op_qmatmul_woq
fn f_op_qmatmul_woq(self, a: Tensor, b: 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 op_qmatmul_woq(self, a: Tensor, b: QTensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, compute_mode: clika_rt_qcompute_mode) -> Tensor
Wraps api-table member op_qmatmul_woq.
ClikaRT::ops::qmatmul_woq <- ClikaRT/compute/q_tensor.h
op_qmatmul_woq_inplace / f_op_qmatmul_woq_inplace
fn f_op_qmatmul_woq_inplace(self, a: Tensor, b: 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 op_qmatmul_woq_inplace(self, a: Tensor, b: QTensor, out: &Tensor, bias: Tensor, activation_has: bool, activation: clika_rt_activation, transpose_a: bool, transpose_b: bool, compute_mode: clika_rt_qcompute_mode)
Wraps api-table member op_qmatmul_woq_inplace.
ClikaRT::ops::qmatmul_woq_ <- ClikaRT/compute/q_tensor.h
op_qmoe_to_dense / f_op_qmoe_to_dense
fn f_op_qmoe_to_dense(self, input: QTensor, 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: &QmoeToDenseOptions) -> Result<Tensor>
fn op_qmoe_to_dense(self, input: QTensor, 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: &QmoeToDenseOptions) -> Tensor
Wraps api-table member op_qmoe_to_dense.
ClikaRT::ops::qmoe <- ClikaRT/compute/q_tensor.h
op_qmoe_to_quantized / f_op_qmoe_to_quantized
fn f_op_qmoe_to_quantized(self, input: QTensor, 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, routing_mode_has: bool, routing_mode: clika_rt_moe_routing, renormalize_has: bool, renormalize: bool, n_group_has: bool, n_group: i64, topk_group_has: bool, topk_group: i64, routed_scaling_factor_has: bool, routed_scaling_factor: f64, sparse_mixer_eps_has: bool, sparse_mixer_eps: f64, apply_router_weight_on_input_has: bool, apply_router_weight_on_input: bool, activation_has: bool, activation: clika_rt_activation, swiglu_fusion_has: bool, swiglu_fusion: clika_rt_swiglu_fusion, swiglu_alpha_has: bool, swiglu_alpha: f64, swiglu_beta_has: bool, swiglu_beta: f64, swiglu_limit_has: bool, swiglu_limit: f64, gelu_mode_has: bool, gelu_mode: clika_rt_gelu_mode, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, shared_output: Tensor) -> Result<QTensor>
fn op_qmoe_to_quantized(self, input: QTensor, 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, routing_mode_has: bool, routing_mode: clika_rt_moe_routing, renormalize_has: bool, renormalize: bool, n_group_has: bool, n_group: i64, topk_group_has: bool, topk_group: i64, routed_scaling_factor_has: bool, routed_scaling_factor: f64, sparse_mixer_eps_has: bool, sparse_mixer_eps: f64, apply_router_weight_on_input_has: bool, apply_router_weight_on_input: bool, activation_has: bool, activation: clika_rt_activation, swiglu_fusion_has: bool, swiglu_fusion: clika_rt_swiglu_fusion, swiglu_alpha_has: bool, swiglu_alpha: f64, swiglu_beta_has: bool, swiglu_beta: f64, swiglu_limit_has: bool, swiglu_limit: f64, gelu_mode_has: bool, gelu_mode: clika_rt_gelu_mode, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, shared_output: Tensor) -> QTensor
Wraps api-table member op_qmoe_to_quantized.
ClikaRT::ops::qmoe <- ClikaRT/compute/q_tensor.h
op_qmoe_woq / f_op_qmoe_woq
fn f_op_qmoe_woq(self, input: Tensor, 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 op_qmoe_woq(self, input: Tensor, 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
Wraps api-table member op_qmoe_woq.
ClikaRT::ops::qmoe_woq <- ClikaRT/compute/q_tensor.h
op_qmul_inplace_to_dense / f_op_qmul_inplace_to_dense
fn f_op_qmul_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, activation: clika_rt_activation) -> Result<()>
fn op_qmul_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, activation: clika_rt_activation)
Wraps api-table member op_qmul_inplace_to_dense.
ClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h
op_qmul_inplace_to_dense_out_scale / f_op_qmul_inplace_to_dense_out_scale
fn f_op_qmul_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation) -> Result<()>
fn op_qmul_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation)
Wraps api-table member op_qmul_inplace_to_dense_out_scale.
ClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h
op_qmul_inplace_to_quantized / f_op_qmul_inplace_to_quantized
fn f_op_qmul_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, activation: clika_rt_activation) -> Result<()>
fn op_qmul_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, activation: clika_rt_activation)
Wraps api-table member op_qmul_inplace_to_quantized.
ClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h
op_qmul_to_dense / f_op_qmul_to_dense
fn f_op_qmul_to_dense(self, a: QTensor, b: QTensor, activation: clika_rt_activation) -> Result<Tensor>
fn op_qmul_to_dense(self, a: QTensor, b: QTensor, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qmul_to_dense.
ClikaRT::ops::qmul <- ClikaRT/compute/q_tensor.h
op_qmul_to_quantized / f_op_qmul_to_quantized
fn f_op_qmul_to_quantized(self, a: QTensor, b: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> Result<QTensor>
fn op_qmul_to_quantized(self, a: QTensor, b: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> QTensor
Wraps api-table member op_qmul_to_quantized.
ClikaRT::ops::qmul <- ClikaRT/compute/q_tensor.h
op_qquick_gelu_inplace_to_dense / f_op_qquick_gelu_inplace_to_dense
fn f_op_qquick_gelu_inplace_to_dense(self, a: QTensor, out: &Tensor) -> Result<()>
fn op_qquick_gelu_inplace_to_dense(self, a: QTensor, out: &Tensor)
Wraps api-table member op_qquick_gelu_inplace_to_dense.
ClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h
op_qquick_gelu_inplace_to_dense_out_scale / f_op_qquick_gelu_inplace_to_dense_out_scale
fn f_op_qquick_gelu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_qquick_gelu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_qquick_gelu_inplace_to_dense_out_scale.
ClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h
op_qquick_gelu_inplace_to_quantized / f_op_qquick_gelu_inplace_to_quantized
fn f_op_qquick_gelu_inplace_to_quantized(self, a: QTensor, out: &QTensor) -> Result<()>
fn op_qquick_gelu_inplace_to_quantized(self, a: QTensor, out: &QTensor)
Wraps api-table member op_qquick_gelu_inplace_to_quantized.
ClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h
op_qquick_gelu_to_dense / f_op_qquick_gelu_to_dense
fn f_op_qquick_gelu_to_dense(self, a: QTensor) -> Result<Tensor>
fn op_qquick_gelu_to_dense(self, a: QTensor) -> Tensor
Wraps api-table member op_qquick_gelu_to_dense.
ClikaRT::ops::qquick_gelu <- ClikaRT/compute/q_tensor.h
op_qquick_gelu_to_quantized / f_op_qquick_gelu_to_quantized
fn f_op_qquick_gelu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qquick_gelu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qquick_gelu_to_quantized.
ClikaRT::ops::qquick_gelu <- ClikaRT/compute/q_tensor.h
op_qrelu_inplace_to_dense / f_op_qrelu_inplace_to_dense
fn f_op_qrelu_inplace_to_dense(self, a: QTensor, out: &Tensor) -> Result<()>
fn op_qrelu_inplace_to_dense(self, a: QTensor, out: &Tensor)
Wraps api-table member op_qrelu_inplace_to_dense.
ClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h
op_qrelu_inplace_to_dense_out_scale / f_op_qrelu_inplace_to_dense_out_scale
fn f_op_qrelu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_qrelu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_qrelu_inplace_to_dense_out_scale.
ClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h
op_qrelu_inplace_to_quantized / f_op_qrelu_inplace_to_quantized
fn f_op_qrelu_inplace_to_quantized(self, a: QTensor, out: &QTensor) -> Result<()>
fn op_qrelu_inplace_to_quantized(self, a: QTensor, out: &QTensor)
Wraps api-table member op_qrelu_inplace_to_quantized.
ClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h
op_qrelu_to_dense / f_op_qrelu_to_dense
fn f_op_qrelu_to_dense(self, a: QTensor) -> Result<Tensor>
fn op_qrelu_to_dense(self, a: QTensor) -> Tensor
Wraps api-table member op_qrelu_to_dense.
ClikaRT::ops::qrelu <- ClikaRT/compute/q_tensor.h
op_qrelu_to_quantized / f_op_qrelu_to_quantized
fn f_op_qrelu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qrelu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qrelu_to_quantized.
ClikaRT::ops::qrelu <- ClikaRT/compute/q_tensor.h
op_qsigmoid_inplace_to_dense / f_op_qsigmoid_inplace_to_dense
fn f_op_qsigmoid_inplace_to_dense(self, a: QTensor, out: &Tensor) -> Result<()>
fn op_qsigmoid_inplace_to_dense(self, a: QTensor, out: &Tensor)
Wraps api-table member op_qsigmoid_inplace_to_dense.
ClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h
op_qsigmoid_inplace_to_dense_out_scale / f_op_qsigmoid_inplace_to_dense_out_scale
fn f_op_qsigmoid_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_qsigmoid_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_qsigmoid_inplace_to_dense_out_scale.
ClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h
op_qsigmoid_inplace_to_quantized / f_op_qsigmoid_inplace_to_quantized
fn f_op_qsigmoid_inplace_to_quantized(self, a: QTensor, out: &QTensor) -> Result<()>
fn op_qsigmoid_inplace_to_quantized(self, a: QTensor, out: &QTensor)
Wraps api-table member op_qsigmoid_inplace_to_quantized.
ClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h
op_qsigmoid_to_dense / f_op_qsigmoid_to_dense
fn f_op_qsigmoid_to_dense(self, a: QTensor) -> Result<Tensor>
fn op_qsigmoid_to_dense(self, a: QTensor) -> Tensor
Wraps api-table member op_qsigmoid_to_dense.
ClikaRT::ops::qsigmoid <- ClikaRT/compute/q_tensor.h
op_qsigmoid_to_quantized / f_op_qsigmoid_to_quantized
fn f_op_qsigmoid_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qsigmoid_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qsigmoid_to_quantized.
ClikaRT::ops::qsigmoid <- ClikaRT/compute/q_tensor.h
op_qsilu_inplace_to_dense / f_op_qsilu_inplace_to_dense
fn f_op_qsilu_inplace_to_dense(self, a: QTensor, out: &Tensor) -> Result<()>
fn op_qsilu_inplace_to_dense(self, a: QTensor, out: &Tensor)
Wraps api-table member op_qsilu_inplace_to_dense.
ClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h
op_qsilu_inplace_to_dense_out_scale / f_op_qsilu_inplace_to_dense_out_scale
fn f_op_qsilu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_qsilu_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_qsilu_inplace_to_dense_out_scale.
ClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h
op_qsilu_inplace_to_quantized / f_op_qsilu_inplace_to_quantized
fn f_op_qsilu_inplace_to_quantized(self, a: QTensor, out: &QTensor) -> Result<()>
fn op_qsilu_inplace_to_quantized(self, a: QTensor, out: &QTensor)
Wraps api-table member op_qsilu_inplace_to_quantized.
ClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h
op_qsilu_to_dense / f_op_qsilu_to_dense
fn f_op_qsilu_to_dense(self, a: QTensor) -> Result<Tensor>
fn op_qsilu_to_dense(self, a: QTensor) -> Tensor
Wraps api-table member op_qsilu_to_dense.
ClikaRT::ops::qsilu <- ClikaRT/compute/q_tensor.h
op_qsilu_to_quantized / f_op_qsilu_to_quantized
fn f_op_qsilu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qsilu_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qsilu_to_quantized.
ClikaRT::ops::qsilu <- ClikaRT/compute/q_tensor.h
op_qsub_inplace_to_dense / f_op_qsub_inplace_to_dense
fn f_op_qsub_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, activation: clika_rt_activation) -> Result<()>
fn op_qsub_inplace_to_dense(self, a: QTensor, b: QTensor, out: &Tensor, activation: clika_rt_activation)
Wraps api-table member op_qsub_inplace_to_dense.
ClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h
op_qsub_inplace_to_dense_out_scale / f_op_qsub_inplace_to_dense_out_scale
fn f_op_qsub_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation) -> Result<()>
fn op_qsub_inplace_to_dense_out_scale(self, a: QTensor, b: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, activation: clika_rt_activation)
Wraps api-table member op_qsub_inplace_to_dense_out_scale.
ClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h
op_qsub_inplace_to_quantized / f_op_qsub_inplace_to_quantized
fn f_op_qsub_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, activation: clika_rt_activation) -> Result<()>
fn op_qsub_inplace_to_quantized(self, a: QTensor, b: QTensor, out: &QTensor, activation: clika_rt_activation)
Wraps api-table member op_qsub_inplace_to_quantized.
ClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h
op_qsub_to_dense / f_op_qsub_to_dense
fn f_op_qsub_to_dense(self, a: QTensor, b: QTensor, activation: clika_rt_activation) -> Result<Tensor>
fn op_qsub_to_dense(self, a: QTensor, b: QTensor, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_qsub_to_dense.
ClikaRT::ops::qsub <- ClikaRT/compute/q_tensor.h
op_qsub_to_quantized / f_op_qsub_to_quantized
fn f_op_qsub_to_quantized(self, a: QTensor, b: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> Result<QTensor>
fn op_qsub_to_quantized(self, a: QTensor, b: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type, activation: clika_rt_activation) -> QTensor
Wraps api-table member op_qsub_to_quantized.
ClikaRT::ops::qsub <- ClikaRT/compute/q_tensor.h
op_qtanh_inplace_to_dense / f_op_qtanh_inplace_to_dense
fn f_op_qtanh_inplace_to_dense(self, a: QTensor, out: &Tensor) -> Result<()>
fn op_qtanh_inplace_to_dense(self, a: QTensor, out: &Tensor)
Wraps api-table member op_qtanh_inplace_to_dense.
ClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h
op_qtanh_inplace_to_dense_out_scale / f_op_qtanh_inplace_to_dense_out_scale
fn f_op_qtanh_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_qtanh_inplace_to_dense_out_scale(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_qtanh_inplace_to_dense_out_scale.
ClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h
op_qtanh_inplace_to_quantized / f_op_qtanh_inplace_to_quantized
fn f_op_qtanh_inplace_to_quantized(self, a: QTensor, out: &QTensor) -> Result<()>
fn op_qtanh_inplace_to_quantized(self, a: QTensor, out: &QTensor)
Wraps api-table member op_qtanh_inplace_to_quantized.
ClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h
op_qtanh_to_dense / f_op_qtanh_to_dense
fn f_op_qtanh_to_dense(self, a: QTensor) -> Result<Tensor>
fn op_qtanh_to_dense(self, a: QTensor) -> Tensor
Wraps api-table member op_qtanh_to_dense.
ClikaRT::ops::qtanh <- ClikaRT/compute/q_tensor.h
op_qtanh_to_quantized / f_op_qtanh_to_quantized
fn f_op_qtanh_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_qtanh_to_quantized(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_qtanh_to_quantized.
ClikaRT::ops::qtanh <- ClikaRT/compute/q_tensor.h
op_quantile / f_op_quantile
fn f_op_quantile(self, x: Tensor, q: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, keepdim: bool, interpolation: clika_rt_quantile_interp) -> Result<Tensor>
fn op_quantile(self, x: Tensor, q: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, keepdim: bool, interpolation: clika_rt_quantile_interp) -> Tensor
Wraps api-table member op_quantile.
ClikaRT::ops::quantile <- ClikaRT/compute/ops.h
op_quantize / f_op_quantize
fn f_op_quantize(self, x: Tensor, scale: Tensor, zero_point: Tensor, quant_axis: i64, out_dtype: clika_rt_data_type, block_size: i64) -> Result<QTensor>
fn op_quantize(self, x: Tensor, scale: Tensor, zero_point: Tensor, quant_axis: i64, out_dtype: clika_rt_data_type, block_size: i64) -> QTensor
Wraps api-table member op_quantize.
ClikaRT::ops::quantize <- ClikaRT/compute/q_tensor.h
op_quantize_dequantize / f_op_quantize_dequantize
fn f_op_quantize_dequantize(self, x: Tensor, 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 op_quantize_dequantize(self, x: Tensor, scale: Tensor, zero_point: Tensor, quant_axis: i64, code_dtype: clika_rt_data_type, out_dtype: clika_rt_data_type, block_size: i64) -> Tensor
Wraps api-table member op_quantize_dequantize.
ClikaRT::ops::quantize_dequantize <- ClikaRT/compute/q_tensor.h
op_quantize_inplace_to_dense / f_op_quantize_inplace_to_dense
fn f_op_quantize_inplace_to_dense(self, x: Tensor, out: &Tensor, scale: Tensor, zero_point: Tensor, quant_axis: i64, block_size: i64) -> Result<()>
fn op_quantize_inplace_to_dense(self, x: Tensor, out: &Tensor, scale: Tensor, zero_point: Tensor, quant_axis: i64, block_size: i64)
Wraps api-table member op_quantize_inplace_to_dense.
ClikaRT::ops::quantize_ <- ClikaRT/compute/q_tensor.h
op_quantize_inplace_to_quantized / f_op_quantize_inplace_to_quantized
fn f_op_quantize_inplace_to_quantized(self, x: Tensor, out: &QTensor) -> Result<()>
fn op_quantize_inplace_to_quantized(self, x: Tensor, out: &QTensor)
Wraps api-table member op_quantize_inplace_to_quantized.
ClikaRT::ops::quantize_ <- ClikaRT/compute/q_tensor.h
op_quantize_to_scheme / f_op_quantize_to_scheme
fn f_op_quantize_to_scheme(self, x: Tensor, scheme: &str, scale: Tensor) -> Result<QTensor>
fn op_quantize_to_scheme(self, x: Tensor, scheme: &str, scale: Tensor) -> QTensor
Wraps api-table member op_quantize_to_scheme.
ClikaRT::ops::quantize_to_scheme <- ClikaRT/compute/q_tensor.h
op_quick_gelu / f_op_quick_gelu
fn f_op_quick_gelu(self, x: Tensor) -> Result<Tensor>
fn op_quick_gelu(self, x: Tensor) -> Tensor
Wraps api-table member op_quick_gelu.
ClikaRT::ops::quick_gelu <- ClikaRT/compute/ops.h
op_rad2deg / f_op_rad2deg
fn f_op_rad2deg(self, x: Tensor) -> Result<Tensor>
fn op_rad2deg(self, x: Tensor) -> Tensor
Wraps api-table member op_rad2deg.
ClikaRT::ops::rad2deg <- ClikaRT/compute/ops.h
op_rad2deg_inplace / f_op_rad2deg_inplace
fn f_op_rad2deg_inplace(self, self_: &Tensor) -> Result<()>
fn op_rad2deg_inplace(self, self_: &Tensor)
Wraps api-table member op_rad2deg_inplace.
ClikaRT::ops::rad2deg_ <- ClikaRT/compute/ops.h
op_rand / f_op_rand
fn f_op_rand(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_rand(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_rand.
ClikaRT::ops::rand <- ClikaRT/compute/ops.h
op_rand_like / f_op_rand_like
fn f_op_rand_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_rand_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_rand_like.
ClikaRT::ops::rand_like <- ClikaRT/compute/ops.h
op_randint / f_op_randint
fn f_op_randint(self, low: i64, high: i64, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_randint(self, low: i64, high: i64, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_randint.
ClikaRT::ops::randint <- ClikaRT/compute/ops.h
op_randint_like / f_op_randint_like
fn f_op_randint_like(self, reference: Tensor, low: i64, high: i64, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_randint_like(self, reference: Tensor, low: i64, high: i64, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_randint_like.
ClikaRT::ops::randint_like <- ClikaRT/compute/ops.h
op_randn / f_op_randn
fn f_op_randn(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_randn(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_randn.
ClikaRT::ops::randn <- ClikaRT/compute/ops.h
op_randn_like / f_op_randn_like
fn f_op_randn_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_randn_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_randn_like.
ClikaRT::ops::randn_like <- ClikaRT/compute/ops.h
op_random_inplace / f_op_random_inplace
fn f_op_random_inplace(self, self_: &Tensor, low_has: bool, low: i64, high_has: bool, high: i64, s: clika_rt_stream_or_device) -> Result<()>
fn op_random_inplace(self, self_: &Tensor, low_has: bool, low: i64, high_has: bool, high: i64, s: clika_rt_stream_or_device)
Wraps api-table member op_random_inplace.
ClikaRT::ops::random_ <- ClikaRT/compute/ops.h
op_randperm / f_op_randperm
fn f_op_randperm(self, n: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_randperm(self, n: clika_rt_scalar_or_tensor, dtype: clika_rt_data_type, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_randperm.
ClikaRT::ops::randperm <- ClikaRT/compute/ops.h
op_reciprocal / f_op_reciprocal
fn f_op_reciprocal(self, x: Tensor) -> Result<Tensor>
fn op_reciprocal(self, x: Tensor) -> Tensor
Wraps api-table member op_reciprocal.
ClikaRT::ops::reciprocal <- ClikaRT/compute/ops.h
op_reciprocal_inplace / f_op_reciprocal_inplace
fn f_op_reciprocal_inplace(self, self_: &Tensor) -> Result<()>
fn op_reciprocal_inplace(self, self_: &Tensor)
Wraps api-table member op_reciprocal_inplace.
ClikaRT::ops::reciprocal_ <- ClikaRT/compute/ops.h
op_reflect_pad / f_op_reflect_pad
fn f_op_reflect_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn op_reflect_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor]) -> Tensor
Wraps api-table member op_reflect_pad.
ClikaRT::ops::reflect_pad <- ClikaRT/compute/ops.h
op_reglu / f_op_reglu
fn f_op_reglu(self, x: Tensor) -> Result<Tensor>
fn op_reglu(self, x: Tensor) -> Tensor
Wraps api-table member op_reglu.
ClikaRT::ops::reglu <- ClikaRT/compute/ops.h
op_relu / f_op_relu
fn f_op_relu(self, x: Tensor) -> Result<Tensor>
fn op_relu(self, x: Tensor) -> Tensor
Wraps api-table member op_relu.
ClikaRT::ops::relu <- ClikaRT/compute/ops.h
op_relu6 / f_op_relu6
fn f_op_relu6(self, x: Tensor) -> Result<Tensor>
fn op_relu6(self, x: Tensor) -> Tensor
Wraps api-table member op_relu6.
ClikaRT::ops::relu6 <- ClikaRT/compute/ops.h
op_relu6_inplace / f_op_relu6_inplace
fn f_op_relu6_inplace(self, self_: &Tensor) -> Result<()>
fn op_relu6_inplace(self, self_: &Tensor)
Wraps api-table member op_relu6_inplace.
ClikaRT::ops::relu6_ <- ClikaRT/compute/ops.h
op_relu_inplace / f_op_relu_inplace
fn f_op_relu_inplace(self, self_: &Tensor) -> Result<()>
fn op_relu_inplace(self, self_: &Tensor)
Wraps api-table member op_relu_inplace.
ClikaRT::ops::relu_ <- ClikaRT/compute/ops.h
op_remainder / f_op_remainder
fn f_op_remainder(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_remainder(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_remainder.
ClikaRT::ops::remainder <- ClikaRT/compute/ops.h
op_remainder_inplace / f_op_remainder_inplace
fn f_op_remainder_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_remainder_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_remainder_inplace.
ClikaRT::ops::remainder_ <- ClikaRT/compute/ops.h
op_renorm / f_op_renorm
fn f_op_renorm(self, x: Tensor, p: clika_rt_scalar, dim: i64, maxnorm: clika_rt_scalar, eps_has: bool, eps: f64) -> Result<Tensor>
fn op_renorm(self, x: Tensor, p: clika_rt_scalar, dim: i64, maxnorm: clika_rt_scalar, eps_has: bool, eps: f64) -> Tensor
Wraps api-table member op_renorm.
ClikaRT::ops::renorm <- ClikaRT/compute/ops.h
op_renorm_inplace / f_op_renorm_inplace
fn f_op_renorm_inplace(self, self_: &Tensor, p: clika_rt_scalar, dim: i64, maxnorm: clika_rt_scalar, eps_has: bool, eps: f64) -> Result<()>
fn op_renorm_inplace(self, self_: &Tensor, p: clika_rt_scalar, dim: i64, maxnorm: clika_rt_scalar, eps_has: bool, eps: f64)
Wraps api-table member op_renorm_inplace.
ClikaRT::ops::renorm_ <- ClikaRT/compute/ops.h
op_repeat / f_op_repeat
fn f_op_repeat(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn op_repeat(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor]) -> Tensor
Wraps api-table member op_repeat.
ClikaRT::ops::repeat <- ClikaRT/compute/ops.h
op_repeat_interleave / f_op_repeat_interleave
fn f_op_repeat_interleave(self, x: Tensor, repeats: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, output_size_has: bool, output_size: i64) -> Result<Tensor>
fn op_repeat_interleave(self, x: Tensor, repeats: clika_rt_scalar_or_tensor, dim_has: bool, dim: i64, output_size_has: bool, output_size: i64) -> Tensor
Wraps api-table member op_repeat_interleave.
ClikaRT::ops::repeat_interleave <- ClikaRT/compute/ops.h
op_replicate_pad / f_op_replicate_pad
fn f_op_replicate_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn op_replicate_pad(self, x: Tensor, pad: &[clika_rt_scalar_or_tensor]) -> Tensor
Wraps api-table member op_replicate_pad.
ClikaRT::ops::replicate_pad <- ClikaRT/compute/ops.h
op_requantize / f_op_requantize
fn f_op_requantize(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> Result<QTensor>
fn op_requantize(self, a: QTensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64, out_dtype: clika_rt_data_type) -> QTensor
Wraps api-table member op_requantize.
ClikaRT::ops::requantize <- ClikaRT/compute/q_tensor.h
op_requantize_inplace_to_dense / f_op_requantize_inplace_to_dense
fn f_op_requantize_inplace_to_dense(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64) -> Result<()>
fn op_requantize_inplace_to_dense(self, a: QTensor, out: &Tensor, out_scale: Tensor, out_zero_point: Tensor, out_quant_axis: i64)
Wraps api-table member op_requantize_inplace_to_dense.
ClikaRT::ops::requantize_ <- ClikaRT/compute/q_tensor.h
op_requantize_inplace_to_quantized / f_op_requantize_inplace_to_quantized
fn f_op_requantize_inplace_to_quantized(self, a: QTensor, out: &QTensor) -> Result<()>
fn op_requantize_inplace_to_quantized(self, a: QTensor, out: &QTensor)
Wraps api-table member op_requantize_inplace_to_quantized.
ClikaRT::ops::requantize_ <- ClikaRT/compute/q_tensor.h
op_resample / f_op_resample
fn f_op_resample(self, x: Tensor, orig_freq: i64, new_freq: i64, lowpass_filter_width: i64, rolloff: f64, beta_has: bool, beta: f64) -> Result<Tensor>
fn op_resample(self, x: Tensor, orig_freq: i64, new_freq: i64, lowpass_filter_width: i64, rolloff: f64, beta_has: bool, beta: f64) -> Tensor
Wraps api-table member op_resample.
ClikaRT::ops::resample <- ClikaRT/compute/ops.h
op_reshape / f_op_reshape
fn f_op_reshape(self, x: Tensor, shape: &[clika_rt_index_bound]) -> Result<Tensor>
fn op_reshape(self, x: Tensor, shape: &[clika_rt_index_bound]) -> Tensor
Wraps api-table member op_reshape.
ClikaRT::ops::reshape <- ClikaRT/compute/ops.h
op_reshape_as / f_op_reshape_as
fn f_op_reshape_as(self, x: Tensor, other: Tensor) -> Result<Tensor>
fn op_reshape_as(self, x: Tensor, other: Tensor) -> Tensor
Wraps api-table member op_reshape_as.
ClikaRT::ops::reshape_as <- ClikaRT/compute/ops.h
op_rfft / f_op_rfft
fn f_op_rfft(self, x: Tensor, n_fft_has: bool, n_fft: i64, normalized: bool) -> Result<Tensor>
fn op_rfft(self, x: Tensor, n_fft_has: bool, n_fft: i64, normalized: bool) -> Tensor
Wraps api-table member op_rfft.
ClikaRT::ops::rfft <- ClikaRT/compute/ops.h
op_rms_norm / f_op_rms_norm
fn f_op_rms_norm(self, x: Tensor, normalized_shape: &[i64], weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Result<Tensor>
fn op_rms_norm(self, x: Tensor, normalized_shape: &[i64], weight: Tensor, bias: Tensor, eps_has: bool, eps: f64, activation_has: bool, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_rms_norm.
ClikaRT::ops::rms_norm <- ClikaRT/compute/ops.h
op_roll / f_op_roll
fn f_op_roll(self, x: Tensor, shifts: &[i64], dims: &[i64]) -> Result<Tensor>
fn op_roll(self, x: Tensor, shifts: &[i64], dims: &[i64]) -> Tensor
Wraps api-table member op_roll.
ClikaRT::ops::roll <- ClikaRT/compute/ops.h
op_rot90 / f_op_rot90
fn f_op_rot90(self, x: Tensor, k: i64, dims: &[i64]) -> Result<Tensor>
fn op_rot90(self, x: Tensor, k: i64, dims: &[i64]) -> Tensor
Wraps api-table member op_rot90.
ClikaRT::ops::rot90 <- ClikaRT/compute/ops.h
op_rotary_embedding / f_op_rotary_embedding
fn f_op_rotary_embedding(self, x0: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingOptions) -> Result<Tensor>
fn op_rotary_embedding(self, x0: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingOptions) -> Tensor
Wraps api-table member op_rotary_embedding.
ClikaRT::ops::rotary_embedding <- ClikaRT/compute/ops.h
op_rotary_embedding_qk / f_op_rotary_embedding_qk
fn f_op_rotary_embedding_qk(self, q: Tensor, k: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingQkOptions) -> Result<(Tensor, Tensor)>
fn op_rotary_embedding_qk(self, q: Tensor, k: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingQkOptions) -> (Tensor, Tensor)
Wraps api-table member op_rotary_embedding_qk.
ClikaRT::ops::rotary_embedding_qk <- ClikaRT/compute/ops.h
op_rotary_embedding_qk_varlen / f_op_rotary_embedding_qk_varlen
fn f_op_rotary_embedding_qk_varlen(self, q: Tensor, k: Tensor, cu_seqlens: Tensor, seqlens: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingQkVarlenOptions) -> Result<(Tensor, Tensor)>
fn op_rotary_embedding_qk_varlen(self, q: Tensor, k: Tensor, cu_seqlens: Tensor, seqlens: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingQkVarlenOptions) -> (Tensor, Tensor)
Wraps api-table member op_rotary_embedding_qk_varlen.
ClikaRT::ops::rotary_embedding_qk_varlen <- ClikaRT/compute/ops.h
op_rotary_embedding_varlen / f_op_rotary_embedding_varlen
fn f_op_rotary_embedding_varlen(self, x0: Tensor, cu_seqlens: Tensor, seqlens: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingVarlenOptions) -> Result<Tensor>
fn op_rotary_embedding_varlen(self, x0: Tensor, cu_seqlens: Tensor, seqlens: Tensor, position_ids: Tensor, cos: Tensor, sin: Tensor, freq_factors: Tensor, options: &RotaryEmbeddingVarlenOptions) -> Tensor
Wraps api-table member op_rotary_embedding_varlen.
ClikaRT::ops::rotary_embedding_varlen <- ClikaRT/compute/ops.h
op_round / f_op_round
fn f_op_round(self, x: Tensor, decimals: i64) -> Result<Tensor>
fn op_round(self, x: Tensor, decimals: i64) -> Tensor
Wraps api-table member op_round.
ClikaRT::ops::round <- ClikaRT/compute/ops.h
op_round_inplace / f_op_round_inplace
fn f_op_round_inplace(self, self_: &Tensor, decimals: i64) -> Result<()>
fn op_round_inplace(self, self_: &Tensor, decimals: i64)
Wraps api-table member op_round_inplace.
ClikaRT::ops::round_ <- ClikaRT/compute/ops.h
op_rsqrt / f_op_rsqrt
fn f_op_rsqrt(self, x: Tensor) -> Result<Tensor>
fn op_rsqrt(self, x: Tensor) -> Tensor
Wraps api-table member op_rsqrt.
ClikaRT::ops::rsqrt <- ClikaRT/compute/ops.h
op_rsqrt_inplace / f_op_rsqrt_inplace
fn f_op_rsqrt_inplace(self, self_: &Tensor) -> Result<()>
fn op_rsqrt_inplace(self, self_: &Tensor)
Wraps api-table member op_rsqrt_inplace.
ClikaRT::ops::rsqrt_ <- ClikaRT/compute/ops.h
op_scaled_dot_product_attention / f_op_scaled_dot_product_attention
fn f_op_scaled_dot_product_attention(self, q: Tensor, k: Tensor, v: Tensor, attn_mask: Tensor, is_causal: bool, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_scaled_dot_product_attention(self, q: Tensor, k: Tensor, v: Tensor, attn_mask: Tensor, is_causal: bool, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_scaled_dot_product_attention.
ClikaRT::ops::scaled_dot_product_attention <- ClikaRT/compute/ops.h
op_scaled_dot_product_attention_varlen / f_op_scaled_dot_product_attention_varlen
fn f_op_scaled_dot_product_attention_varlen(self, q: Tensor, k: Tensor, v: Tensor, cu_seqlens_q: Tensor, cu_seqlens_k: Tensor, max_seqlen_q: clika_rt_scalar_or_tensor, max_seqlen_k: clika_rt_scalar_or_tensor, attn_mask: Tensor, is_causal: bool, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_scaled_dot_product_attention_varlen(self, q: Tensor, k: Tensor, v: Tensor, cu_seqlens_q: Tensor, cu_seqlens_k: Tensor, max_seqlen_q: clika_rt_scalar_or_tensor, max_seqlen_k: clika_rt_scalar_or_tensor, attn_mask: Tensor, is_causal: bool, q_scale: clika_rt_scalar_or_tensor, k_scale: clika_rt_scalar_or_tensor, v_scale: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_scaled_dot_product_attention_varlen.
ClikaRT::ops::scaled_dot_product_attention_varlen <- ClikaRT/compute/ops.h
op_scatter / f_op_scatter
fn f_op_scatter(self, x: Tensor, dim: i64, index: Tensor, src: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_scatter(self, x: Tensor, dim: i64, index: Tensor, src: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_scatter.
ClikaRT::ops::scatter <- ClikaRT/compute/ops.h
op_scatter_add / f_op_scatter_add
fn f_op_scatter_add(self, x: Tensor, dim: i64, index: Tensor, src: Tensor, deterministic: bool) -> Result<Tensor>
fn op_scatter_add(self, x: Tensor, dim: i64, index: Tensor, src: Tensor, deterministic: bool) -> Tensor
Wraps api-table member op_scatter_add.
ClikaRT::ops::scatter_add <- ClikaRT/compute/ops.h
op_scatter_add_inplace / f_op_scatter_add_inplace
fn f_op_scatter_add_inplace(self, self_: &Tensor, dim: i64, index: Tensor, src: Tensor, deterministic: bool) -> Result<()>
fn op_scatter_add_inplace(self, self_: &Tensor, dim: i64, index: Tensor, src: Tensor, deterministic: bool)
Wraps api-table member op_scatter_add_inplace.
ClikaRT::ops::scatter_add_ <- ClikaRT/compute/ops.h
op_scatter_inplace / f_op_scatter_inplace
fn f_op_scatter_inplace(self, self_: &Tensor, dim: i64, index: Tensor, src: clika_rt_scalar_or_tensor) -> Result<()>
fn op_scatter_inplace(self, self_: &Tensor, dim: i64, index: Tensor, src: clika_rt_scalar_or_tensor)
Wraps api-table member op_scatter_inplace.
ClikaRT::ops::scatter_ <- ClikaRT/compute/ops.h
op_scatter_reduce / f_op_scatter_reduce
fn f_op_scatter_reduce(self, x: Tensor, dim: i64, index: Tensor, src: Tensor, reduce: clika_rt_scatter_reduce_mode, include_self: bool, deterministic: bool) -> Result<Tensor>
fn op_scatter_reduce(self, x: Tensor, dim: i64, index: Tensor, src: Tensor, reduce: clika_rt_scatter_reduce_mode, include_self: bool, deterministic: bool) -> Tensor
Wraps api-table member op_scatter_reduce.
ClikaRT::ops::scatter_reduce <- ClikaRT/compute/ops.h
op_scatter_reduce_inplace / f_op_scatter_reduce_inplace
fn f_op_scatter_reduce_inplace(self, self_: &Tensor, dim: i64, index: Tensor, src: Tensor, reduce: clika_rt_scatter_reduce_mode, include_self: bool, deterministic: bool) -> Result<()>
fn op_scatter_reduce_inplace(self, self_: &Tensor, dim: i64, index: Tensor, src: Tensor, reduce: clika_rt_scatter_reduce_mode, include_self: bool, deterministic: bool)
Wraps api-table member op_scatter_reduce_inplace.
ClikaRT::ops::scatter_reduce_ <- ClikaRT/compute/ops.h
op_searchsorted / f_op_searchsorted
fn f_op_searchsorted(self, sorted_sequence: Tensor, values: Tensor, out_int32: bool, right: bool, side_has: bool, side: bool, sorter: Tensor) -> Result<Tensor>
fn op_searchsorted(self, sorted_sequence: Tensor, values: Tensor, out_int32: bool, right: bool, side_has: bool, side: bool, sorter: Tensor) -> Tensor
Wraps api-table member op_searchsorted.
ClikaRT::ops::searchsorted <- ClikaRT/compute/ops.h
op_select / f_op_select
fn f_op_select(self, x: Tensor, dim: i64, index: clika_rt_index_bound) -> Result<Tensor>
fn op_select(self, x: Tensor, dim: i64, index: clika_rt_index_bound) -> Tensor
Wraps api-table member op_select.
ClikaRT::ops::select <- ClikaRT/compute/ops.h
op_selu / f_op_selu
fn f_op_selu(self, x: Tensor) -> Result<Tensor>
fn op_selu(self, x: Tensor) -> Tensor
Wraps api-table member op_selu.
ClikaRT::ops::selu <- ClikaRT/compute/ops.h
op_selu_inplace / f_op_selu_inplace
fn f_op_selu_inplace(self, self_: &Tensor) -> Result<()>
fn op_selu_inplace(self, self_: &Tensor)
Wraps api-table member op_selu_inplace.
ClikaRT::ops::selu_ <- ClikaRT/compute/ops.h
op_sgn / f_op_sgn
fn f_op_sgn(self, x: Tensor) -> Result<Tensor>
fn op_sgn(self, x: Tensor) -> Tensor
Wraps api-table member op_sgn.
ClikaRT::ops::sgn <- ClikaRT/compute/ops.h
op_sgn_inplace / f_op_sgn_inplace
fn f_op_sgn_inplace(self, self_: &Tensor) -> Result<()>
fn op_sgn_inplace(self, self_: &Tensor)
Wraps api-table member op_sgn_inplace.
ClikaRT::ops::sgn_ <- ClikaRT/compute/ops.h
op_shape_dim / f_op_shape_dim
fn f_op_shape_dim(self, x: Tensor, dim_has: bool, dim: i64) -> Result<Tensor>
fn op_shape_dim(self, x: Tensor, dim_has: bool, dim: i64) -> Tensor
Wraps api-table member op_shape_dim.
ClikaRT::ops::shape <- ClikaRT/compute/ops.h
op_shape_host_all / f_op_shape_host_all
fn f_op_shape_host_all(self, x: Tensor) -> Result<Tensor>
fn op_shape_host_all(self, x: Tensor) -> Tensor
Wraps api-table member op_shape_host_all.
ClikaRT::ops::shape_host <- ClikaRT/compute/ops.h
op_shape_host_dim / f_op_shape_host_dim
fn f_op_shape_host_dim(self, x: Tensor, dim: i64) -> Result<Tensor>
fn op_shape_host_dim(self, x: Tensor, dim: i64) -> Tensor
Wraps api-table member op_shape_host_dim.
ClikaRT::ops::shape_host <- ClikaRT/compute/ops.h
op_shape_host_range / f_op_shape_host_range
fn f_op_shape_host_range(self, x: Tensor, start_has: bool, start: i64, end_has: bool, end: i64) -> Result<Tensor>
fn op_shape_host_range(self, x: Tensor, start_has: bool, start: i64, end_has: bool, end: i64) -> Tensor
Wraps api-table member op_shape_host_range.
ClikaRT::ops::shape_host <- ClikaRT/compute/ops.h
op_shape_range / f_op_shape_range
fn f_op_shape_range(self, x: Tensor, start_has: bool, start: i64, end_has: bool, end: i64) -> Result<Tensor>
fn op_shape_range(self, x: Tensor, start_has: bool, start: i64, end_has: bool, end: i64) -> Tensor
Wraps api-table member op_shape_range.
ClikaRT::ops::shape <- ClikaRT/compute/ops.h
op_sigmoid / f_op_sigmoid
fn f_op_sigmoid(self, x: Tensor) -> Result<Tensor>
fn op_sigmoid(self, x: Tensor) -> Tensor
Wraps api-table member op_sigmoid.
ClikaRT::ops::sigmoid <- ClikaRT/compute/ops.h
op_sigmoid_inplace / f_op_sigmoid_inplace
fn f_op_sigmoid_inplace(self, self_: &Tensor) -> Result<()>
fn op_sigmoid_inplace(self, self_: &Tensor)
Wraps api-table member op_sigmoid_inplace.
ClikaRT::ops::sigmoid_ <- ClikaRT/compute/ops.h
op_sign / f_op_sign
fn f_op_sign(self, x: Tensor) -> Result<Tensor>
fn op_sign(self, x: Tensor) -> Tensor
Wraps api-table member op_sign.
ClikaRT::ops::sign <- ClikaRT/compute/ops.h
op_sign_inplace / f_op_sign_inplace
fn f_op_sign_inplace(self, self_: &Tensor) -> Result<()>
fn op_sign_inplace(self, self_: &Tensor)
Wraps api-table member op_sign_inplace.
ClikaRT::ops::sign_ <- ClikaRT/compute/ops.h
op_silu / f_op_silu
fn f_op_silu(self, x: Tensor) -> Result<Tensor>
fn op_silu(self, x: Tensor) -> Tensor
Wraps api-table member op_silu.
ClikaRT::ops::silu <- ClikaRT/compute/ops.h
op_silu_inplace / f_op_silu_inplace
fn f_op_silu_inplace(self, self_: &Tensor) -> Result<()>
fn op_silu_inplace(self, self_: &Tensor)
Wraps api-table member op_silu_inplace.
ClikaRT::ops::silu_ <- ClikaRT/compute/ops.h
op_sin / f_op_sin
fn f_op_sin(self, x: Tensor) -> Result<Tensor>
fn op_sin(self, x: Tensor) -> Tensor
Wraps api-table member op_sin.
ClikaRT::ops::sin <- ClikaRT/compute/ops.h
op_sin_inplace / f_op_sin_inplace
fn f_op_sin_inplace(self, self_: &Tensor) -> Result<()>
fn op_sin_inplace(self, self_: &Tensor)
Wraps api-table member op_sin_inplace.
ClikaRT::ops::sin_ <- ClikaRT/compute/ops.h
op_sinc / f_op_sinc
fn f_op_sinc(self, x: Tensor) -> Result<Tensor>
fn op_sinc(self, x: Tensor) -> Tensor
Wraps api-table member op_sinc.
ClikaRT::ops::sinc <- ClikaRT/compute/ops.h
op_sinc_inplace / f_op_sinc_inplace
fn f_op_sinc_inplace(self, self_: &Tensor) -> Result<()>
fn op_sinc_inplace(self, self_: &Tensor)
Wraps api-table member op_sinc_inplace.
ClikaRT::ops::sinc_ <- ClikaRT/compute/ops.h
op_sinh / f_op_sinh
fn f_op_sinh(self, x: Tensor) -> Result<Tensor>
fn op_sinh(self, x: Tensor) -> Tensor
Wraps api-table member op_sinh.
ClikaRT::ops::sinh <- ClikaRT/compute/ops.h
op_sinh_inplace / f_op_sinh_inplace
fn f_op_sinh_inplace(self, self_: &Tensor) -> Result<()>
fn op_sinh_inplace(self, self_: &Tensor)
Wraps api-table member op_sinh_inplace.
ClikaRT::ops::sinh_ <- ClikaRT/compute/ops.h
op_slice_dim / f_op_slice_dim
fn f_op_slice_dim(self, x: Tensor, dim: i64, start: clika_rt_index_bound, end: clika_rt_index_bound, step: clika_rt_index_bound) -> Result<Tensor>
fn op_slice_dim(self, x: Tensor, dim: i64, start: clika_rt_index_bound, end: clika_rt_index_bound, step: clika_rt_index_bound) -> Tensor
Wraps api-table member op_slice_dim.
ClikaRT::ops::slice <- ClikaRT/compute/ops.h
op_slice_dims / f_op_slice_dims
fn f_op_slice_dims(self, x: Tensor, dim: &[i64], start: &[clika_rt_index_bound], end: &[clika_rt_index_bound], step: &[clika_rt_index_bound]) -> Result<Tensor>
fn op_slice_dims(self, x: Tensor, dim: &[i64], start: &[clika_rt_index_bound], end: &[clika_rt_index_bound], step: &[clika_rt_index_bound]) -> Tensor
Wraps api-table member op_slice_dims.
ClikaRT::ops::slice <- ClikaRT/compute/ops.h
op_smooth_l1_loss / f_op_smooth_l1_loss
fn f_op_smooth_l1_loss(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction, beta: f64) -> Result<Tensor>
fn op_smooth_l1_loss(self, input: Tensor, target: Tensor, reduction: clika_rt_reduction, beta: f64) -> Tensor
Wraps api-table member op_smooth_l1_loss.
ClikaRT::ops::smooth_l1_loss <- ClikaRT/compute/ops.h
op_snake / f_op_snake
fn f_op_snake(self, x: Tensor, alpha: Tensor, beta: Tensor, eps: f64) -> Result<Tensor>
fn op_snake(self, x: Tensor, alpha: Tensor, beta: Tensor, eps: f64) -> Tensor
Wraps api-table member op_snake.
ClikaRT::ops::snake <- ClikaRT/compute/ops.h
op_snake_inplace / f_op_snake_inplace
fn f_op_snake_inplace(self, self_: &Tensor, alpha: Tensor, beta: Tensor, eps: f64) -> Result<()>
fn op_snake_inplace(self, self_: &Tensor, alpha: Tensor, beta: Tensor, eps: f64)
Wraps api-table member op_snake_inplace.
ClikaRT::ops::snake_ <- ClikaRT/compute/ops.h
op_softcap_logits / f_op_softcap_logits
fn f_op_softcap_logits(self, x: Tensor, cap: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_softcap_logits(self, x: Tensor, cap: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_softcap_logits.
ClikaRT::ops::softcap_logits <- ClikaRT/compute/ops.h
op_softcap_logits_inplace / f_op_softcap_logits_inplace
fn f_op_softcap_logits_inplace(self, self_: &Tensor, cap: clika_rt_scalar_or_tensor) -> Result<()>
fn op_softcap_logits_inplace(self, self_: &Tensor, cap: clika_rt_scalar_or_tensor)
Wraps api-table member op_softcap_logits_inplace.
ClikaRT::ops::softcap_logits_ <- ClikaRT/compute/ops.h
op_softmax / f_op_softmax
fn f_op_softmax(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn op_softmax(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_softmax.
ClikaRT::ops::softmax <- ClikaRT/compute/ops.h
op_softmax_inplace / f_op_softmax_inplace
fn f_op_softmax_inplace(self, self_: &Tensor, dim: i64) -> Result<()>
fn op_softmax_inplace(self, self_: &Tensor, dim: i64)
Wraps api-table member op_softmax_inplace.
ClikaRT::ops::softmax_ <- ClikaRT/compute/ops.h
op_softmin / f_op_softmin
fn f_op_softmin(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Result<Tensor>
fn op_softmin(self, x: Tensor, dim: i64, dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_softmin.
ClikaRT::ops::softmin <- ClikaRT/compute/ops.h
op_softmin_inplace / f_op_softmin_inplace
fn f_op_softmin_inplace(self, self_: &Tensor, dim: i64) -> Result<()>
fn op_softmin_inplace(self, self_: &Tensor, dim: i64)
Wraps api-table member op_softmin_inplace.
ClikaRT::ops::softmin_ <- ClikaRT/compute/ops.h
op_softplus / f_op_softplus
fn f_op_softplus(self, x: Tensor, beta: f64, threshold: f64) -> Result<Tensor>
fn op_softplus(self, x: Tensor, beta: f64, threshold: f64) -> Tensor
Wraps api-table member op_softplus.
ClikaRT::ops::softplus <- ClikaRT/compute/ops.h
op_softplus_inplace / f_op_softplus_inplace
fn f_op_softplus_inplace(self, self_: &Tensor, beta: f64, threshold: f64) -> Result<()>
fn op_softplus_inplace(self, self_: &Tensor, beta: f64, threshold: f64)
Wraps api-table member op_softplus_inplace.
ClikaRT::ops::softplus_ <- ClikaRT/compute/ops.h
op_softshrink / f_op_softshrink
fn f_op_softshrink(self, x: Tensor, lambd: f64) -> Result<Tensor>
fn op_softshrink(self, x: Tensor, lambd: f64) -> Tensor
Wraps api-table member op_softshrink.
ClikaRT::ops::softshrink <- ClikaRT/compute/ops.h
op_softshrink_inplace / f_op_softshrink_inplace
fn f_op_softshrink_inplace(self, self_: &Tensor, lambd: f64) -> Result<()>
fn op_softshrink_inplace(self, self_: &Tensor, lambd: f64)
Wraps api-table member op_softshrink_inplace.
ClikaRT::ops::softshrink_ <- ClikaRT/compute/ops.h
op_softsign / f_op_softsign
fn f_op_softsign(self, x: Tensor) -> Result<Tensor>
fn op_softsign(self, x: Tensor) -> Tensor
Wraps api-table member op_softsign.
ClikaRT::ops::softsign <- ClikaRT/compute/ops.h
op_softsign_inplace / f_op_softsign_inplace
fn f_op_softsign_inplace(self, self_: &Tensor) -> Result<()>
fn op_softsign_inplace(self, self_: &Tensor)
Wraps api-table member op_softsign_inplace.
ClikaRT::ops::softsign_ <- ClikaRT/compute/ops.h
op_sort / f_op_sort
fn f_op_sort(self, x: Tensor, dim: i64, descending: bool, stable: bool) -> Result<(Tensor, Tensor)>
fn op_sort(self, x: Tensor, dim: i64, descending: bool, stable: bool) -> (Tensor, Tensor)
Wraps api-table member op_sort.
ClikaRT::ops::sort <- ClikaRT/compute/ops.h
op_split_by_size / f_op_split_by_size
fn f_op_split_by_size(self, x: Tensor, chunk_size: i64, dim: i64) -> Result<TensorList>
fn op_split_by_size(self, x: Tensor, chunk_size: i64, dim: i64) -> TensorList
Wraps api-table member op_split_by_size.
ClikaRT::ops::split_by_size <- ClikaRT/compute/ops.h
op_split_with_sizes / f_op_split_with_sizes
fn f_op_split_with_sizes(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], dim: i64) -> Result<TensorList>
fn op_split_with_sizes(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], dim: i64) -> TensorList
Wraps api-table member op_split_with_sizes.
ClikaRT::ops::split_with_sizes <- ClikaRT/compute/ops.h
op_sqrt / f_op_sqrt
fn f_op_sqrt(self, x: Tensor) -> Result<Tensor>
fn op_sqrt(self, x: Tensor) -> Tensor
Wraps api-table member op_sqrt.
ClikaRT::ops::sqrt <- ClikaRT/compute/ops.h
op_sqrt_inplace / f_op_sqrt_inplace
fn f_op_sqrt_inplace(self, self_: &Tensor) -> Result<()>
fn op_sqrt_inplace(self, self_: &Tensor)
Wraps api-table member op_sqrt_inplace.
ClikaRT::ops::sqrt_ <- ClikaRT/compute/ops.h
op_square / f_op_square
fn f_op_square(self, x: Tensor) -> Result<Tensor>
fn op_square(self, x: Tensor) -> Tensor
Wraps api-table member op_square.
ClikaRT::ops::square <- ClikaRT/compute/ops.h
op_square_inplace / f_op_square_inplace
fn f_op_square_inplace(self, self_: &Tensor) -> Result<()>
fn op_square_inplace(self, self_: &Tensor)
Wraps api-table member op_square_inplace.
ClikaRT::ops::square_ <- ClikaRT/compute/ops.h
op_squeeze / f_op_squeeze
fn f_op_squeeze(self, x: Tensor, dim: &[i64]) -> Result<Tensor>
fn op_squeeze(self, x: Tensor, dim: &[i64]) -> Tensor
Wraps api-table member op_squeeze.
ClikaRT::ops::squeeze <- ClikaRT/compute/ops.h
op_squeeze_inplace / f_op_squeeze_inplace
fn f_op_squeeze_inplace(self, self_: &Tensor, dim: &[i64]) -> Result<()>
fn op_squeeze_inplace(self, self_: &Tensor, dim: &[i64])
Wraps api-table member op_squeeze_inplace.
ClikaRT::ops::squeeze_ <- ClikaRT/compute/ops.h
op_ssd_update / f_op_ssd_update
fn f_op_ssd_update(self, x: Tensor, dt: Tensor, a_rate: Tensor, b_mat: Tensor, c_mat: Tensor, d_skip: Tensor, dt_bias: Tensor, z: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, dt_softplus: bool) -> Result<Tensor>
fn op_ssd_update(self, x: Tensor, dt: Tensor, a_rate: Tensor, b_mat: Tensor, c_mat: Tensor, d_skip: Tensor, dt_bias: Tensor, z: Tensor, state: Tensor, seq_lens: Tensor, slot_ids: Tensor, dt_softplus: bool) -> Tensor
Wraps api-table member op_ssd_update.
ClikaRT::ops::ssd_update <- ClikaRT/compute/ops.h
op_stack / f_op_stack
fn f_op_stack(self, tensors: &[&Tensor], dim: i64) -> Result<Tensor>
fn op_stack(self, tensors: &[&Tensor], dim: i64) -> Tensor
Wraps api-table member op_stack.
ClikaRT::ops::stack <- ClikaRT/compute/ops.h
op_std / f_op_std
fn f_op_std(self, x: Tensor, dims: &[i64], correction: i64, keepdim: bool) -> Result<Tensor>
fn op_std(self, x: Tensor, dims: &[i64], correction: i64, keepdim: bool) -> Tensor
Wraps api-table member op_std.
ClikaRT::ops::std <- ClikaRT/compute/ops.h
op_stft / f_op_stft
fn f_op_stft(self, x: Tensor, n_fft: i64, window: Tensor, options: &StftOptions) -> Result<Tensor>
fn op_stft(self, x: Tensor, n_fft: i64, window: Tensor, options: &StftOptions) -> Tensor
Wraps api-table member op_stft.
ClikaRT::ops::stft <- ClikaRT/compute/ops.h
op_sub_inplace / f_op_sub_inplace
fn f_op_sub_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Result<()>
fn op_sub_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation)
Wraps api-table member op_sub_inplace.
ClikaRT::ops::sub_ <- ClikaRT/compute/ops.h
op_sub_scalar_lhs / f_op_sub_scalar_lhs
fn f_op_sub_scalar_lhs(self, a: clika_rt_scalar, b: Tensor, alpha: f64, activation: clika_rt_activation) -> Result<Tensor>
fn op_sub_scalar_lhs(self, a: clika_rt_scalar, b: Tensor, alpha: f64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_sub_scalar_lhs.
ClikaRT::ops::sub <- ClikaRT/compute/ops.h
op_sub_tensor / f_op_sub_tensor
fn f_op_sub_tensor(self, a: Tensor, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Result<Tensor>
fn op_sub_tensor(self, a: Tensor, other: clika_rt_scalar_or_tensor, alpha: f64, activation: clika_rt_activation) -> Tensor
Wraps api-table member op_sub_tensor.
ClikaRT::ops::sub <- ClikaRT/compute/ops.h
op_sum / f_op_sum
fn f_op_sum(self, x: Tensor, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Result<Tensor>
fn op_sum(self, x: Tensor, dims: &[i64], keepdim: bool, dtype: clika_rt_data_type) -> Tensor
Wraps api-table member op_sum.
ClikaRT::ops::sum <- ClikaRT/compute/ops.h
op_swiglu / f_op_swiglu
fn f_op_swiglu(self, x: Tensor, alpha: f64, beta: f64, limit: f64) -> Result<Tensor>
fn op_swiglu(self, x: Tensor, alpha: f64, beta: f64, limit: f64) -> Tensor
Wraps api-table member op_swiglu.
ClikaRT::ops::swiglu <- ClikaRT/compute/ops.h
op_synchronize_all / f_op_synchronize_all
fn f_op_synchronize_all(self) -> Result<()>
fn op_synchronize_all(self)
Wraps api-table member op_synchronize_all.
ClikaRT::ops::synchronize_all <- ClikaRT/compute/ops.h
op_take / f_op_take
fn f_op_take(self, self_: Tensor, index: Tensor) -> Result<Tensor>
fn op_take(self, self_: Tensor, index: Tensor) -> Tensor
Wraps api-table member op_take.
ClikaRT::ops::take <- ClikaRT/compute/ops.h
op_take_along_dim / f_op_take_along_dim
fn f_op_take_along_dim(self, x: Tensor, index: Tensor, dim_has: bool, dim: i64) -> Result<Tensor>
fn op_take_along_dim(self, x: Tensor, index: Tensor, dim_has: bool, dim: i64) -> Tensor
Wraps api-table member op_take_along_dim.
ClikaRT::ops::take_along_dim <- ClikaRT/compute/ops.h
op_tan / f_op_tan
fn f_op_tan(self, x: Tensor) -> Result<Tensor>
fn op_tan(self, x: Tensor) -> Tensor
Wraps api-table member op_tan.
ClikaRT::ops::tan <- ClikaRT/compute/ops.h
op_tan_inplace / f_op_tan_inplace
fn f_op_tan_inplace(self, self_: &Tensor) -> Result<()>
fn op_tan_inplace(self, self_: &Tensor)
Wraps api-table member op_tan_inplace.
ClikaRT::ops::tan_ <- ClikaRT/compute/ops.h
op_tanh / f_op_tanh
fn f_op_tanh(self, x: Tensor) -> Result<Tensor>
fn op_tanh(self, x: Tensor) -> Tensor
Wraps api-table member op_tanh.
ClikaRT::ops::tanh <- ClikaRT/compute/ops.h
op_tanh_inplace / f_op_tanh_inplace
fn f_op_tanh_inplace(self, self_: &Tensor) -> Result<()>
fn op_tanh_inplace(self, self_: &Tensor)
Wraps api-table member op_tanh_inplace.
ClikaRT::ops::tanh_ <- ClikaRT/compute/ops.h
op_tensordot / f_op_tensordot
fn f_op_tensordot(self, a: Tensor, b: Tensor, dims_a: &[i64], dims_b: &[i64]) -> Result<Tensor>
fn op_tensordot(self, a: Tensor, b: Tensor, dims_a: &[i64], dims_b: &[i64]) -> Tensor
Wraps api-table member op_tensordot.
ClikaRT::ops::tensordot <- ClikaRT/compute/ops.h
op_threshold / f_op_threshold
fn f_op_threshold(self, x: Tensor, threshold: f64, value: f64) -> Result<Tensor>
fn op_threshold(self, x: Tensor, threshold: f64, value: f64) -> Tensor
Wraps api-table member op_threshold.
ClikaRT::ops::threshold <- ClikaRT/compute/ops.h
op_threshold_inplace / f_op_threshold_inplace
fn f_op_threshold_inplace(self, self_: &Tensor, threshold: f64, value: f64) -> Result<()>
fn op_threshold_inplace(self, self_: &Tensor, threshold: f64, value: f64)
Wraps api-table member op_threshold_inplace.
ClikaRT::ops::threshold_ <- ClikaRT/compute/ops.h
op_tile / f_op_tile
fn f_op_tile(self, x: Tensor, dims: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn op_tile(self, x: Tensor, dims: &[clika_rt_scalar_or_tensor]) -> Tensor
Wraps api-table member op_tile.
ClikaRT::ops::tile <- ClikaRT/compute/ops.h
op_to_device_str / f_op_to_device_str
fn f_op_to_device_str(self, src: Tensor, device_str: &str) -> Result<Tensor>
fn op_to_device_str(self, src: Tensor, device_str: &str) -> Tensor
Wraps api-table member op_to_device_str.
ClikaRT::ops::to <- ClikaRT/compute/ops.h
op_to_many / f_op_to_many
fn f_op_to_many(self, tensors: &[&Tensor], target: clika_rt_stream_or_device) -> Result<TensorList>
fn op_to_many(self, tensors: &[&Tensor], target: clika_rt_stream_or_device) -> TensorList
Wraps api-table member op_to_many.
ClikaRT::ops::to <- ClikaRT/compute/ops.h
op_to_tensor / f_op_to_tensor
fn f_op_to_tensor(self, src: Tensor, target: clika_rt_stream_or_device) -> Result<Tensor>
fn op_to_tensor(self, src: Tensor, target: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_to_tensor.
ClikaRT::ops::to <- ClikaRT/compute/ops.h
op_topk / f_op_topk
fn f_op_topk(self, x: Tensor, k: i64, dim: i64, largest: bool, sorted: bool) -> Result<(Tensor, Tensor)>
fn op_topk(self, x: Tensor, k: i64, dim: i64, largest: bool, sorted: bool) -> (Tensor, Tensor)
Wraps api-table member op_topk.
ClikaRT::ops::topk <- ClikaRT/compute/ops.h
op_trace / f_op_trace
fn f_op_trace(self, x: Tensor) -> Result<Tensor>
fn op_trace(self, x: Tensor) -> Tensor
Wraps api-table member op_trace.
ClikaRT::ops::trace <- ClikaRT/compute/ops.h
op_transpose / f_op_transpose
fn f_op_transpose(self, x: Tensor, dim0: i64, dim1: i64) -> Result<Tensor>
fn op_transpose(self, x: Tensor, dim0: i64, dim1: i64) -> Tensor
Wraps api-table member op_transpose.
ClikaRT::ops::transpose <- ClikaRT/compute/ops.h
op_tril / f_op_tril
fn f_op_tril(self, x: Tensor, diagonal: i64) -> Result<Tensor>
fn op_tril(self, x: Tensor, diagonal: i64) -> Tensor
Wraps api-table member op_tril.
ClikaRT::ops::tril <- ClikaRT/compute/ops.h
op_tril_inplace / f_op_tril_inplace
fn f_op_tril_inplace(self, self_: &Tensor, diagonal: i64) -> Result<()>
fn op_tril_inplace(self, self_: &Tensor, diagonal: i64)
Wraps api-table member op_tril_inplace.
ClikaRT::ops::tril_ <- ClikaRT/compute/ops.h
op_triu / f_op_triu
fn f_op_triu(self, x: Tensor, diagonal: i64) -> Result<Tensor>
fn op_triu(self, x: Tensor, diagonal: i64) -> Tensor
Wraps api-table member op_triu.
ClikaRT::ops::triu <- ClikaRT/compute/ops.h
op_triu_inplace / f_op_triu_inplace
fn f_op_triu_inplace(self, self_: &Tensor, diagonal: i64) -> Result<()>
fn op_triu_inplace(self, self_: &Tensor, diagonal: i64)
Wraps api-table member op_triu_inplace.
ClikaRT::ops::triu_ <- ClikaRT/compute/ops.h
op_trunc / f_op_trunc
fn f_op_trunc(self, x: Tensor) -> Result<Tensor>
fn op_trunc(self, x: Tensor) -> Tensor
Wraps api-table member op_trunc.
ClikaRT::ops::trunc <- ClikaRT/compute/ops.h
op_trunc_inplace / f_op_trunc_inplace
fn f_op_trunc_inplace(self, self_: &Tensor) -> Result<()>
fn op_trunc_inplace(self, self_: &Tensor)
Wraps api-table member op_trunc_inplace.
ClikaRT::ops::trunc_ <- ClikaRT/compute/ops.h
op_unflatten / f_op_unflatten
fn f_op_unflatten(self, x: Tensor, dim: i64, sizes: &[i64]) -> Result<Tensor>
fn op_unflatten(self, x: Tensor, dim: i64, sizes: &[i64]) -> Tensor
Wraps api-table member op_unflatten.
ClikaRT::ops::unflatten <- ClikaRT/compute/ops.h
op_unfold / f_op_unfold
fn f_op_unfold(self, x: Tensor, kernel_size: &[i64], dilation: &[i64], padding: &[i64], stride: &[i64], mode: clika_rt_pad_mode, value_has: bool, value: f64) -> Result<Tensor>
fn op_unfold(self, x: Tensor, kernel_size: &[i64], dilation: &[i64], padding: &[i64], stride: &[i64], mode: clika_rt_pad_mode, value_has: bool, value: f64) -> Tensor
Wraps api-table member op_unfold.
ClikaRT::ops::unfold <- ClikaRT/compute/ops.h
op_uniform_inplace / f_op_uniform_inplace
fn f_op_uniform_inplace(self, self_: &Tensor, low: f64, high: f64, s: clika_rt_stream_or_device) -> Result<()>
fn op_uniform_inplace(self, self_: &Tensor, low: f64, high: f64, s: clika_rt_stream_or_device)
Wraps api-table member op_uniform_inplace.
ClikaRT::ops::uniform_ <- ClikaRT/compute/ops.h
op_unique / f_op_unique
fn f_op_unique(self, x: Tensor, sorted: bool, return_inverse: bool, return_counts: bool, dim_has: bool, dim: i64) -> Result<(Tensor, Tensor, Tensor)>
fn op_unique(self, x: Tensor, sorted: bool, return_inverse: bool, return_counts: bool, dim_has: bool, dim: i64) -> (Tensor, Tensor, Tensor)
Wraps api-table member op_unique.
ClikaRT::ops::unique <- ClikaRT/compute/ops.h
op_unique_consecutive / f_op_unique_consecutive
fn f_op_unique_consecutive(self, x: Tensor, return_inverse: bool, return_counts: bool, dim_has: bool, dim: i64) -> Result<(Tensor, Tensor, Tensor)>
fn op_unique_consecutive(self, x: Tensor, return_inverse: bool, return_counts: bool, dim_has: bool, dim: i64) -> (Tensor, Tensor, Tensor)
Wraps api-table member op_unique_consecutive.
ClikaRT::ops::unique_consecutive <- ClikaRT/compute/ops.h
op_unsqueeze / f_op_unsqueeze
fn f_op_unsqueeze(self, x: Tensor, dim: i64) -> Result<Tensor>
fn op_unsqueeze(self, x: Tensor, dim: i64) -> Tensor
Wraps api-table member op_unsqueeze.
ClikaRT::ops::unsqueeze <- ClikaRT/compute/ops.h
op_unsqueeze_inplace / f_op_unsqueeze_inplace
fn f_op_unsqueeze_inplace(self, self_: &Tensor, dim: i64) -> Result<()>
fn op_unsqueeze_inplace(self, self_: &Tensor, dim: i64)
Wraps api-table member op_unsqueeze_inplace.
ClikaRT::ops::unsqueeze_ <- ClikaRT/compute/ops.h
op_upsample_bicubic2d / f_op_upsample_bicubic2d
fn f_op_upsample_bicubic2d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Result<Tensor>
fn op_upsample_bicubic2d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Tensor
Wraps api-table member op_upsample_bicubic2d.
ClikaRT::ops::upsample_bicubic2d <- ClikaRT/compute/ops.h
op_upsample_bilinear2d / f_op_upsample_bilinear2d
fn f_op_upsample_bilinear2d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Result<Tensor>
fn op_upsample_bilinear2d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Tensor
Wraps api-table member op_upsample_bilinear2d.
ClikaRT::ops::upsample_bilinear2d <- ClikaRT/compute/ops.h
op_upsample_linear1d / f_op_upsample_linear1d
fn f_op_upsample_linear1d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Result<Tensor>
fn op_upsample_linear1d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Tensor
Wraps api-table member op_upsample_linear1d.
ClikaRT::ops::upsample_linear1d <- ClikaRT/compute/ops.h
op_upsample_nearest1d / f_op_upsample_nearest1d
fn f_op_upsample_nearest1d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn op_upsample_nearest1d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Tensor
Wraps api-table member op_upsample_nearest1d.
ClikaRT::ops::upsample_nearest1d <- ClikaRT/compute/ops.h
op_upsample_nearest2d / f_op_upsample_nearest2d
fn f_op_upsample_nearest2d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn op_upsample_nearest2d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Tensor
Wraps api-table member op_upsample_nearest2d.
ClikaRT::ops::upsample_nearest2d <- ClikaRT/compute/ops.h
op_upsample_nearest3d / f_op_upsample_nearest3d
fn f_op_upsample_nearest3d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Result<Tensor>
fn op_upsample_nearest3d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor]) -> Tensor
Wraps api-table member op_upsample_nearest3d.
ClikaRT::ops::upsample_nearest3d <- ClikaRT/compute/ops.h
op_upsample_trilinear3d / f_op_upsample_trilinear3d
fn f_op_upsample_trilinear3d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Result<Tensor>
fn op_upsample_trilinear3d(self, x: Tensor, sizes: &[clika_rt_scalar_or_tensor], scale_factors: &[clika_rt_scalar_or_tensor], align_corners: bool) -> Tensor
Wraps api-table member op_upsample_trilinear3d.
ClikaRT::ops::upsample_trilinear3d <- ClikaRT/compute/ops.h
op_validate_rotary_dim / f_op_validate_rotary_dim
fn f_op_validate_rotary_dim(self, rotary_dim: i64, head_dim: i64) -> Result<()>
fn op_validate_rotary_dim(self, rotary_dim: i64, head_dim: i64)
Wraps api-table member op_validate_rotary_dim.
ClikaRT::ops::validate_rotary_dim <- ClikaRT/compute/ops.h
op_var / f_op_var
fn f_op_var(self, x: Tensor, dims: &[i64], correction: i64, keepdim: bool) -> Result<Tensor>
fn op_var(self, x: Tensor, dims: &[i64], correction: i64, keepdim: bool) -> Tensor
Wraps api-table member op_var.
ClikaRT::ops::var <- ClikaRT/compute/ops.h
op_where_nonzero / f_op_where_nonzero
fn f_op_where_nonzero(self, condition: Tensor) -> Result<Tensor>
fn op_where_nonzero(self, condition: Tensor) -> Tensor
Wraps api-table member op_where_nonzero.
ClikaRT::ops::where <- ClikaRT/compute/ops.h
op_where_select / f_op_where_select
fn f_op_where_select(self, condition: Tensor, x: Tensor, y: Tensor) -> Result<Tensor>
fn op_where_select(self, condition: Tensor, x: Tensor, y: Tensor) -> Tensor
Wraps api-table member op_where_select.
ClikaRT::ops::where <- ClikaRT/compute/ops.h
op_xlog1py / f_op_xlog1py
fn f_op_xlog1py(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_xlog1py(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_xlog1py.
ClikaRT::ops::xlog1py <- ClikaRT/compute/ops.h
op_xlogy / f_op_xlogy
fn f_op_xlogy(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Result<Tensor>
fn op_xlogy(self, a: Tensor, other: clika_rt_scalar_or_tensor) -> Tensor
Wraps api-table member op_xlogy.
ClikaRT::ops::xlogy <- ClikaRT/compute/ops.h
op_xlogy_inplace / f_op_xlogy_inplace
fn f_op_xlogy_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor) -> Result<()>
fn op_xlogy_inplace(self, self_: &Tensor, other: clika_rt_scalar_or_tensor)
Wraps api-table member op_xlogy_inplace.
ClikaRT::ops::xlogy_ <- ClikaRT/compute/ops.h
op_zero_inplace / f_op_zero_inplace
fn f_op_zero_inplace(self, self_: &Tensor, s: clika_rt_stream_or_device) -> Result<()>
fn op_zero_inplace(self, self_: &Tensor, s: clika_rt_stream_or_device)
Wraps api-table member op_zero_inplace.
ClikaRT::ops::zero_ <- ClikaRT/compute/ops.h
op_zeros / f_op_zeros
fn f_op_zeros(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device, pinned_for: clika_rt_stream_or_device) -> Result<Tensor>
fn op_zeros(self, shape: &[clika_rt_scalar_or_tensor], dtype: clika_rt_data_type, s: clika_rt_stream_or_device, pinned_for: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_zeros.
ClikaRT::ops::zeros <- ClikaRT/compute/ops.h
op_zeros_like / f_op_zeros_like
fn f_op_zeros_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Result<Tensor>
fn op_zeros_like(self, reference: Tensor, s: clika_rt_stream_or_device) -> Tensor
Wraps api-table member op_zeros_like.
ClikaRT::ops::zeros_like <- ClikaRT/compute/ops.h