Skip to main content

op

family

Declared in clika_rt/clika_rt_core.h.

Members​

NameDescription
op_absClikaRT::ops::abs <- ClikaRT/compute/ops.h consumes x (contract §6)
op_abs_inplaceClikaRT::ops::abs_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_acosClikaRT::ops::acos <- ClikaRT/compute/ops.h consumes x (contract §6)
op_acos_inplaceClikaRT::ops::acos_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_acoshClikaRT::ops::acosh <- ClikaRT/compute/ops.h consumes x (contract §6)
op_acosh_inplaceClikaRT::ops::acosh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_adaptive_avg_poolClikaRT::ops::adaptive_avg_pool <- ClikaRT/compute/ops.h consumes x (contract §6)
op_adaptive_avg_pool1dClikaRT::ops::adaptive_avg_pool1d <- ClikaRT/compute/ops.h consumes x (contract §6)
op_adaptive_avg_pool2dClikaRT::ops::adaptive_avg_pool2d <- ClikaRT/compute/ops.h consumes x (contract §6)
op_adaptive_avg_pool3dClikaRT::ops::adaptive_avg_pool3d <- ClikaRT/compute/ops.h consumes x (contract §6)
op_adaptive_max_poolClikaRT::ops::adaptive_max_pool <- ClikaRT/compute/ops.h consumes x (contract §6)
op_adaptive_max_pool1dClikaRT::ops::adaptive_max_pool1d <- ClikaRT/compute/ops.h consumes x (contract §6)
op_adaptive_max_pool2dClikaRT::ops::adaptive_max_pool2d <- ClikaRT/compute/ops.h consumes x (contract §6)
op_adaptive_max_pool3dClikaRT::ops::adaptive_max_pool3d <- ClikaRT/compute/ops.h consumes x (contract §6)
op_add_inplaceClikaRT::ops::add_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity
op_add_layer_normClikaRT::ops::add_layer_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes residual when present (contract §6) optional; NULL = absent; consumes post_residual when present (contract §6) optional; NULL = absent; consumes skip_bias when present (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): residual={}, post_residual={}, normalized_shape={}, skip_bias={}, weight={}, bias={}, eps=std::nullopt, activation=std::nullopt
op_add_rms_normClikaRT::ops::add_rms_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes residual when present (contract §6) optional; NULL = absent; consumes residual2 when present (contract §6) optional; NULL = absent; consumes post_residual when present (contract §6) optional; NULL = absent; consumes skip_bias when present (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): residual={}, residual2={}, post_residual={}, normalized_shape={}, skip_bias={}, weight={}, bias={}, eps=std::nullopt, activation=std::nullopt
op_add_scalar_lhsClikaRT::ops::add <- ClikaRT/compute/ops.h one form of the overloaded C++ add; the _scalar_lhs suffix names this form consumes b (contract §6) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity
op_add_tensorClikaRT::ops::add <- ClikaRT/compute/ops.h one form of the overloaded C++ add; the _tensor suffix names this form consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity
op_allClikaRT::ops::all <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false
op_allcloseClikaRT::ops::allclose <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): rtol=1e-5, atol=1e-8, equal_nan=false
op_amaxClikaRT::ops::amax <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false
op_aminClikaRT::ops::amin <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false
op_aminmaxClikaRT::ops::aminmax <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false
op_anyClikaRT::ops::any <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false
op_arangeClikaRT::ops::arange <- ClikaRT/compute/ops.h start.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) end.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) step.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): step=1, dtype=DataType::Int64, s={}
op_argmaxClikaRT::ops::argmax <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, index_dtype=DataType::Int64
op_argminClikaRT::ops::argmin <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, index_dtype=DataType::Int64
op_argsortClikaRT::ops::argsort <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1, descending=false, stable=false
op_asinClikaRT::ops::asin <- ClikaRT/compute/ops.h consumes x (contract §6)
op_asin_inplaceClikaRT::ops::asin_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_asinhClikaRT::ops::asinh <- ClikaRT/compute/ops.h consumes x (contract §6)
op_asinh_inplaceClikaRT::ops::asinh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_atanClikaRT::ops::atan <- ClikaRT/compute/ops.h consumes x (contract §6)
op_atan2ClikaRT::ops::atan2 <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_atan2_inplaceClikaRT::ops::atan2_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)
op_atan_inplaceClikaRT::ops::atan_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_atanhClikaRT::ops::atanh <- ClikaRT/compute/ops.h consumes x (contract §6)
op_atanh_inplaceClikaRT::ops::atanh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_atleast_1dClikaRT::ops::atleast_1d <- ClikaRT/compute/ops.h consumes x (contract §6)
op_atleast_2dClikaRT::ops::atleast_2d <- ClikaRT/compute/ops.h consumes x (contract §6)
op_atleast_3dClikaRT::ops::atleast_3d <- ClikaRT/compute/ops.h consumes x (contract §6)
op_attentionClikaRT::ops::attention <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) optional; NULL = absent; consumes head_sink when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): attn_mask={}, head_sink={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, k_scale={}, v_scale={}
op_attention_over_cacheClikaRT::ops::attention_over_cache <- ClikaRT/compute/ops.h consumes q (contract §6) consumes cache_key (contract §6) consumes cache_value (contract §6) consumes kvcache_start (contract §6) consumes cu_seqlens_q (contract §6) consumes cu_seqlens_k (contract §6) max_seqlen_q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max_seqlen_k.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes rope_cos when present (contract §6) optional; NULL = absent; consumes rope_sin when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) rotary_mode read only when rotary_mode_has is nonzero (contract §9) num_heads read only when num_heads_has is nonzero (contract §9) kv_num_heads read only when kv_num_heads_has is nonzero (contract §9) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes head_sink when present (contract §6) optional; NULL = absent; consumes q_norm_gain when present (contract §6) optional; NULL = absent; consumes k_norm_gain when present (contract §6) qk_norm_eps read only when qk_norm_eps_has is nonzero (contract §9) optional; NULL = absent; consumes slot_ids when present (contract §6) C++ defaults (dropped at this surface): max_seqlen_q={}, max_seqlen_k={}, rope_cos={}, rope_sin={}, position_ids={}, attn_mask={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, rotary_mode=std::nullopt, num_heads=std::nullopt, kv_num_heads=std::nullopt, k_scale={}, v_scale={}, head_sink={}, q_norm_gain={}, k_norm_gain={}, qk_norm_eps=std::nullopt, slot_ids={}
op_attention_varlenClikaRT::ops::attention_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) consumes cu_seqlens_q (contract §6) consumes cu_seqlens_k (contract §6) max_seqlen_q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max_seqlen_k.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes attn_mask when present (contract §6) optional; NULL = absent; consumes head_sink when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): max_seqlen_q={}, max_seqlen_k={}, attn_mask={}, head_sink={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, k_scale={}, v_scale={}
op_avg_poolClikaRT::ops::avg_pool <- ClikaRT/compute/ops.h consumes x (contract §6) divisor_override read only when divisor_override_has is nonzero (contract §9)
op_avg_pool1dClikaRT::ops::avg_pool1d <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): stride={}, padding={0}, ceil_mode=false, count_include_pad=true
op_avg_pool2dClikaRT::ops::avg_pool2d <- ClikaRT/compute/ops.h consumes x (contract §6) divisor_override read only when divisor_override_has is nonzero (contract §9) C++ defaults (dropped at this surface): stride={}, padding={0, 0}, ceil_mode=false, count_include_pad=true, divisor_override=std::nullopt
op_avg_pool3dClikaRT::ops::avg_pool3d <- ClikaRT/compute/ops.h consumes x (contract §6) divisor_override read only when divisor_override_has is nonzero (contract §9) C++ defaults (dropped at this surface): stride={}, padding={0, 0, 0}, ceil_mode=false, count_include_pad=true, divisor_override=std::nullopt
op_batch_normClikaRT::ops::batch_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) optional; NULL = absent; consumes running_mean when present (contract §6) optional; NULL = absent; consumes running_var when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, running_mean={}, running_var={}, eps=std::nullopt, activation=std::nullopt
op_bernoulliClikaRT::ops::bernoulli <- ClikaRT/compute/ops.h consumes probabilities (contract §6) C++ defaults (dropped at this surface): s={}
op_bernoulli_inplaceClikaRT::ops::bernoulli_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): s={}
op_binary_cross_entropyClikaRT::ops::binary_cross_entropy <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) optional; NULL = absent; consumes weight when present (contract §6) C++ defaults (dropped at this surface): weight={}, reduction=Reduction::Mean
op_binary_cross_entropy_with_logitsClikaRT::ops::binary_cross_entropy_with_logits <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes pos_weight when present (contract §6) C++ defaults (dropped at this surface): weight={}, reduction=Reduction::Mean, pos_weight={}
op_bincountClikaRT::ops::bincount <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weights when present (contract §6) C++ defaults (dropped at this surface): weights={}, minlength=0
op_bitwise_andClikaRT::ops::bitwise_and <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bitwise_and_inplaceClikaRT::ops::bitwise_and_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bitwise_left_shiftClikaRT::ops::bitwise_left_shift <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bitwise_left_shift_inplaceClikaRT::ops::bitwise_left_shift_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bitwise_notClikaRT::ops::bitwise_not <- ClikaRT/compute/ops.h consumes x (contract §6)
op_bitwise_not_inplaceClikaRT::ops::bitwise_not_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_bitwise_orClikaRT::ops::bitwise_or <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bitwise_or_inplaceClikaRT::ops::bitwise_or_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bitwise_right_shiftClikaRT::ops::bitwise_right_shift <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bitwise_right_shift_inplaceClikaRT::ops::bitwise_right_shift_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bitwise_xorClikaRT::ops::bitwise_xor <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bitwise_xor_inplaceClikaRT::ops::bitwise_xor_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_bmmClikaRT::ops::bmm <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt
op_broadcast_tensorsClikaRT::ops::broadcast_tensors <- ClikaRT/compute/ops.h elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft)
op_broadcast_toClikaRT::ops::broadcast_to <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)
op_bucketizeClikaRT::ops::bucketize <- ClikaRT/compute/ops.h consumes x (contract §6) consumes boundaries (contract §6) C++ defaults (dropped at this surface): out_int32=false, right=false
op_castClikaRT::ops::cast <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): force_copy=false
op_cast_likeClikaRT::ops::cast_like <- ClikaRT/compute/ops.h consumes x (contract §6) consumes reference (contract §6)
op_causal_conv_updateClikaRT::ops::causal_conv_update <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes state (contract §6) optional; NULL = absent; consumes seq_lens when present (contract §6) optional; NULL = absent; consumes slot_ids when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): seq_lens={}, slot_ids={}, activation=std::nullopt
op_cdistClikaRT::ops::cdist <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): p=2.0
op_ceilClikaRT::ops::ceil <- ClikaRT/compute/ops.h consumes x (contract §6)
op_ceil_inplaceClikaRT::ops::ceil_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_celuClikaRT::ops::celu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): alpha=1.0
op_celu_inplaceClikaRT::ops::celu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): alpha=1.0
op_chunkClikaRT::ops::chunk <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=0
op_circular_padClikaRT::ops::circular_pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)
op_clampClikaRT::ops::clamp <- ClikaRT/compute/ops.h consumes x (contract §6) min.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): min=std::nullopt, max=std::nullopt
op_clamp_inplaceClikaRT::ops::clamp_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) min.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): min=std::nullopt, max=std::nullopt
op_clamp_maxClikaRT::ops::clamp_max <- ClikaRT/compute/ops.h consumes x (contract §6) max.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_clamp_max_inplaceClikaRT::ops::clamp_max_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) max.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_clamp_minClikaRT::ops::clamp_min <- ClikaRT/compute/ops.h consumes x (contract §6) min.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_clamp_min_inplaceClikaRT::ops::clamp_min_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) min.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_cloneClikaRT::ops::clone <- ClikaRT/compute/ops.h consumes src (contract §6)
op_concatClikaRT::ops::concat <- ClikaRT/compute/ops.h elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): dim=0, activation=Activation::Identity
op_constant_padClikaRT::ops::constant_pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): value=std::nullopt
op_contiguousClikaRT::ops::contiguous <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): force_copy=false
op_convClikaRT::ops::conv <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity
op_conv1dClikaRT::ops::conv1d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, dilation={1}, groups=1, activation=Activation::Identity
op_conv2dClikaRT::ops::conv2d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity
op_conv3dClikaRT::ops::conv3d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity
op_conv_transposeClikaRT::ops::conv_transpose <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity
op_conv_transpose1dClikaRT::ops::conv_transpose1d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0, 0}, output_padding={0}, groups=1, dilation={1}, activation=Activation::Identity
op_conv_transpose2dClikaRT::ops::conv_transpose2d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0, 0, 0}, output_padding={0, 0}, groups=1, dilation={1, 1}, activation=Activation::Identity
op_conv_transpose3dClikaRT::ops::conv_transpose3d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0, 0, 0, 0}, output_padding={0, 0, 0}, groups=1, dilation={1, 1, 1}, activation=Activation::Identity
op_copyClikaRT::ops::copy <- ClikaRT/compute/ops.h consumes src (contract §6) C++ defaults (dropped at this surface): target={}, force_copy=true
op_copy_inplaceClikaRT::ops::copy_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes src (contract §6) C++ defaults (dropped at this surface): target={}
op_copy_intoClikaRT::ops::copy_into <- ClikaRT/compute/ops.h borrows out; written through (the in-place target) consumes src (contract §6) C++ defaults (dropped at this surface): target={}
op_copy_to_cpuClikaRT::ops::copy_to_cpu <- ClikaRT/compute/ops.h consumes src (contract §6)
op_copysignClikaRT::ops::copysign <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_copysign_inplaceClikaRT::ops::copysign_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_cosClikaRT::ops::cos <- ClikaRT/compute/ops.h consumes x (contract §6)
op_cos_inplaceClikaRT::ops::cos_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_coshClikaRT::ops::cosh <- ClikaRT/compute/ops.h consumes x (contract §6)
op_cosh_inplaceClikaRT::ops::cosh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_cosine_similarityClikaRT::ops::cosine_similarity <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=1, eps=std::nullopt
op_count_nonzeroClikaRT::ops::count_nonzero <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}
op_crossClikaRT::ops::cross <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt
op_cross_entropyClikaRT::ops::cross_entropy <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) optional; NULL = absent; consumes weight when present (contract §6) ignore_index read only when ignore_index_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, ignore_index=std::nullopt, reduction=Reduction::Mean
op_cummaxClikaRT::ops::cummax <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)
op_cumminClikaRT::ops::cummin <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)
op_cumprodClikaRT::ops::cumprod <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dtype=DataType::Undefined
op_cumprod_inplaceClikaRT::ops::cumprod_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dtype=DataType::Undefined
op_cumsumClikaRT::ops::cumsum <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dtype=DataType::Undefined
op_cumsum_inplaceClikaRT::ops::cumsum_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dtype=DataType::Undefined
op_deform_convClikaRT::ops::deform_conv <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) consumes offset (contract §6) optional; NULL = absent; consumes mask when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): mask={}, bias={}, stride={}, padding={}, dilation={}, groups=1, offset_groups=1, activation=Activation::Identity
op_deg2radClikaRT::ops::deg2rad <- ClikaRT/compute/ops.h consumes x (contract §6)
op_deg2rad_inplaceClikaRT::ops::deg2rad_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_dequantizeClikaRT::ops::dequantize <- ClikaRT/compute/q_tensor.h consumes x (contract §6) C++ defaults (dropped at this surface): target_dtype=DataType::Undefined
op_dequantize_inplaceClikaRT::ops::dequantize_ <- ClikaRT/compute/q_tensor.h in-place op consumes x (contract §6) borrows out; written through (the in-place target)
op_diagClikaRT::ops::diag <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): diagonal=0
op_diag_embedClikaRT::ops::diag_embed <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): offset=0, dim1=-2, dim2=-1
op_diagonalClikaRT::ops::diagonal <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): offset=0, dim1=0, dim2=1
op_diffClikaRT::ops::diff <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes prepend when present (contract §6) optional; NULL = absent; consumes append when present (contract §6) C++ defaults (dropped at this surface): n=1, dim=-1, prepend={}, append={}
op_div_inplaceClikaRT::ops::div_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): rounding_mode=RoundingMode::None, activation=Activation::Identity
op_div_scalar_lhsClikaRT::ops::div <- ClikaRT/compute/ops.h one form of the overloaded C++ div; the _scalar_lhs suffix names this form consumes b (contract §6) C++ defaults (dropped at this surface): rounding_mode=RoundingMode::None, activation=Activation::Identity
op_div_tensorClikaRT::ops::div <- ClikaRT/compute/ops.h one form of the overloaded C++ div; the _tensor suffix names this form consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): rounding_mode=RoundingMode::None, activation=Activation::Identity
op_dotClikaRT::ops::dot <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_dynamic_quantizeClikaRT::ops::dynamic_quantize <- ClikaRT/compute/q_tensor.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)
op_einsumClikaRT::ops::einsum <- ClikaRT/compute/ops.h elements of operands BORROWED; whether §6 reaches through spans needs a ruling (draft)
op_eluClikaRT::ops::elu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): alpha=1.0, scale=1.0, input_scale=1.0
op_elu_inplaceClikaRT::ops::elu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): alpha=1.0, scale=1.0, input_scale=1.0
op_embeddingClikaRT::ops::embedding <- ClikaRT/compute/ops.h consumes indices (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt
op_emptyClikaRT::ops::empty <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): s={}, pinned_for={}
op_empty_likeClikaRT::ops::empty_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}
op_empty_stridedClikaRT::ops::empty_strided <- ClikaRT/compute/ops.h C++ defaults (dropped at this surface): s={}
op_eqClikaRT::ops::eq <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_eq_inplaceClikaRT::ops::eq_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_erfClikaRT::ops::erf <- ClikaRT/compute/ops.h consumes x (contract §6)
op_erf_inplaceClikaRT::ops::erf_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_erfcClikaRT::ops::erfc <- ClikaRT/compute/ops.h consumes x (contract §6)
op_erfc_inplaceClikaRT::ops::erfc_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_erfinvClikaRT::ops::erfinv <- ClikaRT/compute/ops.h consumes x (contract §6)
op_erfinv_inplaceClikaRT::ops::erfinv_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_expClikaRT::ops::exp <- ClikaRT/compute/ops.h consumes x (contract §6)
op_exp_inplaceClikaRT::ops::exp_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_expandClikaRT::ops::expand <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): bidirectional=false
op_expand_asClikaRT::ops::expand_as <- ClikaRT/compute/ops.h consumes x (contract §6) consumes other (contract §6)
op_exponential_inplaceClikaRT::ops::exponential_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): lambd=1.0, s={}
op_eyeClikaRT::ops::eye <- ClikaRT/compute/ops.h n.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) m.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): m=std::nullopt, dtype=DataType::Float32, s={}
op_fast_geluClikaRT::ops::fast_gelu <- ClikaRT/compute/ops.h consumes x (contract §6)
op_fillClikaRT::ops::fill <- ClikaRT/compute/ops.h consumes x (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): s={}
op_fill_diagonalClikaRT::ops::fill_diagonal <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): wrap=false, s={}
op_fill_diagonal_inplaceClikaRT::ops::fill_diagonal_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): wrap=false, s={}
op_fill_inplaceClikaRT::ops::fill_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): s={}
op_flattenClikaRT::ops::flatten <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): start_dim=0, end_dim=-1
op_flipClikaRT::ops::flip <- ClikaRT/compute/ops.h consumes x (contract §6)
op_fliplrClikaRT::ops::fliplr <- ClikaRT/compute/ops.h consumes x (contract §6)
op_flipudClikaRT::ops::flipud <- ClikaRT/compute/ops.h consumes x (contract §6)
op_floorClikaRT::ops::floor <- ClikaRT/compute/ops.h consumes x (contract §6)
op_floor_divideClikaRT::ops::floor_divide <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_floor_divide_inplaceClikaRT::ops::floor_divide_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_floor_inplaceClikaRT::ops::floor_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_fmaxClikaRT::ops::fmax <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_fminClikaRT::ops::fmin <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_fmodClikaRT::ops::fmod <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_fmod_inplaceClikaRT::ops::fmod_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_foldClikaRT::ops::fold <- ClikaRT/compute/ops.h consumes x (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): mode=PadMode::Constant, value=std::nullopt
op_fracClikaRT::ops::frac <- ClikaRT/compute/ops.h consumes x (contract §6)
op_frac_inplaceClikaRT::ops::frac_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_frexpClikaRT::ops::frexp <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)
op_from_blobClikaRT::ops::from_blob <- ClikaRT/compute/ops.h deleter is the contract §7 triple: the callback takes userdata first; deleter_userdata_free (NULL when no finalizer is needed) runs exactly once when the registration dies, including one that never fires and one whose call the runtime refused at its argument checks a NULL deleter registers nothing C++ defaults (dropped at this surface): s={}, strides={}, deleter={}, pinned_for={}
op_fullClikaRT::ops::full <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) fill_value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): s={}, pinned_for={}
op_full_likeClikaRT::ops::full_like <- ClikaRT/compute/ops.h consumes reference (contract §6) fill_value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): s={}
op_gated_delta_updateClikaRT::ops::gated_delta_update <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) consumes beta (contract §6) consumes g (contract §6) consumes state (contract §6) optional; NULL = absent; consumes seq_lens when present (contract §6) optional; NULL = absent; consumes slot_ids when present (contract §6) scale read only when scale_has is nonzero (contract §9) optional; NULL = absent; consumes gate_bias when present (contract §6) optional; NULL = absent; consumes gate_scale when present (contract §6) C++ defaults (dropped at this surface): seq_lens={}, slot_ids={}, scale=std::nullopt, gate_bias={}, gate_scale={}
op_gated_rms_normClikaRT::ops::gated_rms_norm <- ClikaRT/compute/ops.h consumes x (contract §6) consumes z (contract §6) optional; NULL = absent; consumes weight when present (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, eps=std::nullopt
op_gatherClikaRT::ops::gather <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6)
op_geClikaRT::ops::ge <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_ge_inplaceClikaRT::ops::ge_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_gegluClikaRT::ops::geglu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): approximate=GeluMode::None
op_geluClikaRT::ops::gelu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): approximate=GeluMode::None
op_gelu_inplaceClikaRT::ops::gelu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): approximate=GeluMode::None
op_generate_rotary_cacheClikaRT::ops::generate_rotary_cache <- ClikaRT/compute/ops.h theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}, s={}
op_gluClikaRT::ops::glu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1
op_grid_sampleClikaRT::ops::grid_sample <- ClikaRT/compute/ops.h consumes x (contract §6) consumes grid (contract §6) C++ defaults (dropped at this surface): mode=GridSampleMode::Bilinear, padding_mode=GridSamplePaddingMode::Zeros, align_corners=false
op_group_normClikaRT::ops::group_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) optional; NULL = absent; consumes running_mean when present (contract §6) optional; NULL = absent; consumes running_var when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, running_mean={}, running_var={}, eps=std::nullopt, activation=std::nullopt
op_group_query_attentionClikaRT::ops::group_query_attention <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) optional; NULL = absent; consumes past_key when present (contract §6) optional; NULL = absent; consumes past_value when present (contract §6) optional; NULL = absent; consumes kvcache_start when present (contract §6) optional; NULL = absent; consumes rope_cos when present (contract §6) optional; NULL = absent; consumes rope_sin when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) rotary_mode read only when rotary_mode_has is nonzero (contract §9) num_heads read only when num_heads_has is nonzero (contract §9) kv_num_heads read only when kv_num_heads_has is nonzero (contract §9) optional; NULL = absent; consumes out_present_key when present (contract §6) optional; NULL = absent; consumes out_present_value when present (contract §6) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes head_sink when present (contract §6) optional; NULL = absent; consumes q_norm_gain when present (contract §6) optional; NULL = absent; consumes k_norm_gain when present (contract §6) qk_norm_eps read only when qk_norm_eps_has is nonzero (contract §9) optional; NULL = absent; consumes slot_ids when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): past_key={}, past_value={}, kvcache_start={}, rope_cos={}, rope_sin={}, position_ids={}, attn_mask={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, rotary_mode=std::nullopt, num_heads=std::nullopt, kv_num_heads=std::nullopt, out_present_key={}, out_present_value={}, k_scale={}, v_scale={}, head_sink={}, q_norm_gain={}, k_norm_gain={}, qk_norm_eps=std::nullopt, slot_ids={}
op_group_query_attention_varlenClikaRT::ops::group_query_attention_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) consumes cu_seqlens_q (contract §6) consumes cu_seqlens_k (contract §6) max_seqlen_q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max_seqlen_k.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes past_key when present (contract §6) optional; NULL = absent; consumes past_value when present (contract §6) optional; NULL = absent; consumes kvcache_start when present (contract §6) optional; NULL = absent; consumes rope_cos when present (contract §6) optional; NULL = absent; consumes rope_sin when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) optional; NULL = absent; consumes head_sink when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) rotary_mode read only when rotary_mode_has is nonzero (contract §9) num_heads read only when num_heads_has is nonzero (contract §9) kv_num_heads read only when kv_num_heads_has is nonzero (contract §9) optional; NULL = absent; consumes out_present_key when present (contract §6) optional; NULL = absent; consumes out_present_value when present (contract §6) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes q_norm_gain when present (contract §6) optional; NULL = absent; consumes k_norm_gain when present (contract §6) qk_norm_eps read only when qk_norm_eps_has is nonzero (contract §9) optional; NULL = absent; consumes slot_ids when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): max_seqlen_q={}, max_seqlen_k={}, past_key={}, past_value={}, kvcache_start={}, rope_cos={}, rope_sin={}, position_ids={}, attn_mask={}, head_sink={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, rotary_mode=std::nullopt, num_heads=std::nullopt, kv_num_heads=std::nullopt, out_present_key={}, out_present_value={}, k_scale={}, v_scale={}, q_norm_gain={}, k_norm_gain={}, qk_norm_eps=std::nullopt, slot_ids={}
op_gtClikaRT::ops::gt <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_gt_inplaceClikaRT::ops::gt_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_hardshrinkClikaRT::ops::hardshrink <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): lambd=0.5
op_hardshrink_inplaceClikaRT::ops::hardshrink_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): lambd=0.5
op_hardsigmoidClikaRT::ops::hardsigmoid <- ClikaRT/compute/ops.h consumes x (contract §6)
op_hardsigmoid_inplaceClikaRT::ops::hardsigmoid_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_hardswishClikaRT::ops::hardswish <- ClikaRT/compute/ops.h consumes x (contract §6)
op_hardswish_inplaceClikaRT::ops::hardswish_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_hardtanhClikaRT::ops::hardtanh <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): min_val=-1.0, max_val=1.0
op_hardtanh_inplaceClikaRT::ops::hardtanh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): min_val=-1.0, max_val=1.0
op_hash_128ClikaRT::ops::hash_128 <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): seed=0
op_hash_256ClikaRT::ops::hash_256 <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): seed=0
op_hash_64ClikaRT::ops::hash_64 <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): seed=0
op_hash_chainClikaRT::ops::hash_chain <- ClikaRT/compute/ops.h consumes rows (contract §6) consumes parent (contract §6) C++ defaults (dropped at this surface): seed=0
op_hash_tensorClikaRT::ops::hash_tensor <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, mode=HashTensorMode::XorSum
op_histogramClikaRT::ops::histogram <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes range when present (contract §6) optional; NULL = absent; consumes weight when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): bins=100, range={}, weight={}, density=false
op_huber_lossClikaRT::ops::huber_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean, delta=1.0
op_hypotClikaRT::ops::hypot <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_hypot_inplaceClikaRT::ops::hypot_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)
op_indexClikaRT::ops::index <- ClikaRT/compute/ops.h consumes x (contract §6) index payload; embedded tensors BORROWED (contract §11)
op_index_addClikaRT::ops::index_add <- ClikaRT/compute/ops.h consumes x (contract §6) consumes indices (contract §6) consumes src (contract §6)
op_index_add_inplaceClikaRT::ops::index_add_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes indices (contract §6) consumes src (contract §6)
op_index_copyClikaRT::ops::index_copy <- ClikaRT/compute/ops.h consumes x (contract §6) consumes indices (contract §6) consumes src (contract §6)
op_index_copy_inplaceClikaRT::ops::index_copy_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes indices (contract §6) consumes src (contract §6)
op_index_fillClikaRT::ops::index_fill <- ClikaRT/compute/ops.h consumes x (contract §6) consumes indices (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_index_fill_inplaceClikaRT::ops::index_fill_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes indices (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_index_putClikaRT::ops::index_put <- ClikaRT/compute/ops.h consumes x (contract §6) index payload; embedded tensors BORROWED (contract §11) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): accumulate=false
op_index_put_inplaceClikaRT::ops::index_put_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) index payload; embedded tensors BORROWED (contract §11) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): accumulate=false
op_index_selectClikaRT::ops::index_select <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6)
op_innerClikaRT::ops::inner <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_instance_normClikaRT::ops::instance_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) optional; NULL = absent; consumes running_mean when present (contract §6) optional; NULL = absent; consumes running_var when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, running_mean={}, running_var={}, eps=std::nullopt, activation=std::nullopt
op_interpolateClikaRT::ops::interpolate <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) align_corners read only when align_corners_has is nonzero (contract §9) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, mode=InterpMode::Nearest, align_corners=std::nullopt, recompute_scale_factor=false, antialias=false
op_iscloseClikaRT::ops::isclose <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): rtol=1e-5, atol=1e-8, equal_nan=false
op_isfiniteClikaRT::ops::isfinite <- ClikaRT/compute/ops.h consumes x (contract §6)
op_isinfClikaRT::ops::isinf <- ClikaRT/compute/ops.h consumes x (contract §6)
op_isnanClikaRT::ops::isnan <- ClikaRT/compute/ops.h consumes x (contract §6)
op_isneginfClikaRT::ops::isneginf <- ClikaRT/compute/ops.h consumes x (contract §6)
op_isposinfClikaRT::ops::isposinf <- ClikaRT/compute/ops.h consumes x (contract §6)
op_kl_divClikaRT::ops::kl_div <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean, log_target=false
op_kronClikaRT::ops::kron <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_kthvalueClikaRT::ops::kthvalue <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=-1, keepdim=false
op_l1_lossClikaRT::ops::l1_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean
op_layer_normClikaRT::ops::layer_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, eps=std::nullopt, activation=std::nullopt
op_leClikaRT::ops::le <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_le_inplaceClikaRT::ops::le_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_leaky_reluClikaRT::ops::leaky_relu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): negative_slope=0.01
op_leaky_relu_inplaceClikaRT::ops::leaky_relu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): negative_slope=0.01
op_linearClikaRT::ops::linear <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, situ_beta=0.0, situ_linear_beta=0.0
op_linspaceClikaRT::ops::linspace <- ClikaRT/compute/ops.h start.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) end.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) steps.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Float32, s={}
op_logClikaRT::ops::log <- ClikaRT/compute/ops.h consumes x (contract §6)
op_log10ClikaRT::ops::log10 <- ClikaRT/compute/ops.h consumes x (contract §6)
op_log10_inplaceClikaRT::ops::log10_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_log1pClikaRT::ops::log1p <- ClikaRT/compute/ops.h consumes x (contract §6)
op_log1p_inplaceClikaRT::ops::log1p_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_log2ClikaRT::ops::log2 <- ClikaRT/compute/ops.h consumes x (contract §6)
op_log2_inplaceClikaRT::ops::log2_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_log_inplaceClikaRT::ops::log_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_log_sigmoidClikaRT::ops::log_sigmoid <- ClikaRT/compute/ops.h consumes x (contract §6)
op_log_sigmoid_inplaceClikaRT::ops::log_sigmoid_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_log_softmaxClikaRT::ops::log_softmax <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1, dtype=DataType::Undefined
op_log_softmax_inplaceClikaRT::ops::log_softmax_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dim=-1
op_logaddexpClikaRT::ops::logaddexp <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_logaddexp2ClikaRT::ops::logaddexp2 <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_logical_andClikaRT::ops::logical_and <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_logical_and_inplaceClikaRT::ops::logical_and_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)
op_logical_notClikaRT::ops::logical_not <- ClikaRT/compute/ops.h consumes x (contract §6)
op_logical_not_inplaceClikaRT::ops::logical_not_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_logical_orClikaRT::ops::logical_or <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_logical_or_inplaceClikaRT::ops::logical_or_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)
op_logical_xorClikaRT::ops::logical_xor <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_logical_xor_inplaceClikaRT::ops::logical_xor_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)
op_logitClikaRT::ops::logit <- ClikaRT/compute/ops.h consumes x (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): eps=std::nullopt
op_logit_inplaceClikaRT::ops::logit_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): eps=std::nullopt
op_logsumexpClikaRT::ops::logsumexp <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): keepdim=false
op_ltClikaRT::ops::lt <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_lt_inplaceClikaRT::ops::lt_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_masked_fillClikaRT::ops::masked_fill <- ClikaRT/compute/ops.h consumes x (contract §6) consumes mask (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_masked_fill_inplaceClikaRT::ops::masked_fill_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes mask (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_masked_scatterClikaRT::ops::masked_scatter <- ClikaRT/compute/ops.h consumes x (contract §6) consumes mask (contract §6) consumes source (contract §6)
op_masked_scatter_inplaceClikaRT::ops::masked_scatter_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes mask (contract §6) consumes source (contract §6)
op_masked_selectClikaRT::ops::masked_select <- ClikaRT/compute/ops.h consumes x (contract §6) consumes mask (contract §6)
op_matmulClikaRT::ops::matmul <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false, situ_beta=0.0, situ_linear_beta=0.0
op_maxClikaRT::ops::max <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): keepdim=false
op_max_poolClikaRT::ops::max_pool <- ClikaRT/compute/ops.h consumes x (contract §6)
op_max_pool1dClikaRT::ops::max_pool1d <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): stride={}, padding={0}, dilation={1}, ceil_mode=false
op_max_pool1d_with_indicesClikaRT::ops::max_pool1d_with_indices <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): stride={}, padding={0}, dilation={1}, ceil_mode=false
op_max_pool2dClikaRT::ops::max_pool2d <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): stride={}, padding={0, 0}, dilation={1, 1}, ceil_mode=false
op_max_pool2d_with_indicesClikaRT::ops::max_pool2d_with_indices <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): stride={}, padding={0, 0}, dilation={1, 1}, ceil_mode=false
op_max_pool3dClikaRT::ops::max_pool3d <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): stride={}, padding={0, 0, 0}, dilation={1, 1, 1}, ceil_mode=false
op_max_pool3d_with_indicesClikaRT::ops::max_pool3d_with_indices <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): stride={}, padding={0, 0, 0}, dilation={1, 1, 1}, ceil_mode=false
op_max_pool_with_indicesClikaRT::ops::max_pool_with_indices <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)
op_maximumClikaRT::ops::maximum <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_maximum_inplaceClikaRT::ops::maximum_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)
op_meanClikaRT::ops::mean <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, dtype=DataType::Undefined
op_medianClikaRT::ops::median <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false
op_meshgridClikaRT::ops::meshgrid <- ClikaRT/compute/ops.h elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): indexing=MeshgridIndexing::IJ
op_minClikaRT::ops::min <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): keepdim=false
op_minimumClikaRT::ops::minimum <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_minimum_inplaceClikaRT::ops::minimum_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)
op_mishClikaRT::ops::mish <- ClikaRT/compute/ops.h consumes x (contract §6)
op_mish_inplaceClikaRT::ops::mish_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_mla_attentionClikaRT::ops::mla_attention <- ClikaRT/compute/ops.h consumes q_nope (contract §6) consumes q_pe (contract §6) consumes new_ckv (contract §6) consumes new_kpe (contract §6) consumes ckv_cache (contract §6) consumes kpe_cache (contract §6) consumes kvcache_start (contract §6) consumes cu_seqlens_q (contract §6) optional; NULL = absent; consumes slot_ids when present (contract §6) C++ defaults (dropped at this surface): slot_ids={}
op_mmClikaRT::ops::mm <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt
op_modClikaRT::ops::mod <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): mode=ModMode::Python
op_mod_inplaceClikaRT::ops::mod_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): mode=ModMode::Python
op_moeClikaRT::ops::moe <- ClikaRT/compute/ops.h consumes input (contract §6) consumes router_logits (contract §6) consumes fc1_experts (contract §6) consumes fc2_experts (contract §6) optional; NULL = absent; consumes fc1_bias when present (contract §6) optional; NULL = absent; consumes fc2_bias when present (contract §6) optional; NULL = absent; consumes fc3_experts when present (contract §6) optional; NULL = absent; consumes fc3_bias when present (contract §6) optional; NULL = absent; consumes e_score_correction_bias when present (contract §6) optional; NULL = absent; consumes router_weights when present (contract §6) routing_mode read only when routing_mode_has is nonzero (contract §9) renormalize read only when renormalize_has is nonzero (contract §9) n_group read only when n_group_has is nonzero (contract §9) topk_group read only when topk_group_has is nonzero (contract §9) routed_scaling_factor read only when routed_scaling_factor_has is nonzero (contract §9) sparse_mixer_eps read only when sparse_mixer_eps_has is nonzero (contract §9) apply_router_weight_on_input read only when apply_router_weight_on_input_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) swiglu_fusion read only when swiglu_fusion_has is nonzero (contract §9) swiglu_alpha read only when swiglu_alpha_has is nonzero (contract §9) swiglu_beta read only when swiglu_beta_has is nonzero (contract §9) swiglu_limit read only when swiglu_limit_has is nonzero (contract §9) gelu_mode read only when gelu_mode_has is nonzero (contract §9) optional; NULL = absent; consumes shared_output when present (contract §6) C++ defaults (dropped at this surface): fc1_bias={}, fc2_bias={}, fc3_experts={}, fc3_bias={}, e_score_correction_bias={}, router_weights={}, routing_mode=std::nullopt, renormalize=std::nullopt, n_group=std::nullopt, topk_group=std::nullopt, routed_scaling_factor=std::nullopt, sparse_mixer_eps=std::nullopt, apply_router_weight_on_input=std::nullopt, activation=std::nullopt, swiglu_fusion=std::nullopt, swiglu_alpha=std::nullopt, swiglu_beta=std::nullopt, swiglu_limit=std::nullopt, gelu_mode=std::nullopt, shared_output={}
op_mrope_rotary_embeddingClikaRT::ops::mrope_rotary_embedding <- ClikaRT/compute/ops.h consumes x0 (contract §6) consumes position_ids (contract §6) interleaved_sections read only when interleaved_sections_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) C++ defaults (dropped at this surface): interleaved_sections=std::nullopt, theta=std::nullopt, scaling=std::nullopt, mode=std::nullopt, rotary_dim=std::nullopt, scale=std::nullopt
op_mrope_rotary_embedding_qk_varlenClikaRT::ops::mrope_rotary_embedding_qk_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes position_ids (contract §6) interleaved_sections read only when interleaved_sections_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): interleaved_sections=std::nullopt, theta=std::nullopt, scaling=std::nullopt, mode=std::nullopt, rotary_dim=std::nullopt, scale=std::nullopt
op_mrope_rotary_embedding_varlenClikaRT::ops::mrope_rotary_embedding_varlen <- ClikaRT/compute/ops.h consumes x0 (contract §6) consumes position_ids (contract §6) interleaved_sections read only when interleaved_sections_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) C++ defaults (dropped at this surface): interleaved_sections=std::nullopt, theta=std::nullopt, scaling=std::nullopt, mode=std::nullopt, rotary_dim=std::nullopt, scale=std::nullopt
op_ms_deform_attentionClikaRT::ops::ms_deform_attention <- ClikaRT/compute/ops.h consumes value (contract §6) consumes spatial_shapes (contract §6) consumes level_start_index (contract §6) consumes sampling_locations (contract §6) consumes attention_weights (contract §6)
op_mse_lossClikaRT::ops::mse_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean
op_mul_inplaceClikaRT::ops::mul_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): activation=Activation::Identity
op_mul_scalar_lhsClikaRT::ops::mul <- ClikaRT/compute/ops.h one form of the overloaded C++ mul; the _scalar_lhs suffix names this form consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity
op_mul_tensorClikaRT::ops::mul <- ClikaRT/compute/ops.h one form of the overloaded C++ mul; the _tensor suffix names this form consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): activation=Activation::Identity
op_multinomialClikaRT::ops::multinomial <- ClikaRT/compute/ops.h consumes probabilities (contract §6) C++ defaults (dropped at this surface): replacement=false, s={}
op_mvClikaRT::ops::mv <- ClikaRT/compute/ops.h consumes a (contract §6) consumes vec (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt
op_nan_to_numClikaRT::ops::nan_to_num <- ClikaRT/compute/ops.h consumes x (contract §6) nan read only when nan_has is nonzero (contract §9) posinf read only when posinf_has is nonzero (contract §9) neginf read only when neginf_has is nonzero (contract §9) C++ defaults (dropped at this surface): nan=std::nullopt, posinf=std::nullopt, neginf=std::nullopt
op_nan_to_num_inplaceClikaRT::ops::nan_to_num_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) nan read only when nan_has is nonzero (contract §9) posinf read only when posinf_has is nonzero (contract §9) neginf read only when neginf_has is nonzero (contract §9) C++ defaults (dropped at this surface): nan=std::nullopt, posinf=std::nullopt, neginf=std::nullopt
op_nanmeanClikaRT::ops::nanmean <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false
op_nanmedianClikaRT::ops::nanmedian <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false
op_nanquantileClikaRT::ops::nanquantile <- ClikaRT/compute/ops.h consumes x (contract §6) q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false, interpolation=QuantileInterp::Linear
op_nansumClikaRT::ops::nansum <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false
op_narrowClikaRT::ops::narrow <- ClikaRT/compute/ops.h consumes x (contract §6) an embedded tensor is BORROWED (contract §11) an embedded tensor is BORROWED (contract §11)
op_ndimClikaRT::ops::ndim <- ClikaRT/compute/ops.h consumes x (contract §6)
op_ndim_hostClikaRT::ops::ndim_host <- ClikaRT/compute/ops.h consumes x (contract §6)
op_neClikaRT::ops::ne <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_ne_inplaceClikaRT::ops::ne_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_negClikaRT::ops::neg <- ClikaRT/compute/ops.h consumes x (contract §6)
op_neg_inplaceClikaRT::ops::neg_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_nll_lossClikaRT::ops::nll_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) optional; NULL = absent; consumes weight when present (contract §6) ignore_index read only when ignore_index_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, ignore_index=std::nullopt, reduction=Reduction::Mean
op_nmsClikaRT::ops::nms <- ClikaRT/compute/ops.h consumes boxes (contract §6) consumes scores (contract §6) max_output_boxes_per_class.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) iou_threshold.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) score_threshold.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): max_output_boxes_per_class=std::nullopt, iou_threshold=std::nullopt, score_threshold=std::nullopt, center_point_box=false
op_nonzeroClikaRT::ops::nonzero <- ClikaRT/compute/ops.h consumes x (contract §6)
op_normClikaRT::ops::norm <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): p=2.0, dims={}, keepdim=false
op_normalClikaRT::ops::normal <- ClikaRT/compute/ops.h mean.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) stddev.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): s={}
op_normal_inplaceClikaRT::ops::normal_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) mean.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) stddev.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): mean=0, stddev=1, s={}
op_normalizeClikaRT::ops::normalize <- ClikaRT/compute/ops.h consumes x (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): p=2.0, dim=1, eps=std::nullopt
op_normalize_inplaceClikaRT::ops::normalize_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): p=2.0, dim=1, eps=std::nullopt
op_numelClikaRT::ops::numel <- ClikaRT/compute/ops.h consumes x (contract §6)
op_numel_hostClikaRT::ops::numel_host <- ClikaRT/compute/ops.h consumes x (contract §6)
op_one_hotClikaRT::ops::one_hot <- ClikaRT/compute/ops.h consumes indices (contract §6)
op_onesClikaRT::ops::ones <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): s={}, pinned_for={}
op_ones_likeClikaRT::ops::ones_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}
op_outerClikaRT::ops::outer <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_padClikaRT::ops::pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): mode=PadMode::Constant, value=std::nullopt
op_pairwise_distanceClikaRT::ops::pairwise_distance <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): p=2.0, eps=std::nullopt, keepdim=false
op_pdistClikaRT::ops::pdist <- ClikaRT/compute/ops.h consumes a (contract §6) C++ defaults (dropped at this surface): p=2.0
op_permuteClikaRT::ops::permute <- ClikaRT/compute/ops.h consumes x (contract §6)
op_pixel_shuffleClikaRT::ops::pixel_shuffle <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): mode=PixelShuffleMode::CRD
op_pixel_unshuffleClikaRT::ops::pixel_unshuffle <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): mode=PixelShuffleMode::CRD
op_poissonClikaRT::ops::poisson <- ClikaRT/compute/ops.h consumes rates (contract §6) C++ defaults (dropped at this surface): s={}
op_powClikaRT::ops::pow <- ClikaRT/compute/ops.h consumes a (contract §6) exponent.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_pow_inplaceClikaRT::ops::pow_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) exponent.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_preluClikaRT::ops::prelu <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) C++ defaults (dropped at this surface): weight={}
op_prelu_inplaceClikaRT::ops::prelu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) optional; NULL = absent; consumes weight when present (contract §6) C++ defaults (dropped at this surface): weight={}
op_prodClikaRT::ops::prod <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, dtype=DataType::Undefined
op_putClikaRT::ops::put <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) consumes source (contract §6) C++ defaults (dropped at this surface): accumulate=false
op_put_inplaceClikaRT::ops::put_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes index (contract §6) consumes source (contract §6) C++ defaults (dropped at this surface): accumulate=false
op_q_embeddingClikaRT::ops::q_embedding <- ClikaRT/compute/q_tensor.h consumes indices (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, out_dtype=DataType::Undefined
op_qadd_inplace_to_denseClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qadd_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qadd_inplace_to_dense_out_scaleClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qadd_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity
op_qadd_inplace_to_quantizedClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qadd_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qadd_to_denseClikaRT::ops::qadd <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qadd; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qadd_to_quantizedClikaRT::ops::qadd <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qadd; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity
op_qconcat_inplace_to_denseClikaRT::ops::qconcat_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconcat_; the _to_dense suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity
op_qconcat_inplace_to_quantizedClikaRT::ops::qconcat_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconcat_; the _to_quantized suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qconcat_to_denseClikaRT::ops::qconcat <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconcat; the _to_dense suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): dim=0, activation=Activation::Identity
op_qconcat_to_quantizedClikaRT::ops::qconcat <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconcat; the _to_quantized suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity
op_qconv1d_to_denseClikaRT::ops::qconv1d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv1d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, dilation={1}, groups=1, activation=Activation::Identity
op_qconv1d_to_quantizedClikaRT::ops::qconv1d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv1d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qconv1d_woqClikaRT::ops::qconv1d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, dilation={1}, groups=1, activation=Activation::Identity
op_qconv2d_to_denseClikaRT::ops::qconv2d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv2d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity
op_qconv2d_to_quantizedClikaRT::ops::qconv2d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv2d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qconv2d_woqClikaRT::ops::qconv2d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity
op_qconv3d_to_denseClikaRT::ops::qconv3d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv3d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity
op_qconv3d_to_quantizedClikaRT::ops::qconv3d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv3d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qconv3d_woqClikaRT::ops::qconv3d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity
op_qconv_inplace_to_denseClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity
op_qconv_inplace_to_dense_out_scaleClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): out_quant_axis=-1, bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity
op_qconv_inplace_to_quantizedClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity
op_qconv_to_denseClikaRT::ops::qconv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity
op_qconv_to_quantizedClikaRT::ops::qconv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qconv_transpose1d_to_denseClikaRT::ops::qconv_transpose1d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose1d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, output_padding={0}, dilation={1}, groups=1, activation=Activation::Identity
op_qconv_transpose1d_to_quantizedClikaRT::ops::qconv_transpose1d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose1d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qconv_transpose1d_woqClikaRT::ops::qconv_transpose1d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, output_padding={0}, dilation={1}, groups=1, activation=Activation::Identity
op_qconv_transpose2d_to_denseClikaRT::ops::qconv_transpose2d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose2d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, output_padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity
op_qconv_transpose2d_to_quantizedClikaRT::ops::qconv_transpose2d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose2d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qconv_transpose2d_woqClikaRT::ops::qconv_transpose2d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, output_padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity
op_qconv_transpose3d_to_denseClikaRT::ops::qconv_transpose3d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose3d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, output_padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity
op_qconv_transpose3d_to_quantizedClikaRT::ops::qconv_transpose3d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose3d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qconv_transpose3d_woqClikaRT::ops::qconv_transpose3d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, output_padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity
op_qconv_transpose_inplace_to_denseClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_transpose_; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity
op_qconv_transpose_inplace_to_dense_out_scaleClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_transpose_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): out_quant_axis=-1, bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity
op_qconv_transpose_inplace_to_quantizedClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_transpose_; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity
op_qconv_transpose_to_denseClikaRT::ops::qconv_transpose <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity
op_qconv_transpose_to_quantizedClikaRT::ops::qconv_transpose <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qconv_transpose_woqClikaRT::ops::qconv_transpose_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity, compute_mode=QComputeMode::ExactFP
op_qconv_woqClikaRT::ops::qconv_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity, compute_mode=QComputeMode::ExactFP
op_qdeform_conv_to_denseClikaRT::ops::qdeform_conv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qdeform_conv; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) consumes offset (contract §6) optional; NULL = absent; consumes mask when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): mask={}, bias={}, stride={}, padding={}, dilation={}, groups=1, offset_groups=1, activation=Activation::Identity
op_qdeform_conv_to_quantizedClikaRT::ops::qdeform_conv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qdeform_conv; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) consumes offset (contract §6) optional; NULL = absent; consumes mask when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qdeform_conv_woqClikaRT::ops::qdeform_conv_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) consumes offset (contract §6) optional; NULL = absent; consumes mask when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): mask={}, bias={}, stride={}, padding={}, dilation={}, groups=1, offset_groups=1, activation=Activation::Identity, compute_mode=QComputeMode::ExactFP
op_qdiv_inplace_to_denseClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qdiv_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qdiv_inplace_to_dense_out_scaleClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qdiv_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity
op_qdiv_inplace_to_quantizedClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qdiv_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qdiv_to_denseClikaRT::ops::qdiv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qdiv; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qdiv_to_quantizedClikaRT::ops::qdiv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qdiv; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity
op_qfast_gelu_inplace_to_denseClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qfast_gelu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qfast_gelu_inplace_to_dense_out_scaleClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qfast_gelu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_qfast_gelu_inplace_to_quantizedClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qfast_gelu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qfast_gelu_to_denseClikaRT::ops::qfast_gelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qfast_gelu; the _to_dense suffix names this form consumes a (contract §6)
op_qfast_gelu_to_quantizedClikaRT::ops::qfast_gelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qfast_gelu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qgelu_inplace_to_denseClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qgelu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qgelu_inplace_to_dense_out_scaleClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qgelu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_qgelu_inplace_to_quantizedClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qgelu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qgelu_to_denseClikaRT::ops::qgelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qgelu; the _to_dense suffix names this form consumes a (contract §6)
op_qgelu_to_quantizedClikaRT::ops::qgelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qgelu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qhardswish_inplace_to_denseClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qhardswish_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qhardswish_inplace_to_dense_out_scaleClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qhardswish_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_qhardswish_inplace_to_quantizedClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qhardswish_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qhardswish_to_denseClikaRT::ops::qhardswish <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qhardswish; the _to_dense suffix names this form consumes a (contract §6)
op_qhardswish_to_quantizedClikaRT::ops::qhardswish <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qhardswish; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qk_layer_normClikaRT::ops::qk_layer_norm <- ClikaRT/compute/ops.h consumes q (contract §6) optional; NULL = absent; consumes k when present (contract §6) optional; NULL = absent; consumes v when present (contract §6) optional; NULL = absent; consumes w_q when present (contract §6) optional; NULL = absent; consumes b_q when present (contract §6) optional; NULL = absent; consumes w_k when present (contract §6) optional; NULL = absent; consumes b_k when present (contract §6) eps read only when eps_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): k={}, v={}, w_q={}, b_q={}, w_k={}, b_k={}, head_dim=0, eps=std::nullopt
op_qk_layer_norm_inplaceClikaRT::ops::qk_layer_norm_ <- ClikaRT/compute/ops.h in-place op borrows q; written through (the in-place target) optional; NULL = absent; consumes k when present (contract §6) optional; NULL = absent; consumes v when present (contract §6) optional; NULL = absent; consumes w_q when present (contract §6) optional; NULL = absent; consumes b_q when present (contract §6) optional; NULL = absent; consumes w_k when present (contract §6) optional; NULL = absent; consumes b_k when present (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): k={}, v={}, w_q={}, b_q={}, w_k={}, b_k={}, head_dim=0, eps=std::nullopt
op_qk_rms_normClikaRT::ops::qk_rms_norm <- ClikaRT/compute/ops.h consumes q (contract §6) optional; NULL = absent; consumes k when present (contract §6) optional; NULL = absent; consumes v when present (contract §6) optional; NULL = absent; consumes w_q when present (contract §6) optional; NULL = absent; consumes w_k when present (contract §6) eps read only when eps_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): k={}, v={}, w_q={}, w_k={}, head_dim=0, eps=std::nullopt
op_qk_rms_norm_inplaceClikaRT::ops::qk_rms_norm_ <- ClikaRT/compute/ops.h in-place op borrows q; written through (the in-place target) optional; NULL = absent; consumes k when present (contract §6) optional; NULL = absent; consumes v when present (contract §6) optional; NULL = absent; consumes w_q when present (contract §6) optional; NULL = absent; consumes w_k when present (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): k={}, v={}, w_q={}, w_k={}, head_dim=0, eps=std::nullopt
op_qleaky_relu_inplace_to_denseClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qleaky_relu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qleaky_relu_inplace_to_dense_out_scaleClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qleaky_relu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_qleaky_relu_inplace_to_quantizedClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qleaky_relu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qleaky_relu_to_denseClikaRT::ops::qleaky_relu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qleaky_relu; the _to_dense suffix names this form consumes a (contract §6) C++ defaults (dropped at this surface): negative_slope=0.01
op_qleaky_relu_to_quantizedClikaRT::ops::qleaky_relu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qleaky_relu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qlinear_inplace_to_denseClikaRT::ops::qlinear_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qlinear_; the _to_dense suffix names this form consumes x (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt
op_qlinear_inplace_to_quantizedClikaRT::ops::qlinear_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qlinear_; the _to_quantized suffix names this form consumes x (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt
op_qlinear_to_denseClikaRT::ops::qlinear <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qlinear; the _to_dense suffix names this form consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt
op_qlinear_to_quantizedClikaRT::ops::qlinear <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qlinear; the _to_quantized suffix names this form consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qlinear_woqClikaRT::ops::qlinear_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, compute_mode=QComputeMode::ExactFP
op_qlinear_woq_inplaceClikaRT::ops::qlinear_woq_ <- ClikaRT/compute/q_tensor.h in-place op consumes x (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, compute_mode=QComputeMode::ExactFP
op_qmatmul_inplace_to_denseClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmatmul_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false
op_qmatmul_inplace_to_dense_out_scaleClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmatmul_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): out_quant_axis=-1, bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false
op_qmatmul_inplace_to_quantizedClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmatmul_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false
op_qmatmul_to_denseClikaRT::ops::qmatmul <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmatmul; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false
op_qmatmul_to_quantizedClikaRT::ops::qmatmul <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmatmul; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qmatmul_woqClikaRT::ops::qmatmul_woq <- ClikaRT/compute/q_tensor.h consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false, compute_mode=QComputeMode::ExactFP
op_qmatmul_woq_inplaceClikaRT::ops::qmatmul_woq_ <- ClikaRT/compute/q_tensor.h in-place op consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false, compute_mode=QComputeMode::ExactFP
op_qmoe_to_denseClikaRT::ops::qmoe <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmoe; the _to_dense suffix names this form consumes input (contract §6) consumes router_logits (contract §6) consumes fc1_experts (contract §6) consumes fc2_experts (contract §6) optional; NULL = absent; consumes fc1_bias when present (contract §6) optional; NULL = absent; consumes fc2_bias when present (contract §6) consumes fc3_experts (contract §6) optional; NULL = absent; consumes fc3_bias when present (contract §6) optional; NULL = absent; consumes e_score_correction_bias when present (contract §6) optional; NULL = absent; consumes router_weights when present (contract §6) routing_mode read only when routing_mode_has is nonzero (contract §9) renormalize read only when renormalize_has is nonzero (contract §9) n_group read only when n_group_has is nonzero (contract §9) topk_group read only when topk_group_has is nonzero (contract §9) routed_scaling_factor read only when routed_scaling_factor_has is nonzero (contract §9) sparse_mixer_eps read only when sparse_mixer_eps_has is nonzero (contract §9) apply_router_weight_on_input read only when apply_router_weight_on_input_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) swiglu_fusion read only when swiglu_fusion_has is nonzero (contract §9) swiglu_alpha read only when swiglu_alpha_has is nonzero (contract §9) swiglu_beta read only when swiglu_beta_has is nonzero (contract §9) swiglu_limit read only when swiglu_limit_has is nonzero (contract §9) gelu_mode read only when gelu_mode_has is nonzero (contract §9) optional; NULL = absent; consumes shared_output when present (contract §6) C++ defaults (dropped at this surface): fc1_bias={}, fc2_bias={}, fc3_experts={}, fc3_bias={}, e_score_correction_bias={}, router_weights={}, routing_mode=std::nullopt, renormalize=std::nullopt, n_group=std::nullopt, topk_group=std::nullopt, routed_scaling_factor=std::nullopt, sparse_mixer_eps=std::nullopt, apply_router_weight_on_input=std::nullopt, activation=std::nullopt, swiglu_fusion=std::nullopt, swiglu_alpha=std::nullopt, swiglu_beta=std::nullopt, swiglu_limit=std::nullopt, gelu_mode=std::nullopt, shared_output={}
op_qmoe_to_quantizedClikaRT::ops::qmoe <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmoe; the _to_quantized suffix names this form consumes input (contract §6) consumes router_logits (contract §6) consumes fc1_experts (contract §6) consumes fc2_experts (contract §6) optional; NULL = absent; consumes fc1_bias when present (contract §6) optional; NULL = absent; consumes fc2_bias when present (contract §6) consumes fc3_experts (contract §6) optional; NULL = absent; consumes fc3_bias when present (contract §6) optional; NULL = absent; consumes e_score_correction_bias when present (contract §6) optional; NULL = absent; consumes router_weights when present (contract §6) routing_mode read only when routing_mode_has is nonzero (contract §9) renormalize read only when renormalize_has is nonzero (contract §9) n_group read only when n_group_has is nonzero (contract §9) topk_group read only when topk_group_has is nonzero (contract §9) routed_scaling_factor read only when routed_scaling_factor_has is nonzero (contract §9) sparse_mixer_eps read only when sparse_mixer_eps_has is nonzero (contract §9) apply_router_weight_on_input read only when apply_router_weight_on_input_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) swiglu_fusion read only when swiglu_fusion_has is nonzero (contract §9) swiglu_alpha read only when swiglu_alpha_has is nonzero (contract §9) swiglu_beta read only when swiglu_beta_has is nonzero (contract §9) swiglu_limit read only when swiglu_limit_has is nonzero (contract §9) gelu_mode read only when gelu_mode_has is nonzero (contract §9) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) optional; NULL = absent; consumes shared_output when present (contract §6) C++ defaults (dropped at this surface): out_quant_axis=-1, out_dtype=DataType::Undefined, shared_output={}
op_qmoe_woqClikaRT::ops::qmoe_woq <- ClikaRT/compute/q_tensor.h consumes input (contract §6) consumes router_logits (contract §6) consumes fc1_experts (contract §6) consumes fc2_experts (contract §6) optional; NULL = absent; consumes fc1_bias when present (contract §6) optional; NULL = absent; consumes fc2_bias when present (contract §6) consumes fc3_experts (contract §6) optional; NULL = absent; consumes fc3_bias when present (contract §6) optional; NULL = absent; consumes e_score_correction_bias when present (contract §6) optional; NULL = absent; consumes router_weights when present (contract §6) routing_mode read only when routing_mode_has is nonzero (contract §9) renormalize read only when renormalize_has is nonzero (contract §9) n_group read only when n_group_has is nonzero (contract §9) topk_group read only when topk_group_has is nonzero (contract §9) routed_scaling_factor read only when routed_scaling_factor_has is nonzero (contract §9) sparse_mixer_eps read only when sparse_mixer_eps_has is nonzero (contract §9) apply_router_weight_on_input read only when apply_router_weight_on_input_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) swiglu_fusion read only when swiglu_fusion_has is nonzero (contract §9) swiglu_alpha read only when swiglu_alpha_has is nonzero (contract §9) swiglu_beta read only when swiglu_beta_has is nonzero (contract §9) swiglu_limit read only when swiglu_limit_has is nonzero (contract §9) gelu_mode read only when gelu_mode_has is nonzero (contract §9) optional; NULL = absent; consumes shared_output when present (contract §6) C++ defaults (dropped at this surface): fc1_bias={}, fc2_bias={}, fc3_experts={}, fc3_bias={}, e_score_correction_bias={}, router_weights={}, routing_mode=std::nullopt, renormalize=std::nullopt, n_group=std::nullopt, topk_group=std::nullopt, routed_scaling_factor=std::nullopt, sparse_mixer_eps=std::nullopt, apply_router_weight_on_input=std::nullopt, activation=std::nullopt, swiglu_fusion=std::nullopt, swiglu_alpha=std::nullopt, swiglu_beta=std::nullopt, swiglu_limit=std::nullopt, gelu_mode=std::nullopt, shared_output={}
op_qmul_inplace_to_denseClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmul_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qmul_inplace_to_dense_out_scaleClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmul_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity
op_qmul_inplace_to_quantizedClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmul_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qmul_to_denseClikaRT::ops::qmul <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmul; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qmul_to_quantizedClikaRT::ops::qmul <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmul; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity
op_qquick_gelu_inplace_to_denseClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qquick_gelu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qquick_gelu_inplace_to_dense_out_scaleClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qquick_gelu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_qquick_gelu_inplace_to_quantizedClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qquick_gelu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qquick_gelu_to_denseClikaRT::ops::qquick_gelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qquick_gelu; the _to_dense suffix names this form consumes a (contract §6)
op_qquick_gelu_to_quantizedClikaRT::ops::qquick_gelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qquick_gelu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qrelu_inplace_to_denseClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qrelu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qrelu_inplace_to_dense_out_scaleClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qrelu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_qrelu_inplace_to_quantizedClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qrelu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qrelu_to_denseClikaRT::ops::qrelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qrelu; the _to_dense suffix names this form consumes a (contract §6)
op_qrelu_to_quantizedClikaRT::ops::qrelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qrelu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qsigmoid_inplace_to_denseClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsigmoid_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qsigmoid_inplace_to_dense_out_scaleClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsigmoid_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_qsigmoid_inplace_to_quantizedClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsigmoid_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qsigmoid_to_denseClikaRT::ops::qsigmoid <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsigmoid; the _to_dense suffix names this form consumes a (contract §6)
op_qsigmoid_to_quantizedClikaRT::ops::qsigmoid <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsigmoid; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qsilu_inplace_to_denseClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsilu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qsilu_inplace_to_dense_out_scaleClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsilu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_qsilu_inplace_to_quantizedClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsilu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qsilu_to_denseClikaRT::ops::qsilu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsilu; the _to_dense suffix names this form consumes a (contract §6)
op_qsilu_to_quantizedClikaRT::ops::qsilu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsilu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_qsub_inplace_to_denseClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsub_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qsub_inplace_to_dense_out_scaleClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsub_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity
op_qsub_inplace_to_quantizedClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsub_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qsub_to_denseClikaRT::ops::qsub <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsub; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity
op_qsub_to_quantizedClikaRT::ops::qsub <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsub; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity
op_qtanh_inplace_to_denseClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qtanh_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qtanh_inplace_to_dense_out_scaleClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qtanh_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_qtanh_inplace_to_quantizedClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qtanh_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_qtanh_to_denseClikaRT::ops::qtanh <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qtanh; the _to_dense suffix names this form consumes a (contract §6)
op_qtanh_to_quantizedClikaRT::ops::qtanh <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qtanh; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_quantileClikaRT::ops::quantile <- ClikaRT/compute/ops.h consumes x (contract §6) q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false, interpolation=QuantileInterp::Linear
op_quantizeClikaRT::ops::quantize <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes scale (contract §6) optional; NULL = absent; consumes zero_point when present (contract §6) C++ defaults (dropped at this surface): zero_point={}, quant_axis=-1, out_dtype=DataType::Undefined, block_size=0
op_quantize_dequantizeClikaRT::ops::quantize_dequantize <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes scale (contract §6) optional; NULL = absent; consumes zero_point when present (contract §6) C++ defaults (dropped at this surface): zero_point={}, quant_axis=-1, code_dtype=DataType::Undefined, out_dtype=DataType::Undefined, block_size=0
op_quantize_inplace_to_denseClikaRT::ops::quantize_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ quantize_; the _to_dense suffix names this form consumes x (contract §6) borrows out; written through (the in-place target) consumes scale (contract §6) optional; NULL = absent; consumes zero_point when present (contract §6) C++ defaults (dropped at this surface): zero_point={}, quant_axis=-1, block_size=0
op_quantize_inplace_to_quantizedClikaRT::ops::quantize_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ quantize_; the _to_quantized suffix names this form consumes x (contract §6) borrows out; written through (the in-place target)
op_quantize_to_schemeClikaRT::ops::quantize_to_scheme <- ClikaRT/compute/q_tensor.h consumes x (contract §6) optional; NULL = absent; consumes scale when present (contract §6) C++ defaults (dropped at this surface): scale={}
op_quick_geluClikaRT::ops::quick_gelu <- ClikaRT/compute/ops.h consumes x (contract §6)
op_rad2degClikaRT::ops::rad2deg <- ClikaRT/compute/ops.h consumes x (contract §6)
op_rad2deg_inplaceClikaRT::ops::rad2deg_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_randClikaRT::ops::rand <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Float32, s={}
op_rand_likeClikaRT::ops::rand_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}
op_randintClikaRT::ops::randint <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Int64, s={}
op_randint_likeClikaRT::ops::randint_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}
op_randnClikaRT::ops::randn <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Float32, s={}
op_randn_likeClikaRT::ops::randn_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}
op_random_inplaceClikaRT::ops::random_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) low read only when low_has is nonzero (contract §9) high read only when high_has is nonzero (contract §9) C++ defaults (dropped at this surface): low=std::nullopt, high=std::nullopt, s={}
op_randpermClikaRT::ops::randperm <- ClikaRT/compute/ops.h n.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Int64, s={}
op_reciprocalClikaRT::ops::reciprocal <- ClikaRT/compute/ops.h consumes x (contract §6)
op_reciprocal_inplaceClikaRT::ops::reciprocal_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_reflect_padClikaRT::ops::reflect_pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)
op_regluClikaRT::ops::reglu <- ClikaRT/compute/ops.h consumes x (contract §6)
op_reluClikaRT::ops::relu <- ClikaRT/compute/ops.h consumes x (contract §6)
op_relu6ClikaRT::ops::relu6 <- ClikaRT/compute/ops.h consumes x (contract §6)
op_relu6_inplaceClikaRT::ops::relu6_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_relu_inplaceClikaRT::ops::relu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_remainderClikaRT::ops::remainder <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_remainder_inplaceClikaRT::ops::remainder_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_renormClikaRT::ops::renorm <- ClikaRT/compute/ops.h consumes x (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): eps=std::nullopt
op_renorm_inplaceClikaRT::ops::renorm_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): eps=std::nullopt
op_repeatClikaRT::ops::repeat <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)
op_repeat_interleaveClikaRT::ops::repeat_interleave <- ClikaRT/compute/ops.h consumes x (contract §6) repeats.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) dim read only when dim_has is nonzero (contract §9) output_size read only when output_size_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt, output_size=std::nullopt
op_replicate_padClikaRT::ops::replicate_pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)
op_requantizeClikaRT::ops::requantize <- ClikaRT/compute/q_tensor.h consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined
op_requantize_inplace_to_denseClikaRT::ops::requantize_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ requantize_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1
op_requantize_inplace_to_quantizedClikaRT::ops::requantize_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ requantize_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)
op_resampleClikaRT::ops::resample <- ClikaRT/compute/ops.h consumes x (contract §6) beta read only when beta_has is nonzero (contract §9) C++ defaults (dropped at this surface): lowpass_filter_width=16, rolloff=0.945, beta=std::nullopt
op_reshapeClikaRT::ops::reshape <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)
op_reshape_asClikaRT::ops::reshape_as <- ClikaRT/compute/ops.h consumes x (contract §6) consumes other (contract §6)
op_rfftClikaRT::ops::rfft <- ClikaRT/compute/ops.h consumes x (contract §6) n_fft read only when n_fft_has is nonzero (contract §9) C++ defaults (dropped at this surface): n_fft=std::nullopt, normalized=false
op_rms_normClikaRT::ops::rms_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, eps=std::nullopt, activation=std::nullopt
op_rollClikaRT::ops::roll <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}
op_rot90ClikaRT::ops::rot90 <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): k=1, dims={0, 1}
op_rotary_embeddingClikaRT::ops::rotary_embedding <- ClikaRT/compute/ops.h consumes x0 (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes cos when present (contract §6) optional; NULL = absent; consumes sin when present (contract §6) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) C++ defaults (dropped at this surface): position_ids={}, cos={}, sin={}, mode=std::nullopt, rotary_dim=std::nullopt, theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}
op_rotary_embedding_qkClikaRT::ops::rotary_embedding_qk <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes cos when present (contract §6) optional; NULL = absent; consumes sin when present (contract §6) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): position_ids={}, cos={}, sin={}, mode=std::nullopt, rotary_dim=std::nullopt, theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}
op_rotary_embedding_qk_varlenClikaRT::ops::rotary_embedding_qk_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes cu_seqlens (contract §6) optional; NULL = absent; consumes seqlens when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes cos when present (contract §6) optional; NULL = absent; consumes sin when present (contract §6) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): seqlens={}, position_ids={}, cos={}, sin={}, mode=std::nullopt, rotary_dim=std::nullopt, theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}
op_rotary_embedding_varlenClikaRT::ops::rotary_embedding_varlen <- ClikaRT/compute/ops.h consumes x0 (contract §6) consumes cu_seqlens (contract §6) optional; NULL = absent; consumes seqlens when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes cos when present (contract §6) optional; NULL = absent; consumes sin when present (contract §6) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) C++ defaults (dropped at this surface): seqlens={}, position_ids={}, cos={}, sin={}, mode=std::nullopt, rotary_dim=std::nullopt, theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}
op_roundClikaRT::ops::round <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): decimals=0
op_round_inplaceClikaRT::ops::round_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): decimals=0
op_rsqrtClikaRT::ops::rsqrt <- ClikaRT/compute/ops.h consumes x (contract §6)
op_rsqrt_inplaceClikaRT::ops::rsqrt_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_scaled_dot_product_attentionClikaRT::ops::scaled_dot_product_attention <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): attn_mask={}, is_causal=false, q_scale={}, k_scale={}, v_scale={}
op_scaled_dot_product_attention_varlenClikaRT::ops::scaled_dot_product_attention_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) consumes cu_seqlens_q (contract §6) consumes cu_seqlens_k (contract §6) max_seqlen_q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max_seqlen_k.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes attn_mask when present (contract §6) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): max_seqlen_q={}, max_seqlen_k={}, attn_mask={}, is_causal=false, q_scale={}, k_scale={}, v_scale={}
op_scatterClikaRT::ops::scatter <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) src.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_scatter_addClikaRT::ops::scatter_add <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) consumes src (contract §6) C++ defaults (dropped at this surface): deterministic=false
op_scatter_add_inplaceClikaRT::ops::scatter_add_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes index (contract §6) consumes src (contract §6) C++ defaults (dropped at this surface): deterministic=false
op_scatter_inplaceClikaRT::ops::scatter_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes index (contract §6) src.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_scatter_reduceClikaRT::ops::scatter_reduce <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) consumes src (contract §6) C++ defaults (dropped at this surface): include_self=true, deterministic=false
op_scatter_reduce_inplaceClikaRT::ops::scatter_reduce_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes index (contract §6) consumes src (contract §6) C++ defaults (dropped at this surface): include_self=true, deterministic=false
op_searchsortedClikaRT::ops::searchsorted <- ClikaRT/compute/ops.h consumes sorted_sequence (contract §6) consumes values (contract §6) side read only when side_has is nonzero (contract §9) optional; NULL = absent; consumes sorter when present (contract §6) C++ defaults (dropped at this surface): out_int32=false, right=false, side=std::nullopt, sorter={}
op_selectClikaRT::ops::select <- ClikaRT/compute/ops.h consumes x (contract §6) an embedded tensor is BORROWED (contract §11)
op_seluClikaRT::ops::selu <- ClikaRT/compute/ops.h consumes x (contract §6)
op_selu_inplaceClikaRT::ops::selu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_sgnClikaRT::ops::sgn <- ClikaRT/compute/ops.h consumes x (contract §6)
op_sgn_inplaceClikaRT::ops::sgn_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_shape_dimClikaRT::ops::shape <- ClikaRT/compute/ops.h one form of the overloaded C++ shape; the _dim suffix names this form consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt
op_shape_host_allClikaRT::ops::shape_host <- ClikaRT/compute/ops.h one form of the overloaded C++ shape_host; the _all suffix names this form consumes x (contract §6)
op_shape_host_dimClikaRT::ops::shape_host <- ClikaRT/compute/ops.h one form of the overloaded C++ shape_host; the _dim suffix names this form consumes x (contract §6)
op_shape_host_rangeClikaRT::ops::shape_host <- ClikaRT/compute/ops.h one form of the overloaded C++ shape_host; the _range suffix names this form consumes x (contract §6) start read only when start_has is nonzero (contract §9) end read only when end_has is nonzero (contract §9)
op_shape_rangeClikaRT::ops::shape <- ClikaRT/compute/ops.h one form of the overloaded C++ shape; the _range suffix names this form consumes x (contract §6) start read only when start_has is nonzero (contract §9) end read only when end_has is nonzero (contract §9)
op_sigmoidClikaRT::ops::sigmoid <- ClikaRT/compute/ops.h consumes x (contract §6)
op_sigmoid_inplaceClikaRT::ops::sigmoid_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_signClikaRT::ops::sign <- ClikaRT/compute/ops.h consumes x (contract §6)
op_sign_inplaceClikaRT::ops::sign_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_siluClikaRT::ops::silu <- ClikaRT/compute/ops.h consumes x (contract §6)
op_silu_inplaceClikaRT::ops::silu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_sinClikaRT::ops::sin <- ClikaRT/compute/ops.h consumes x (contract §6)
op_sin_inplaceClikaRT::ops::sin_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_sincClikaRT::ops::sinc <- ClikaRT/compute/ops.h consumes x (contract §6)
op_sinc_inplaceClikaRT::ops::sinc_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_sinhClikaRT::ops::sinh <- ClikaRT/compute/ops.h consumes x (contract §6)
op_sinh_inplaceClikaRT::ops::sinh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_slice_dimClikaRT::ops::slice <- ClikaRT/compute/ops.h one form of the overloaded C++ slice; the _dim suffix names this form consumes x (contract §6) an embedded tensor is BORROWED (contract §11) an embedded tensor is BORROWED (contract §11) an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): start={}, end={}, step=1
op_slice_dimsClikaRT::ops::slice <- ClikaRT/compute/ops.h one form of the overloaded C++ slice; the _dims suffix names this form consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): start={}, end={}, step={}
op_smooth_l1_lossClikaRT::ops::smooth_l1_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean, beta=1.0
op_snakeClikaRT::ops::snake <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes alpha when present (contract §6) optional; NULL = absent; consumes beta when present (contract §6) C++ defaults (dropped at this surface): alpha={}, beta={}, eps=1e-9
op_snake_inplaceClikaRT::ops::snake_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) optional; NULL = absent; consumes alpha when present (contract §6) optional; NULL = absent; consumes beta when present (contract §6) C++ defaults (dropped at this surface): alpha={}, beta={}, eps=1e-9
op_softcap_logitsClikaRT::ops::softcap_logits <- ClikaRT/compute/ops.h consumes x (contract §6) cap.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_softcap_logits_inplaceClikaRT::ops::softcap_logits_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) cap.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_softmaxClikaRT::ops::softmax <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1, dtype=DataType::Undefined
op_softmax_inplaceClikaRT::ops::softmax_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dim=-1
op_softminClikaRT::ops::softmin <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1, dtype=DataType::Undefined
op_softmin_inplaceClikaRT::ops::softmin_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dim=-1
op_softplusClikaRT::ops::softplus <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): beta=1.0, threshold=20.0
op_softplus_inplaceClikaRT::ops::softplus_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): beta=1.0, threshold=20.0
op_softshrinkClikaRT::ops::softshrink <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): lambd=0.5
op_softshrink_inplaceClikaRT::ops::softshrink_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): lambd=0.5
op_softsignClikaRT::ops::softsign <- ClikaRT/compute/ops.h consumes x (contract §6)
op_softsign_inplaceClikaRT::ops::softsign_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_sortClikaRT::ops::sort <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=-1, descending=false, stable=false
op_split_by_sizeClikaRT::ops::split_by_size <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=0
op_split_with_sizesClikaRT::ops::split_with_sizes <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): dim=0
op_sqrtClikaRT::ops::sqrt <- ClikaRT/compute/ops.h consumes x (contract §6)
op_sqrt_inplaceClikaRT::ops::sqrt_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_squareClikaRT::ops::square <- ClikaRT/compute/ops.h consumes x (contract §6)
op_square_inplaceClikaRT::ops::square_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_squeezeClikaRT::ops::squeeze <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim={}
op_squeeze_inplaceClikaRT::ops::squeeze_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dim={}
op_ssd_updateClikaRT::ops::ssd_update <- ClikaRT/compute/ops.h consumes x (contract §6) consumes dt (contract §6) consumes a_rate (contract §6) consumes b_mat (contract §6) consumes c_mat (contract §6) optional; NULL = absent; consumes d_skip when present (contract §6) optional; NULL = absent; consumes dt_bias when present (contract §6) optional; NULL = absent; consumes z when present (contract §6) consumes state (contract §6) optional; NULL = absent; consumes seq_lens when present (contract §6) optional; NULL = absent; consumes slot_ids when present (contract §6) C++ defaults (dropped at this surface): seq_lens={}, slot_ids={}, dt_softplus=false
op_stackClikaRT::ops::stack <- ClikaRT/compute/ops.h elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): dim=0
op_stdClikaRT::ops::std <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, correction=1, keepdim=false
op_stftClikaRT::ops::stft <- ClikaRT/compute/ops.h consumes x (contract §6) hop_length read only when hop_length_has is nonzero (contract §9) win_length read only when win_length_has is nonzero (contract §9) optional; NULL = absent; consumes window when present (contract §6) C++ defaults (dropped at this surface): hop_length=std::nullopt, win_length=std::nullopt, window={}, center=true, pad_mode=PadMode::Reflect, normalized=false, onesided=true
op_sub_inplaceClikaRT::ops::sub_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity
op_sub_scalar_lhsClikaRT::ops::sub <- ClikaRT/compute/ops.h one form of the overloaded C++ sub; the _scalar_lhs suffix names this form consumes b (contract §6) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity
op_sub_tensorClikaRT::ops::sub <- ClikaRT/compute/ops.h one form of the overloaded C++ sub; the _tensor suffix names this form consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity
op_sumClikaRT::ops::sum <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, dtype=DataType::Undefined
op_swigluClikaRT::ops::swiglu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): alpha=1.0, beta=0.0, limit=std::numeric_limits<double>::infinity()
op_synchronize_allClikaRT::ops::synchronize_all <- ClikaRT/compute/ops.h the underlying call is infallible plain void
op_takeClikaRT::ops::take <- ClikaRT/compute/ops.h consumes self (contract §6) consumes index (contract §6)
op_take_along_dimClikaRT::ops::take_along_dim <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt
op_tanClikaRT::ops::tan <- ClikaRT/compute/ops.h consumes x (contract §6)
op_tan_inplaceClikaRT::ops::tan_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_tanhClikaRT::ops::tanh <- ClikaRT/compute/ops.h consumes x (contract §6)
op_tanh_inplaceClikaRT::ops::tanh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_tensordotClikaRT::ops::tensordot <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)
op_thresholdClikaRT::ops::threshold <- ClikaRT/compute/ops.h consumes x (contract §6)
op_threshold_inplaceClikaRT::ops::threshold_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_tileClikaRT::ops::tile <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)
op_to_device_strClikaRT::ops::to <- ClikaRT/compute/ops.h one form of the overloaded C++ to; the _device_str suffix names this form consumes src (contract §6)
op_to_manyClikaRT::ops::to <- ClikaRT/compute/ops.h one form of the overloaded C++ to; the _many suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): target={}
op_to_tensorClikaRT::ops::to <- ClikaRT/compute/ops.h one form of the overloaded C++ to; the _tensor suffix names this form consumes src (contract §6) C++ defaults (dropped at this surface): target={}
op_topkClikaRT::ops::topk <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=-1, largest=true, sorted=true
op_traceClikaRT::ops::trace <- ClikaRT/compute/ops.h consumes x (contract §6)
op_transposeClikaRT::ops::transpose <- ClikaRT/compute/ops.h consumes x (contract §6)
op_trilClikaRT::ops::tril <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): diagonal=0
op_tril_inplaceClikaRT::ops::tril_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): diagonal=0
op_triuClikaRT::ops::triu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): diagonal=0
op_triu_inplaceClikaRT::ops::triu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): diagonal=0
op_truncClikaRT::ops::trunc <- ClikaRT/compute/ops.h consumes x (contract §6)
op_trunc_inplaceClikaRT::ops::trunc_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_unflattenClikaRT::ops::unflatten <- ClikaRT/compute/ops.h consumes x (contract §6)
op_unfoldClikaRT::ops::unfold <- ClikaRT/compute/ops.h consumes x (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): mode=PadMode::Constant, value=std::nullopt
op_uniform_inplaceClikaRT::ops::uniform_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): low=0.0, high=1.0, s={}
op_uniqueClikaRT::ops::unique <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): sorted=true, return_inverse=false, return_counts=false, dim=std::nullopt
op_unique_consecutiveClikaRT::ops::unique_consecutive <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): return_inverse=false, return_counts=false, dim=std::nullopt
op_unsqueezeClikaRT::ops::unsqueeze <- ClikaRT/compute/ops.h consumes x (contract §6)
op_unsqueeze_inplaceClikaRT::ops::unsqueeze_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)
op_upsample_bicubic2dClikaRT::ops::upsample_bicubic2d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, align_corners=false
op_upsample_bilinear2dClikaRT::ops::upsample_bilinear2d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, align_corners=false
op_upsample_linear1dClikaRT::ops::upsample_linear1d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, align_corners=false
op_upsample_nearest1dClikaRT::ops::upsample_nearest1d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}
op_upsample_nearest2dClikaRT::ops::upsample_nearest2d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}
op_upsample_nearest3dClikaRT::ops::upsample_nearest3d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}
op_upsample_trilinear3dClikaRT::ops::upsample_trilinear3d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, align_corners=false
op_validate_rotary_dimClikaRT::ops::validate_rotary_dim <- ClikaRT/compute/ops.h C++ defaults (dropped at this surface): head_dim=-1
op_varClikaRT::ops::var <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, correction=1, keepdim=false
op_where_nonzeroClikaRT::ops::where <- ClikaRT/compute/ops.h one form of the overloaded C++ where; the _nonzero suffix names this form consumes condition (contract §6)
op_where_selectClikaRT::ops::where <- ClikaRT/compute/ops.h one form of the overloaded C++ where; the _select suffix names this form consumes condition (contract §6) consumes x (contract §6) consumes y (contract §6)
op_xlog1pyClikaRT::ops::xlog1py <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_xlogyClikaRT::ops::xlogy <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_xlogy_inplaceClikaRT::ops::xlogy_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)
op_zero_inplaceClikaRT::ops::zero_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): s={}
op_zerosClikaRT::ops::zeros <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): s={}, pinned_for={}
op_zeros_likeClikaRT::ops::zeros_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}

Functions​

op_abs​

clika_rt_error*(* op_abs)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::abs <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5265

op_abs_inplace​

clika_rt_error*(* op_abs_inplace)(clika_rt_tensor *self)

ClikaRT::ops::abs_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5271

op_acos​

clika_rt_error*(* op_acos)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::acos <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5275

op_acos_inplace​

clika_rt_error*(* op_acos_inplace)(clika_rt_tensor *self)

ClikaRT::ops::acos_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5281

op_acosh​

clika_rt_error*(* op_acosh)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::acosh <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5285

op_acosh_inplace​

clika_rt_error*(* op_acosh_inplace)(clika_rt_tensor *self)

ClikaRT::ops::acosh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5291

op_adaptive_avg_pool​

clika_rt_error*(* op_adaptive_avg_pool)(clika_rt_tensor *x, const int64_t *output_size, size_t output_size_count, clika_rt_tensor **out)

ClikaRT::ops::adaptive_avg_pool <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4423

op_adaptive_avg_pool1d​

clika_rt_error*(* op_adaptive_avg_pool1d)(clika_rt_tensor *x, const int64_t *output_size, size_t output_size_count, clika_rt_tensor **out)

ClikaRT::ops::adaptive_avg_pool1d <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4430

op_adaptive_avg_pool2d​

clika_rt_error*(* op_adaptive_avg_pool2d)(clika_rt_tensor *x, const int64_t *output_size, size_t output_size_count, clika_rt_tensor **out)

ClikaRT::ops::adaptive_avg_pool2d <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4437

op_adaptive_avg_pool3d​

clika_rt_error*(* op_adaptive_avg_pool3d)(clika_rt_tensor *x, const int64_t *output_size, size_t output_size_count, clika_rt_tensor **out)

ClikaRT::ops::adaptive_avg_pool3d <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4444

op_adaptive_max_pool​

clika_rt_error*(* op_adaptive_max_pool)(clika_rt_tensor *x, const int64_t *output_size, size_t output_size_count, clika_rt_tensor **out)

ClikaRT::ops::adaptive_max_pool <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4451

op_adaptive_max_pool1d​

clika_rt_error*(* op_adaptive_max_pool1d)(clika_rt_tensor *x, const int64_t *output_size, size_t output_size_count, clika_rt_tensor **out)

ClikaRT::ops::adaptive_max_pool1d <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4458

op_adaptive_max_pool2d​

clika_rt_error*(* op_adaptive_max_pool2d)(clika_rt_tensor *x, const int64_t *output_size, size_t output_size_count, clika_rt_tensor **out)

ClikaRT::ops::adaptive_max_pool2d <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4465

op_adaptive_max_pool3d​

clika_rt_error*(* op_adaptive_max_pool3d)(clika_rt_tensor *x, const int64_t *output_size, size_t output_size_count, clika_rt_tensor **out)

ClikaRT::ops::adaptive_max_pool3d <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4472

op_add_inplace​

clika_rt_error*(* op_add_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other, double alpha, clika_rt_activation activation)

ClikaRT::ops::add_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1574

op_add_layer_norm​

clika_rt_error*(* op_add_layer_norm)(clika_rt_tensor *x, clika_rt_tensor *residual, clika_rt_tensor *post_residual, const int64_t *normalized_shape, size_t normalized_shape_count, clika_rt_tensor *skip_bias, clika_rt_tensor *weight, clika_rt_tensor *bias, uint8_t eps_has, double eps, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::add_layer_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes residual when present (contract §6) optional; NULL = absent; consumes post_residual when present (contract §6) optional; NULL = absent; consumes skip_bias when present (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): residual={}, post_residual={}, normalized_shape={}, skip_bias={}, weight={}, bias={}, eps=std::nullopt, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4025

op_add_rms_norm​

clika_rt_error*(* op_add_rms_norm)(clika_rt_tensor *x, clika_rt_tensor *residual, clika_rt_tensor *residual2, clika_rt_tensor *post_residual, const int64_t *normalized_shape, size_t normalized_shape_count, clika_rt_tensor *skip_bias, clika_rt_tensor *weight, clika_rt_tensor *bias, uint8_t eps_has, double eps, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::add_rms_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes residual when present (contract §6) optional; NULL = absent; consumes residual2 when present (contract §6) optional; NULL = absent; consumes post_residual when present (contract §6) optional; NULL = absent; consumes skip_bias when present (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): residual={}, residual2={}, post_residual={}, normalized_shape={}, skip_bias={}, weight={}, bias={}, eps=std::nullopt, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4052

op_add_scalar_lhs​

clika_rt_error*(* op_add_scalar_lhs)(clika_rt_scalar a, clika_rt_tensor *b, double alpha, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::add <- ClikaRT/compute/ops.h one form of the overloaded C++ add; the _scalar_lhs suffix names this form consumes b (contract §6) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1563

op_add_tensor​

clika_rt_error*(* op_add_tensor)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, double alpha, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::add <- ClikaRT/compute/ops.h one form of the overloaded C++ add; the _tensor suffix names this form consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1553

op_all​

clika_rt_error*(* op_all)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::all <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4813

op_allclose​

clika_rt_error*(* op_allclose)(clika_rt_tensor *a, clika_rt_tensor *b, double rtol, double atol, uint8_t equal_nan, clika_rt_tensor **out)

ClikaRT::ops::allclose <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): rtol=1e-5, atol=1e-8, equal_nan=false

Declared in clika_rt/clika_rt_core.h, line 1966

op_amax​

clika_rt_error*(* op_amax)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::amax <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4822

op_amin​

clika_rt_error*(* op_amin)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::amin <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4831

op_aminmax​

clika_rt_error*(* op_aminmax)(clika_rt_tensor *x, uint8_t dim_has, int64_t dim, uint8_t keepdim, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::aminmax <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4842

op_any​

clika_rt_error*(* op_any)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::any <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4852

op_arange​

clika_rt_error*(* op_arange)(clika_rt_scalar_or_tensor start, clika_rt_scalar_or_tensor end, clika_rt_scalar_or_tensor step, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::arange <- ClikaRT/compute/ops.h start.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) end.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) step.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): step=1, dtype=DataType::Int64, s={}

Declared in clika_rt/clika_rt_core.h, line 2788

op_argmax​

clika_rt_error*(* op_argmax)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_data_type index_dtype, clika_rt_tensor **out)

ClikaRT::ops::argmax <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, index_dtype=DataType::Int64

Declared in clika_rt/clika_rt_core.h, line 4861

op_argmin​

clika_rt_error*(* op_argmin)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_data_type index_dtype, clika_rt_tensor **out)

ClikaRT::ops::argmin <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, index_dtype=DataType::Int64

Declared in clika_rt/clika_rt_core.h, line 4871

op_argsort​

clika_rt_error*(* op_argsort)(clika_rt_tensor *x, int64_t dim, uint8_t descending, uint8_t stable, clika_rt_tensor **out)

ClikaRT::ops::argsort <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1, descending=false, stable=false

Declared in clika_rt/clika_rt_core.h, line 5900

op_asin​

clika_rt_error*(* op_asin)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::asin <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5295

op_asin_inplace​

clika_rt_error*(* op_asin_inplace)(clika_rt_tensor *self)

ClikaRT::ops::asin_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5301

op_asinh​

clika_rt_error*(* op_asinh)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::asinh <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5305

op_asinh_inplace​

clika_rt_error*(* op_asinh_inplace)(clika_rt_tensor *self)

ClikaRT::ops::asinh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5311

op_atan​

clika_rt_error*(* op_atan)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::atan <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5315

op_atan2​

clika_rt_error*(* op_atan2)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::atan2 <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1582

op_atan2_inplace​

clika_rt_error*(* op_atan2_inplace)(clika_rt_tensor *self, clika_rt_tensor *other)

ClikaRT::ops::atan2_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1590

op_atan_inplace​

clika_rt_error*(* op_atan_inplace)(clika_rt_tensor *self)

ClikaRT::ops::atan_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5321

op_atanh​

clika_rt_error*(* op_atanh)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::atanh <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5325

op_atanh_inplace​

clika_rt_error*(* op_atanh_inplace)(clika_rt_tensor *self)

ClikaRT::ops::atanh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5331

op_atleast_1d​

clika_rt_error*(* op_atleast_1d)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::atleast_1d <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3596

op_atleast_2d​

clika_rt_error*(* op_atleast_2d)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::atleast_2d <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3601

op_atleast_3d​

clika_rt_error*(* op_atleast_3d)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::atleast_3d <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3606

op_attention​

clika_rt_error*(* op_attention)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *attn_mask, clika_rt_tensor *head_sink, uint8_t is_causal_has, uint8_t is_causal, clika_rt_scalar_or_tensor q_scale, uint8_t softcap_has, double softcap, uint8_t sliding_window_has, int64_t sliding_window, uint8_t smooth_softmax_has, uint8_t smooth_softmax, clika_rt_scalar_or_tensor k_scale, clika_rt_scalar_or_tensor v_scale, clika_rt_tensor **out)

ClikaRT::ops::attention <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) optional; NULL = absent; consumes head_sink when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): attn_mask={}, head_sink={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, k_scale={}, v_scale={}

Declared in clika_rt/clika_rt_core.h, line 1278

op_attention_over_cache​

clika_rt_error*(* op_attention_over_cache)(clika_rt_tensor *q, clika_rt_tensor *cache_key, clika_rt_tensor *cache_value, clika_rt_tensor *kvcache_start, clika_rt_tensor *cu_seqlens_q, clika_rt_tensor *cu_seqlens_k, clika_rt_scalar_or_tensor max_seqlen_q, clika_rt_scalar_or_tensor max_seqlen_k, clika_rt_tensor *rope_cos, clika_rt_tensor *rope_sin, clika_rt_tensor *position_ids, clika_rt_tensor *attn_mask, uint8_t is_causal_has, uint8_t is_causal, clika_rt_scalar_or_tensor q_scale, uint8_t softcap_has, double softcap, uint8_t sliding_window_has, int64_t sliding_window, uint8_t smooth_softmax_has, uint8_t smooth_softmax, uint8_t rotary_mode_has, clika_rt_rotary_mode rotary_mode, uint8_t num_heads_has, int64_t num_heads, uint8_t kv_num_heads_has, int64_t kv_num_heads, clika_rt_scalar_or_tensor k_scale, clika_rt_scalar_or_tensor v_scale, clika_rt_tensor *head_sink, clika_rt_tensor *q_norm_gain, clika_rt_tensor *k_norm_gain, uint8_t qk_norm_eps_has, double qk_norm_eps, clika_rt_tensor *slot_ids, clika_rt_tensor **out)

ClikaRT::ops::attention_over_cache <- ClikaRT/compute/ops.h consumes q (contract §6) consumes cache_key (contract §6) consumes cache_value (contract §6) consumes kvcache_start (contract §6) consumes cu_seqlens_q (contract §6) consumes cu_seqlens_k (contract §6) max_seqlen_q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max_seqlen_k.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes rope_cos when present (contract §6) optional; NULL = absent; consumes rope_sin when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) rotary_mode read only when rotary_mode_has is nonzero (contract §9) num_heads read only when num_heads_has is nonzero (contract §9) kv_num_heads read only when kv_num_heads_has is nonzero (contract §9) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes head_sink when present (contract §6) optional; NULL = absent; consumes q_norm_gain when present (contract §6) optional; NULL = absent; consumes k_norm_gain when present (contract §6) qk_norm_eps read only when qk_norm_eps_has is nonzero (contract §9) optional; NULL = absent; consumes slot_ids when present (contract §6) C++ defaults (dropped at this surface): max_seqlen_q={}, max_seqlen_k={}, rope_cos={}, rope_sin={}, position_ids={}, attn_mask={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, rotary_mode=std::nullopt, num_heads=std::nullopt, kv_num_heads=std::nullopt, k_scale={}, v_scale={}, head_sink={}, q_norm_gain={}, k_norm_gain={}, qk_norm_eps=std::nullopt, slot_ids={}

Declared in clika_rt/clika_rt_core.h, line 1511

op_attention_varlen​

clika_rt_error*(* op_attention_varlen)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *cu_seqlens_q, clika_rt_tensor *cu_seqlens_k, clika_rt_scalar_or_tensor max_seqlen_q, clika_rt_scalar_or_tensor max_seqlen_k, clika_rt_tensor *attn_mask, clika_rt_tensor *head_sink, uint8_t is_causal_has, uint8_t is_causal, clika_rt_scalar_or_tensor q_scale, uint8_t softcap_has, double softcap, uint8_t sliding_window_has, int64_t sliding_window, uint8_t smooth_softmax_has, uint8_t smooth_softmax, clika_rt_scalar_or_tensor k_scale, clika_rt_scalar_or_tensor v_scale, clika_rt_tensor **out)

ClikaRT::ops::attention_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) consumes cu_seqlens_q (contract §6) consumes cu_seqlens_k (contract §6) max_seqlen_q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max_seqlen_k.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes attn_mask when present (contract §6) optional; NULL = absent; consumes head_sink when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): max_seqlen_q={}, max_seqlen_k={}, attn_mask={}, head_sink={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, k_scale={}, v_scale={}

Declared in clika_rt/clika_rt_core.h, line 1314

op_avg_pool​

clika_rt_error*(* op_avg_pool)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, uint8_t ceil_mode, uint8_t count_include_pad, uint8_t divisor_override_has, int64_t divisor_override, clika_rt_tensor **out)

ClikaRT::ops::avg_pool <- ClikaRT/compute/ops.h consumes x (contract §6) divisor_override read only when divisor_override_has is nonzero (contract §9)

Declared in clika_rt/clika_rt_core.h, line 4480

op_avg_pool1d​

clika_rt_error*(* op_avg_pool1d)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, uint8_t ceil_mode, uint8_t count_include_pad, clika_rt_tensor **out)

ClikaRT::ops::avg_pool1d <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): stride={}, padding={0}, ceil_mode=false, count_include_pad=true

Declared in clika_rt/clika_rt_core.h, line 4496

op_avg_pool2d​

clika_rt_error*(* op_avg_pool2d)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, uint8_t ceil_mode, uint8_t count_include_pad, uint8_t divisor_override_has, int64_t divisor_override, clika_rt_tensor **out)

ClikaRT::ops::avg_pool2d <- ClikaRT/compute/ops.h consumes x (contract §6) divisor_override read only when divisor_override_has is nonzero (contract §9) C++ defaults (dropped at this surface): stride={}, padding={0, 0}, ceil_mode=false, count_include_pad=true, divisor_override=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4511

op_avg_pool3d​

clika_rt_error*(* op_avg_pool3d)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, uint8_t ceil_mode, uint8_t count_include_pad, uint8_t divisor_override_has, int64_t divisor_override, clika_rt_tensor **out)

ClikaRT::ops::avg_pool3d <- ClikaRT/compute/ops.h consumes x (contract §6) divisor_override read only when divisor_override_has is nonzero (contract §9) C++ defaults (dropped at this surface): stride={}, padding={0, 0, 0}, ceil_mode=false, count_include_pad=true, divisor_override=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4528

op_batch_norm​

clika_rt_error*(* op_batch_norm)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, clika_rt_tensor *running_mean, clika_rt_tensor *running_var, uint8_t eps_has, double eps, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::batch_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) optional; NULL = absent; consumes running_mean when present (contract §6) optional; NULL = absent; consumes running_var when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, running_mean={}, running_var={}, eps=std::nullopt, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4163

op_bernoulli​

clika_rt_error*(* op_bernoulli)(clika_rt_tensor *probabilities, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::bernoulli <- ClikaRT/compute/ops.h consumes probabilities (contract §6) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 4670

op_bernoulli_inplace​

clika_rt_error*(* op_bernoulli_inplace)(clika_rt_tensor *self, clika_rt_stream_or_device s)

ClikaRT::ops::bernoulli_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 4678

op_binary_cross_entropy​

clika_rt_error*(* op_binary_cross_entropy)(clika_rt_tensor *input, clika_rt_tensor *target, clika_rt_tensor *weight, clika_rt_reduction reduction, clika_rt_tensor **out)

ClikaRT::ops::binary_cross_entropy <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) optional; NULL = absent; consumes weight when present (contract §6) C++ defaults (dropped at this surface): weight={}, reduction=Reduction::Mean

Declared in clika_rt/clika_rt_core.h, line 3467

op_binary_cross_entropy_with_logits​

clika_rt_error*(* op_binary_cross_entropy_with_logits)(clika_rt_tensor *input, clika_rt_tensor *target, clika_rt_tensor *weight, clika_rt_reduction reduction, clika_rt_tensor *pos_weight, clika_rt_tensor **out)

ClikaRT::ops::binary_cross_entropy_with_logits <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes pos_weight when present (contract §6) C++ defaults (dropped at this surface): weight={}, reduction=Reduction::Mean, pos_weight={}

Declared in clika_rt/clika_rt_core.h, line 3479

op_bincount​

clika_rt_error*(* op_bincount)(clika_rt_tensor *x, clika_rt_tensor *weights, int64_t minlength, clika_rt_tensor **out)

ClikaRT::ops::bincount <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weights when present (contract §6) C++ defaults (dropped at this surface): weights={}, minlength=0

Declared in clika_rt/clika_rt_core.h, line 5215

op_bitwise_and​

clika_rt_error*(* op_bitwise_and)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::bitwise_and <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1885

op_bitwise_and_inplace​

clika_rt_error*(* op_bitwise_and_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::bitwise_and_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1893

op_bitwise_left_shift​

clika_rt_error*(* op_bitwise_left_shift)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::bitwise_left_shift <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1899

op_bitwise_left_shift_inplace​

clika_rt_error*(* op_bitwise_left_shift_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::bitwise_left_shift_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1907

op_bitwise_not​

clika_rt_error*(* op_bitwise_not)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::bitwise_not <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1912

op_bitwise_not_inplace​

clika_rt_error*(* op_bitwise_not_inplace)(clika_rt_tensor *self)

ClikaRT::ops::bitwise_not_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1918

op_bitwise_or​

clika_rt_error*(* op_bitwise_or)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::bitwise_or <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1923

op_bitwise_or_inplace​

clika_rt_error*(* op_bitwise_or_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::bitwise_or_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1931

op_bitwise_right_shift​

clika_rt_error*(* op_bitwise_right_shift)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::bitwise_right_shift <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1937

op_bitwise_right_shift_inplace​

clika_rt_error*(* op_bitwise_right_shift_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::bitwise_right_shift_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1945

op_bitwise_xor​

clika_rt_error*(* op_bitwise_xor)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::bitwise_xor <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1951

op_bitwise_xor_inplace​

clika_rt_error*(* op_bitwise_xor_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::bitwise_xor_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1959

op_bmm​

clika_rt_error*(* op_bmm)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::bmm <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3323

op_broadcast_tensors​

clika_rt_error*(* op_broadcast_tensors)(clika_rt_tensor *const *tensors, size_t tensors_count, clika_rt_tensor_list **out)

ClikaRT::ops::broadcast_tensors <- ClikaRT/compute/ops.h elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft)

Declared in clika_rt/clika_rt_core.h, line 3611

op_broadcast_to​

clika_rt_error*(* op_broadcast_to)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *shape, size_t shape_count, clika_rt_tensor **out)

ClikaRT::ops::broadcast_to <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3669

op_bucketize​

clika_rt_error*(* op_bucketize)(clika_rt_tensor *x, clika_rt_tensor *boundaries, uint8_t out_int32, uint8_t right, clika_rt_tensor **out)

ClikaRT::ops::bucketize <- ClikaRT/compute/ops.h consumes x (contract §6) consumes boundaries (contract §6) C++ defaults (dropped at this surface): out_int32=false, right=false

Declared in clika_rt/clika_rt_core.h, line 5141

op_cast​

clika_rt_error*(* op_cast)(clika_rt_tensor *x, clika_rt_data_type target, uint8_t force_copy, clika_rt_tensor **out)

ClikaRT::ops::cast <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): force_copy=false

Declared in clika_rt/clika_rt_core.h, line 2365

op_cast_like​

clika_rt_error*(* op_cast_like)(clika_rt_tensor *x, clika_rt_tensor *reference, clika_rt_tensor **out)

ClikaRT::ops::cast_like <- ClikaRT/compute/ops.h consumes x (contract §6) consumes reference (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2373

op_causal_conv_update​

clika_rt_error*(* op_causal_conv_update)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, clika_rt_tensor *state, clika_rt_tensor *seq_lens, clika_rt_tensor *slot_ids, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::causal_conv_update <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes state (contract §6) optional; NULL = absent; consumes seq_lens when present (contract §6) optional; NULL = absent; consumes slot_ids when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): seq_lens={}, slot_ids={}, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4321

op_cdist​

clika_rt_error*(* op_cdist)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_scalar p, clika_rt_tensor **out)

ClikaRT::ops::cdist <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): p=2.0

Declared in clika_rt/clika_rt_core.h, line 3230

op_ceil​

clika_rt_error*(* op_ceil)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::ceil <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5335

op_ceil_inplace​

clika_rt_error*(* op_ceil_inplace)(clika_rt_tensor *self)

ClikaRT::ops::ceil_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5341

op_celu​

clika_rt_error*(* op_celu)(clika_rt_tensor *x, double alpha, clika_rt_tensor **out)

ClikaRT::ops::celu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): alpha=1.0

Declared in clika_rt/clika_rt_core.h, line 894

op_celu_inplace​

clika_rt_error*(* op_celu_inplace)(clika_rt_tensor *self, double alpha)

ClikaRT::ops::celu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): alpha=1.0

Declared in clika_rt/clika_rt_core.h, line 902

op_chunk​

clika_rt_error*(* op_chunk)(clika_rt_tensor *x, int64_t num_chunks, int64_t dim, clika_rt_tensor_list **out)

ClikaRT::ops::chunk <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=0

Declared in clika_rt/clika_rt_core.h, line 3921

op_circular_pad​

clika_rt_error*(* op_circular_pad)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *pad, size_t pad_count, clika_rt_tensor **out)

ClikaRT::ops::circular_pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3783

op_clamp​

clika_rt_error*(* op_clamp)(clika_rt_tensor *x, clika_rt_scalar_or_tensor min, clika_rt_scalar_or_tensor max, clika_rt_tensor **out)

ClikaRT::ops::clamp <- ClikaRT/compute/ops.h consumes x (contract §6) min.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): min=std::nullopt, max=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 5922

op_clamp_inplace​

clika_rt_error*(* op_clamp_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor min, clika_rt_scalar_or_tensor max)

ClikaRT::ops::clamp_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) min.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): min=std::nullopt, max=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 5933

op_clamp_max​

clika_rt_error*(* op_clamp_max)(clika_rt_tensor *x, clika_rt_scalar_or_tensor max, clika_rt_tensor **out)

ClikaRT::ops::clamp_max <- ClikaRT/compute/ops.h consumes x (contract §6) max.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 5360

op_clamp_max_inplace​

clika_rt_error*(* op_clamp_max_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor max)

ClikaRT::ops::clamp_max_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) max.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 5368

op_clamp_min​

clika_rt_error*(* op_clamp_min)(clika_rt_tensor *x, clika_rt_scalar_or_tensor min, clika_rt_tensor **out)

ClikaRT::ops::clamp_min <- ClikaRT/compute/ops.h consumes x (contract §6) min.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 5346

op_clamp_min_inplace​

clika_rt_error*(* op_clamp_min_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor min)

ClikaRT::ops::clamp_min_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) min.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 5354

op_clone​

clika_rt_error*(* op_clone)(clika_rt_tensor *src, clika_rt_tensor **out)

ClikaRT::ops::clone <- ClikaRT/compute/ops.h consumes src (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2394

op_concat​

clika_rt_error*(* op_concat)(clika_rt_tensor *const *tensors, size_t tensors_count, int64_t dim, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::concat <- ClikaRT/compute/ops.h elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): dim=0, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 3618

op_constant_pad​

clika_rt_error*(* op_constant_pad)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *pad, size_t pad_count, clika_rt_scalar_or_tensor value, clika_rt_tensor **out)

ClikaRT::ops::constant_pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): value=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3758

op_contiguous​

clika_rt_error*(* op_contiguous)(clika_rt_tensor *x, uint8_t force_copy, clika_rt_tensor **out)

ClikaRT::ops::contiguous <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): force_copy=false

Declared in clika_rt/clika_rt_core.h, line 2380

op_conv​

clika_rt_error*(* op_conv)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_pad_mode mode, uint8_t value_has, double value, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::conv <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 2151

op_conv1d​

clika_rt_error*(* op_conv1d)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::conv1d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, dilation={1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 2172

op_conv2d​

clika_rt_error*(* op_conv2d)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::conv2d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 2190

op_conv3d​

clika_rt_error*(* op_conv3d)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::conv3d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 2208

op_conv_transpose​

clika_rt_error*(* op_conv_transpose)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, int64_t groups, const int64_t *dilation, size_t dilation_count, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::conv_transpose <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 2226

op_conv_transpose1d​

clika_rt_error*(* op_conv_transpose1d)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, int64_t groups, const int64_t *dilation, size_t dilation_count, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::conv_transpose1d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0, 0}, output_padding={0}, groups=1, dilation={1}, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 2246

op_conv_transpose2d​

clika_rt_error*(* op_conv_transpose2d)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, int64_t groups, const int64_t *dilation, size_t dilation_count, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::conv_transpose2d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0, 0, 0}, output_padding={0, 0}, groups=1, dilation={1, 1}, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 2266

op_conv_transpose3d​

clika_rt_error*(* op_conv_transpose3d)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, int64_t groups, const int64_t *dilation, size_t dilation_count, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::conv_transpose3d <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0, 0, 0, 0}, output_padding={0, 0, 0}, groups=1, dilation={1, 1, 1}, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 2286

op_copy​

clika_rt_error*(* op_copy)(clika_rt_tensor *src, clika_rt_stream_or_device target, uint8_t force_copy, clika_rt_tensor **out)

ClikaRT::ops::copy <- ClikaRT/compute/ops.h consumes src (contract §6) C++ defaults (dropped at this surface): target={}, force_copy=true

Declared in clika_rt/clika_rt_core.h, line 2387

op_copy_inplace​

clika_rt_error*(* op_copy_inplace)(clika_rt_tensor *self, clika_rt_tensor *src, clika_rt_stream_or_device target)

ClikaRT::ops::copy_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes src (contract §6) C++ defaults (dropped at this surface): target={}

Declared in clika_rt/clika_rt_core.h, line 2402

op_copy_into​

clika_rt_error*(* op_copy_into)(clika_rt_tensor *out, clika_rt_tensor *src, clika_rt_stream_or_device target)

ClikaRT::ops::copy_into <- ClikaRT/compute/ops.h borrows out; written through (the in-place target) consumes src (contract §6) C++ defaults (dropped at this surface): target={}

Declared in clika_rt/clika_rt_core.h, line 2410

op_copy_to_cpu​

clika_rt_error*(* op_copy_to_cpu)(clika_rt_tensor *src, clika_rt_tensor **out)

ClikaRT::ops::copy_to_cpu <- ClikaRT/compute/ops.h consumes src (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2441

op_copysign​

clika_rt_error*(* op_copysign)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::copysign <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1596

op_copysign_inplace​

clika_rt_error*(* op_copysign_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::copysign_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1604

op_cos​

clika_rt_error*(* op_cos)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::cos <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5373

op_cos_inplace​

clika_rt_error*(* op_cos_inplace)(clika_rt_tensor *self)

ClikaRT::ops::cos_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5379

op_cosh​

clika_rt_error*(* op_cosh)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::cosh <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5383

op_cosh_inplace​

clika_rt_error*(* op_cosh_inplace)(clika_rt_tensor *self)

ClikaRT::ops::cosh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5389

op_cosine_similarity​

clika_rt_error*(* op_cosine_similarity)(clika_rt_tensor *a, clika_rt_tensor *b, int64_t dim, uint8_t eps_has, double eps, clika_rt_tensor **out)

ClikaRT::ops::cosine_similarity <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=1, eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3240

op_count_nonzero​

clika_rt_error*(* op_count_nonzero)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, clika_rt_tensor **out)

ClikaRT::ops::count_nonzero <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}

Declared in clika_rt/clika_rt_core.h, line 4881

op_cross​

clika_rt_error*(* op_cross)(clika_rt_tensor *a, clika_rt_tensor *b, uint8_t dim_has, int64_t dim, clika_rt_tensor **out)

ClikaRT::ops::cross <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3252

op_cross_entropy​

clika_rt_error*(* op_cross_entropy)(clika_rt_tensor *input, clika_rt_tensor *target, clika_rt_tensor *weight, uint8_t ignore_index_has, int64_t ignore_index, clika_rt_reduction reduction, clika_rt_tensor **out)

ClikaRT::ops::cross_entropy <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) optional; NULL = absent; consumes weight when present (contract §6) ignore_index read only when ignore_index_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, ignore_index=std::nullopt, reduction=Reduction::Mean

Declared in clika_rt/clika_rt_core.h, line 3492

op_cummax​

clika_rt_error*(* op_cummax)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::cummax <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)

Declared in clika_rt/clika_rt_core.h, line 5092

op_cummin​

clika_rt_error*(* op_cummin)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::cummin <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)

Declared in clika_rt/clika_rt_core.h, line 5100

op_cumprod​

clika_rt_error*(* op_cumprod)(clika_rt_tensor *x, int64_t dim, clika_rt_data_type dtype, clika_rt_tensor **out)

ClikaRT::ops::cumprod <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 5108

op_cumprod_inplace​

clika_rt_error*(* op_cumprod_inplace)(clika_rt_tensor *self, int64_t dim, clika_rt_data_type dtype)

ClikaRT::ops::cumprod_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 5117

op_cumsum​

clika_rt_error*(* op_cumsum)(clika_rt_tensor *x, int64_t dim, clika_rt_data_type dtype, clika_rt_tensor **out)

ClikaRT::ops::cumsum <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 5124

op_cumsum_inplace​

clika_rt_error*(* op_cumsum_inplace)(clika_rt_tensor *self, int64_t dim, clika_rt_data_type dtype)

ClikaRT::ops::cumsum_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 5133

op_deform_conv​

clika_rt_error*(* op_deform_conv)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *offset, clika_rt_tensor *mask, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, int64_t offset_groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::deform_conv <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) consumes offset (contract §6) optional; NULL = absent; consumes mask when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): mask={}, bias={}, stride={}, padding={}, dilation={}, groups=1, offset_groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 2308

op_deg2rad​

clika_rt_error*(* op_deg2rad)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::deg2rad <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1798

op_deg2rad_inplace​

clika_rt_error*(* op_deg2rad_inplace)(clika_rt_tensor *self)

ClikaRT::ops::deg2rad_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1804

op_dequantize​

clika_rt_error*(* op_dequantize)(clika_rt_qtensor *x, clika_rt_data_type target_dtype, clika_rt_tensor **out)

ClikaRT::ops::dequantize <- ClikaRT/compute/q_tensor.h consumes x (contract §6) C++ defaults (dropped at this surface): target_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6106

op_dequantize_inplace​

clika_rt_error*(* op_dequantize_inplace)(clika_rt_qtensor *x, clika_rt_tensor *out)

ClikaRT::ops::dequantize_ <- ClikaRT/compute/q_tensor.h in-place op consumes x (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6114

op_diag​

clika_rt_error*(* op_diag)(clika_rt_tensor *x, int64_t diagonal, clika_rt_tensor **out)

ClikaRT::ops::diag <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): diagonal=0

Declared in clika_rt/clika_rt_core.h, line 3627

op_diag_embed​

clika_rt_error*(* op_diag_embed)(clika_rt_tensor *x, int64_t offset, int64_t dim1, int64_t dim2, clika_rt_tensor **out)

ClikaRT::ops::diag_embed <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): offset=0, dim1=-2, dim2=-1

Declared in clika_rt/clika_rt_core.h, line 3634

op_diagonal​

clika_rt_error*(* op_diagonal)(clika_rt_tensor *x, int64_t offset, int64_t dim1, int64_t dim2, clika_rt_tensor **out)

ClikaRT::ops::diagonal <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): offset=0, dim1=0, dim2=1

Declared in clika_rt/clika_rt_core.h, line 3643

op_diff​

clika_rt_error*(* op_diff)(clika_rt_tensor *x, int64_t n, int64_t dim, clika_rt_tensor *prepend, clika_rt_tensor *append, clika_rt_tensor **out)

ClikaRT::ops::diff <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes prepend when present (contract §6) optional; NULL = absent; consumes append when present (contract §6) C++ defaults (dropped at this surface): n=1, dim=-1, prepend={}, append={}

Declared in clika_rt/clika_rt_core.h, line 5396

op_div_inplace​

clika_rt_error*(* op_div_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other, clika_rt_rounding_mode rounding_mode, clika_rt_activation activation)

ClikaRT::ops::div_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): rounding_mode=RoundingMode::None, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1633

op_div_scalar_lhs​

clika_rt_error*(* op_div_scalar_lhs)(clika_rt_scalar a, clika_rt_tensor *b, clika_rt_rounding_mode rounding_mode, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::div <- ClikaRT/compute/ops.h one form of the overloaded C++ div; the _scalar_lhs suffix names this form consumes b (contract §6) C++ defaults (dropped at this surface): rounding_mode=RoundingMode::None, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1622

op_div_tensor​

clika_rt_error*(* op_div_tensor)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_rounding_mode rounding_mode, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::div <- ClikaRT/compute/ops.h one form of the overloaded C++ div; the _tensor suffix names this form consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): rounding_mode=RoundingMode::None, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1612

op_dot​

clika_rt_error*(* op_dot)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::dot <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3261

op_dynamic_quantize​

clika_rt_error*(* op_dynamic_quantize)(clika_rt_tensor *x, clika_rt_tensor **out0, clika_rt_tensor **out1, clika_rt_tensor **out2)

ClikaRT::ops::dynamic_quantize <- ClikaRT/compute/q_tensor.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)

Declared in clika_rt/clika_rt_core.h, line 8147

op_einsum​

clika_rt_error*(* op_einsum)(const char *equation, size_t equation_len, clika_rt_tensor *const *operands, size_t operands_count, clika_rt_tensor **out)

ClikaRT::ops::einsum <- ClikaRT/compute/ops.h elements of operands BORROWED; whether §6 reaches through spans needs a ruling (draft)

Declared in clika_rt/clika_rt_core.h, line 3267

op_elu​

clika_rt_error*(* op_elu)(clika_rt_tensor *x, double alpha, double scale, double input_scale, clika_rt_tensor **out)

ClikaRT::ops::elu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): alpha=1.0, scale=1.0, input_scale=1.0

Declared in clika_rt/clika_rt_core.h, line 866

op_elu_inplace​

clika_rt_error*(* op_elu_inplace)(clika_rt_tensor *self, double alpha, double scale, double input_scale)

ClikaRT::ops::elu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): alpha=1.0, scale=1.0, input_scale=1.0

Declared in clika_rt/clika_rt_core.h, line 876

op_embedding​

clika_rt_error*(* op_embedding)(clika_rt_tensor *indices, clika_rt_tensor *weight, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::embedding <- ClikaRT/compute/ops.h consumes indices (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 2450

op_empty​

clika_rt_error*(* op_empty)(const clika_rt_scalar_or_tensor *shape, size_t shape_count, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_stream_or_device pinned_for, clika_rt_tensor **out)

ClikaRT::ops::empty <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): s={}, pinned_for={}

Declared in clika_rt/clika_rt_core.h, line 2808

op_empty_like​

clika_rt_error*(* op_empty_like)(clika_rt_tensor *reference, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::empty_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 2818

op_empty_strided​

clika_rt_error*(* op_empty_strided)(const int64_t *size, size_t size_count, const int64_t *stride, size_t stride_count, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::empty_strided <- ClikaRT/compute/ops.h C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 2824

op_eq​

clika_rt_error*(* op_eq)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::eq <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1976

op_eq_inplace​

clika_rt_error*(* op_eq_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::eq_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1984

op_erf​

clika_rt_error*(* op_erf)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::erf <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5405

op_erf_inplace​

clika_rt_error*(* op_erf_inplace)(clika_rt_tensor *self)

ClikaRT::ops::erf_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5411

op_erfc​

clika_rt_error*(* op_erfc)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::erfc <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5415

op_erfc_inplace​

clika_rt_error*(* op_erfc_inplace)(clika_rt_tensor *self)

ClikaRT::ops::erfc_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5421

op_erfinv​

clika_rt_error*(* op_erfinv)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::erfinv <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5425

op_erfinv_inplace​

clika_rt_error*(* op_erfinv_inplace)(clika_rt_tensor *self)

ClikaRT::ops::erfinv_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5431

op_exp​

clika_rt_error*(* op_exp)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::exp <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5435

op_exp_inplace​

clika_rt_error*(* op_exp_inplace)(clika_rt_tensor *self)

ClikaRT::ops::exp_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5441

op_expand​

clika_rt_error*(* op_expand)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *shape, size_t shape_count, uint8_t bidirectional, clika_rt_tensor **out)

ClikaRT::ops::expand <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): bidirectional=false

Declared in clika_rt/clika_rt_core.h, line 3653

op_expand_as​

clika_rt_error*(* op_expand_as)(clika_rt_tensor *x, clika_rt_tensor *other, clika_rt_tensor **out)

ClikaRT::ops::expand_as <- ClikaRT/compute/ops.h consumes x (contract §6) consumes other (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3662

op_exponential_inplace​

clika_rt_error*(* op_exponential_inplace)(clika_rt_tensor *self, double lambd, clika_rt_stream_or_device s)

ClikaRT::ops::exponential_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): lambd=1.0, s={}

Declared in clika_rt/clika_rt_core.h, line 4685

op_eye​

clika_rt_error*(* op_eye)(clika_rt_scalar_or_tensor n, clika_rt_scalar_or_tensor m, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::eye <- ClikaRT/compute/ops.h n.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) m.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): m=std::nullopt, dtype=DataType::Float32, s={}

Declared in clika_rt/clika_rt_core.h, line 2799

op_fast_gelu​

clika_rt_error*(* op_fast_gelu)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::fast_gelu <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 938

op_fill​

clika_rt_error*(* op_fill)(clika_rt_tensor *x, clika_rt_scalar_or_tensor value, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::fill <- ClikaRT/compute/ops.h consumes x (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 2836

op_fill_diagonal​

clika_rt_error*(* op_fill_diagonal)(clika_rt_tensor *x, clika_rt_scalar fill_value, uint8_t wrap, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::fill_diagonal <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): wrap=false, s={}

Declared in clika_rt/clika_rt_core.h, line 2853

op_fill_diagonal_inplace​

clika_rt_error*(* op_fill_diagonal_inplace)(clika_rt_tensor *self, clika_rt_scalar fill_value, uint8_t wrap, clika_rt_stream_or_device s)

ClikaRT::ops::fill_diagonal_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): wrap=false, s={}

Declared in clika_rt/clika_rt_core.h, line 2863

op_fill_inplace​

clika_rt_error*(* op_fill_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor value, clika_rt_stream_or_device s)

ClikaRT::ops::fill_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 2846

op_flatten​

clika_rt_error*(* op_flatten)(clika_rt_tensor *x, int64_t start_dim, int64_t end_dim, clika_rt_tensor **out)

ClikaRT::ops::flatten <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): start_dim=0, end_dim=-1

Declared in clika_rt/clika_rt_core.h, line 3677

op_flip​

clika_rt_error*(* op_flip)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, clika_rt_tensor **out)

ClikaRT::ops::flip <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3684

op_fliplr​

clika_rt_error*(* op_fliplr)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::fliplr <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3691

op_flipud​

clika_rt_error*(* op_flipud)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::flipud <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3696

op_floor​

clika_rt_error*(* op_floor)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::floor <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5445

op_floor_divide​

clika_rt_error*(* op_floor_divide)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::floor_divide <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1641

op_floor_divide_inplace​

clika_rt_error*(* op_floor_divide_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::floor_divide_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1649

op_floor_inplace​

clika_rt_error*(* op_floor_inplace)(clika_rt_tensor *self)

ClikaRT::ops::floor_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5451

op_fmax​

clika_rt_error*(* op_fmax)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::fmax <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1655

op_fmin​

clika_rt_error*(* op_fmin)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::fmin <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1662

op_fmod​

clika_rt_error*(* op_fmod)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::fmod <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1757

op_fmod_inplace​

clika_rt_error*(* op_fmod_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::fmod_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1765

op_fold​

clika_rt_error*(* op_fold)(clika_rt_tensor *x, const int64_t *output_size, size_t output_size_count, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *dilation, size_t dilation_count, const int64_t *padding, size_t padding_count, const int64_t *stride, size_t stride_count, clika_rt_pad_mode mode, uint8_t value_has, double value, clika_rt_tensor **out)

ClikaRT::ops::fold <- ClikaRT/compute/ops.h consumes x (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): mode=PadMode::Constant, value=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 2328

op_frac​

clika_rt_error*(* op_frac)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::frac <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5455

op_frac_inplace​

clika_rt_error*(* op_frac_inplace)(clika_rt_tensor *self)

ClikaRT::ops::frac_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5461

op_frexp​

clika_rt_error*(* op_frexp)(clika_rt_tensor *x, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::frexp <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)

Declared in clika_rt/clika_rt_core.h, line 5466

op_from_blob​

clika_rt_error*(* op_from_blob)(void *data, const int64_t *shape, size_t shape_count, clika_rt_data_type dtype, clika_rt_stream_or_device s, const int64_t *strides, size_t strides_count, void(*deleter)(void *userdata, void *p0), void *deleter_userdata, void(*deleter_userdata_free)(void *), clika_rt_stream_or_device pinned_for, clika_rt_tensor **out)

ClikaRT::ops::from_blob <- ClikaRT/compute/ops.h deleter is the contract §7 triple: the callback takes userdata first; deleter_userdata_free (NULL when no finalizer is needed) runs exactly once when the registration dies, including one that never fires and one whose call the runtime refused at its argument checks a NULL deleter registers nothing C++ defaults (dropped at this surface): s={}, strides={}, deleter={}, pinned_for={}

Declared in clika_rt/clika_rt_core.h, line 2872

op_full​

clika_rt_error*(* op_full)(const clika_rt_scalar_or_tensor *shape, size_t shape_count, clika_rt_scalar_or_tensor fill_value, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_stream_or_device pinned_for, clika_rt_tensor **out)

ClikaRT::ops::full <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) fill_value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): s={}, pinned_for={}

Declared in clika_rt/clika_rt_core.h, line 2889

op_full_like​

clika_rt_error*(* op_full_like)(clika_rt_tensor *reference, clika_rt_scalar_or_tensor fill_value, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::full_like <- ClikaRT/compute/ops.h consumes reference (contract §6) fill_value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 2901

op_gated_delta_update​

clika_rt_error*(* op_gated_delta_update)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *beta, clika_rt_tensor *g, clika_rt_tensor *state, clika_rt_tensor *seq_lens, clika_rt_tensor *slot_ids, uint8_t scale_has, double scale, clika_rt_tensor *gate_bias, clika_rt_tensor *gate_scale, clika_rt_tensor **out)

ClikaRT::ops::gated_delta_update <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) consumes beta (contract §6) consumes g (contract §6) consumes state (contract §6) optional; NULL = absent; consumes seq_lens when present (contract §6) optional; NULL = absent; consumes slot_ids when present (contract §6) scale read only when scale_has is nonzero (contract §9) optional; NULL = absent; consumes gate_bias when present (contract §6) optional; NULL = absent; consumes gate_scale when present (contract §6) C++ defaults (dropped at this surface): seq_lens={}, slot_ids={}, scale=std::nullopt, gate_bias={}, gate_scale={}

Declared in clika_rt/clika_rt_core.h, line 4344

op_gated_rms_norm​

clika_rt_error*(* op_gated_rms_norm)(clika_rt_tensor *x, clika_rt_tensor *z, const int64_t *normalized_shape, size_t normalized_shape_count, clika_rt_tensor *weight, uint8_t eps_has, double eps, clika_rt_tensor **out)

ClikaRT::ops::gated_rms_norm <- ClikaRT/compute/ops.h consumes x (contract §6) consumes z (contract §6) optional; NULL = absent; consumes weight when present (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4303

op_gather​

clika_rt_error*(* op_gather)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor *index, clika_rt_tensor **out)

ClikaRT::ops::gather <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2962

op_ge​

clika_rt_error*(* op_ge)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::ge <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1990

op_ge_inplace​

clika_rt_error*(* op_ge_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::ge_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1998

op_geglu​

clika_rt_error*(* op_geglu)(clika_rt_tensor *x, clika_rt_gelu_mode approximate, clika_rt_tensor **out)

ClikaRT::ops::geglu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): approximate=GeluMode::None

Declared in clika_rt/clika_rt_core.h, line 908

op_gelu​

clika_rt_error*(* op_gelu)(clika_rt_tensor *x, clika_rt_gelu_mode approximate, clika_rt_tensor **out)

ClikaRT::ops::gelu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): approximate=GeluMode::None

Declared in clika_rt/clika_rt_core.h, line 920

op_gelu_inplace​

clika_rt_error*(* op_gelu_inplace)(clika_rt_tensor *self, clika_rt_gelu_mode approximate)

ClikaRT::ops::gelu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): approximate=GeluMode::None

Declared in clika_rt/clika_rt_core.h, line 928

op_generate_rotary_cache​

clika_rt_error*(* op_generate_rotary_cache)(int64_t rotary_dim, int64_t max_positions, uint8_t theta_has, double theta, uint8_t scaling_has, clika_rt_rope_scaling scaling, uint8_t scale_has, double scale, uint8_t low_freq_factor_has, double low_freq_factor, uint8_t high_freq_factor_has, double high_freq_factor, uint8_t original_max_pos_has, int64_t original_max_pos, uint8_t beta_fast_has, double beta_fast, uint8_t beta_slow_has, double beta_slow, clika_rt_tensor *freq_factors, clika_rt_stream_or_device s, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::generate_rotary_cache <- ClikaRT/compute/ops.h theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}, s={}

Declared in clika_rt/clika_rt_core.h, line 2469

op_glu​

clika_rt_error*(* op_glu)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor **out)

ClikaRT::ops::glu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1

Declared in clika_rt/clika_rt_core.h, line 944

op_grid_sample​

clika_rt_error*(* op_grid_sample)(clika_rt_tensor *x, clika_rt_tensor *grid, clika_rt_grid_sample_mode mode, clika_rt_grid_sample_padding_mode padding_mode, uint8_t align_corners, clika_rt_tensor **out)

ClikaRT::ops::grid_sample <- ClikaRT/compute/ops.h consumes x (contract §6) consumes grid (contract §6) C++ defaults (dropped at this surface): mode=GridSampleMode::Bilinear, padding_mode=GridSamplePaddingMode::Zeros, align_corners=false

Declared in clika_rt/clika_rt_core.h, line 5066

op_group_norm​

clika_rt_error*(* op_group_norm)(clika_rt_tensor *x, int64_t num_groups, clika_rt_tensor *weight, clika_rt_tensor *bias, clika_rt_tensor *running_mean, clika_rt_tensor *running_var, uint8_t eps_has, double eps, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::group_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) optional; NULL = absent; consumes running_mean when present (contract §6) optional; NULL = absent; consumes running_var when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, running_mean={}, running_var={}, eps=std::nullopt, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4183

op_group_query_attention​

clika_rt_error*(* op_group_query_attention)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *past_key, clika_rt_tensor *past_value, clika_rt_tensor *kvcache_start, clika_rt_tensor *rope_cos, clika_rt_tensor *rope_sin, clika_rt_tensor *position_ids, clika_rt_tensor *attn_mask, uint8_t is_causal_has, uint8_t is_causal, clika_rt_scalar_or_tensor q_scale, uint8_t softcap_has, double softcap, uint8_t sliding_window_has, int64_t sliding_window, uint8_t smooth_softmax_has, uint8_t smooth_softmax, uint8_t rotary_mode_has, clika_rt_rotary_mode rotary_mode, uint8_t num_heads_has, int64_t num_heads, uint8_t kv_num_heads_has, int64_t kv_num_heads, clika_rt_tensor *out_present_key, clika_rt_tensor *out_present_value, clika_rt_scalar_or_tensor k_scale, clika_rt_scalar_or_tensor v_scale, clika_rt_tensor *head_sink, clika_rt_tensor *q_norm_gain, clika_rt_tensor *k_norm_gain, uint8_t qk_norm_eps_has, double qk_norm_eps, clika_rt_tensor *slot_ids, clika_rt_tensor **out0, clika_rt_tensor **out1, clika_rt_tensor **out2)

ClikaRT::ops::group_query_attention <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) optional; NULL = absent; consumes past_key when present (contract §6) optional; NULL = absent; consumes past_value when present (contract §6) optional; NULL = absent; consumes kvcache_start when present (contract §6) optional; NULL = absent; consumes rope_cos when present (contract §6) optional; NULL = absent; consumes rope_sin when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) rotary_mode read only when rotary_mode_has is nonzero (contract §9) num_heads read only when num_heads_has is nonzero (contract §9) kv_num_heads read only when kv_num_heads_has is nonzero (contract §9) optional; NULL = absent; consumes out_present_key when present (contract §6) optional; NULL = absent; consumes out_present_value when present (contract §6) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes head_sink when present (contract §6) optional; NULL = absent; consumes q_norm_gain when present (contract §6) optional; NULL = absent; consumes k_norm_gain when present (contract §6) qk_norm_eps read only when qk_norm_eps_has is nonzero (contract §9) optional; NULL = absent; consumes slot_ids when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): past_key={}, past_value={}, kvcache_start={}, rope_cos={}, rope_sin={}, position_ids={}, attn_mask={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, rotary_mode=std::nullopt, num_heads=std::nullopt, kv_num_heads=std::nullopt, out_present_key={}, out_present_value={}, k_scale={}, v_scale={}, head_sink={}, q_norm_gain={}, k_norm_gain={}, qk_norm_eps=std::nullopt, slot_ids={}

Declared in clika_rt/clika_rt_core.h, line 1366

op_group_query_attention_varlen​

clika_rt_error*(* op_group_query_attention_varlen)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *cu_seqlens_q, clika_rt_tensor *cu_seqlens_k, clika_rt_scalar_or_tensor max_seqlen_q, clika_rt_scalar_or_tensor max_seqlen_k, clika_rt_tensor *past_key, clika_rt_tensor *past_value, clika_rt_tensor *kvcache_start, clika_rt_tensor *rope_cos, clika_rt_tensor *rope_sin, clika_rt_tensor *position_ids, clika_rt_tensor *attn_mask, clika_rt_tensor *head_sink, uint8_t is_causal_has, uint8_t is_causal, clika_rt_scalar_or_tensor q_scale, uint8_t softcap_has, double softcap, uint8_t sliding_window_has, int64_t sliding_window, uint8_t smooth_softmax_has, uint8_t smooth_softmax, uint8_t rotary_mode_has, clika_rt_rotary_mode rotary_mode, uint8_t num_heads_has, int64_t num_heads, uint8_t kv_num_heads_has, int64_t kv_num_heads, clika_rt_tensor *out_present_key, clika_rt_tensor *out_present_value, clika_rt_scalar_or_tensor k_scale, clika_rt_scalar_or_tensor v_scale, clika_rt_tensor *q_norm_gain, clika_rt_tensor *k_norm_gain, uint8_t qk_norm_eps_has, double qk_norm_eps, clika_rt_tensor *slot_ids, clika_rt_tensor **out0, clika_rt_tensor **out1, clika_rt_tensor **out2)

ClikaRT::ops::group_query_attention_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) consumes cu_seqlens_q (contract §6) consumes cu_seqlens_k (contract §6) max_seqlen_q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max_seqlen_k.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes past_key when present (contract §6) optional; NULL = absent; consumes past_value when present (contract §6) optional; NULL = absent; consumes kvcache_start when present (contract §6) optional; NULL = absent; consumes rope_cos when present (contract §6) optional; NULL = absent; consumes rope_sin when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) optional; NULL = absent; consumes head_sink when present (contract §6) is_causal read only when is_causal_has is nonzero (contract §9) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) softcap read only when softcap_has is nonzero (contract §9) sliding_window read only when sliding_window_has is nonzero (contract §9) smooth_softmax read only when smooth_softmax_has is nonzero (contract §9) rotary_mode read only when rotary_mode_has is nonzero (contract §9) num_heads read only when num_heads_has is nonzero (contract §9) kv_num_heads read only when kv_num_heads_has is nonzero (contract §9) optional; NULL = absent; consumes out_present_key when present (contract §6) optional; NULL = absent; consumes out_present_value when present (contract §6) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes q_norm_gain when present (contract §6) optional; NULL = absent; consumes k_norm_gain when present (contract §6) qk_norm_eps read only when qk_norm_eps_has is nonzero (contract §9) optional; NULL = absent; consumes slot_ids when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): max_seqlen_q={}, max_seqlen_k={}, past_key={}, past_value={}, kvcache_start={}, rope_cos={}, rope_sin={}, position_ids={}, attn_mask={}, head_sink={}, is_causal=std::nullopt, q_scale={}, softcap=std::nullopt, sliding_window=std::nullopt, smooth_softmax=std::nullopt, rotary_mode=std::nullopt, num_heads=std::nullopt, kv_num_heads=std::nullopt, out_present_key={}, out_present_value={}, k_scale={}, v_scale={}, q_norm_gain={}, k_norm_gain={}, qk_norm_eps=std::nullopt, slot_ids={}

Declared in clika_rt/clika_rt_core.h, line 1439

op_gt​

clika_rt_error*(* op_gt)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::gt <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 2004

op_gt_inplace​

clika_rt_error*(* op_gt_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::gt_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 2012

op_hardshrink​

clika_rt_error*(* op_hardshrink)(clika_rt_tensor *x, double lambd, clika_rt_tensor **out)

ClikaRT::ops::hardshrink <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): lambd=0.5

Declared in clika_rt/clika_rt_core.h, line 951

op_hardshrink_inplace​

clika_rt_error*(* op_hardshrink_inplace)(clika_rt_tensor *self, double lambd)

ClikaRT::ops::hardshrink_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): lambd=0.5

Declared in clika_rt/clika_rt_core.h, line 959

op_hardsigmoid​

clika_rt_error*(* op_hardsigmoid)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::hardsigmoid <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 964

op_hardsigmoid_inplace​

clika_rt_error*(* op_hardsigmoid_inplace)(clika_rt_tensor *self)

ClikaRT::ops::hardsigmoid_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 970

op_hardswish​

clika_rt_error*(* op_hardswish)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::hardswish <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 974

op_hardswish_inplace​

clika_rt_error*(* op_hardswish_inplace)(clika_rt_tensor *self)

ClikaRT::ops::hardswish_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 980

op_hardtanh​

clika_rt_error*(* op_hardtanh)(clika_rt_tensor *x, double min_val, double max_val, clika_rt_tensor **out)

ClikaRT::ops::hardtanh <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): min_val=-1.0, max_val=1.0

Declared in clika_rt/clika_rt_core.h, line 985

op_hardtanh_inplace​

clika_rt_error*(* op_hardtanh_inplace)(clika_rt_tensor *self, double min_val, double max_val)

ClikaRT::ops::hardtanh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): min_val=-1.0, max_val=1.0

Declared in clika_rt/clika_rt_core.h, line 994

op_hash_128​

clika_rt_error*(* op_hash_128)(clika_rt_tensor *x, uint64_t seed, clika_rt_tensor **out)

ClikaRT::ops::hash_128 <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): seed=0

Declared in clika_rt/clika_rt_core.h, line 4997

op_hash_256​

clika_rt_error*(* op_hash_256)(clika_rt_tensor *x, uint64_t seed, clika_rt_tensor **out)

ClikaRT::ops::hash_256 <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): seed=0

Declared in clika_rt/clika_rt_core.h, line 5004

op_hash_64​

clika_rt_error*(* op_hash_64)(clika_rt_tensor *x, uint64_t seed, clika_rt_tensor **out)

ClikaRT::ops::hash_64 <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): seed=0

Declared in clika_rt/clika_rt_core.h, line 4990

op_hash_chain​

clika_rt_error*(* op_hash_chain)(clika_rt_tensor *rows, clika_rt_tensor *parent, uint64_t seed, clika_rt_tensor **out)

ClikaRT::ops::hash_chain <- ClikaRT/compute/ops.h consumes rows (contract §6) consumes parent (contract §6) C++ defaults (dropped at this surface): seed=0

Declared in clika_rt/clika_rt_core.h, line 5012

op_hash_tensor​

clika_rt_error*(* op_hash_tensor)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_hash_tensor_mode mode, clika_rt_tensor **out)

ClikaRT::ops::hash_tensor <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, mode=HashTensorMode::XorSum

Declared in clika_rt/clika_rt_core.h, line 4980

op_histogram​

clika_rt_error*(* op_histogram)(clika_rt_tensor *x, int64_t bins, clika_rt_tensor *range, clika_rt_tensor *weight, uint8_t density, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::histogram <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes range when present (contract §6) optional; NULL = absent; consumes weight when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): bins=100, range={}, weight={}, density=false

Declared in clika_rt/clika_rt_core.h, line 5226

op_huber_loss​

clika_rt_error*(* op_huber_loss)(clika_rt_tensor *input, clika_rt_tensor *target, clika_rt_reduction reduction, double delta, clika_rt_tensor **out)

ClikaRT::ops::huber_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean, delta=1.0

Declared in clika_rt/clika_rt_core.h, line 3504

op_hypot​

clika_rt_error*(* op_hypot)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::hypot <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1669

op_hypot_inplace​

clika_rt_error*(* op_hypot_inplace)(clika_rt_tensor *self, clika_rt_tensor *other)

ClikaRT::ops::hypot_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1677

op_index​

clika_rt_error*(* op_index)(clika_rt_tensor *x, const clika_rt_index_entry *indices, size_t indices_count, clika_rt_tensor **out)

ClikaRT::ops::index <- ClikaRT/compute/ops.h consumes x (contract §6) index payload; embedded tensors BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 5762

op_index_add​

clika_rt_error*(* op_index_add)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor *indices, clika_rt_tensor *src, clika_rt_tensor **out)

ClikaRT::ops::index_add <- ClikaRT/compute/ops.h consumes x (contract §6) consumes indices (contract §6) consumes src (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2989

op_index_add_inplace​

clika_rt_error*(* op_index_add_inplace)(clika_rt_tensor *self, int64_t dim, clika_rt_tensor *indices, clika_rt_tensor *src)

ClikaRT::ops::index_add_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes indices (contract §6) consumes src (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3000

op_index_copy​

clika_rt_error*(* op_index_copy)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor *indices, clika_rt_tensor *src, clika_rt_tensor **out)

ClikaRT::ops::index_copy <- ClikaRT/compute/ops.h consumes x (contract §6) consumes indices (contract §6) consumes src (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3009

op_index_copy_inplace​

clika_rt_error*(* op_index_copy_inplace)(clika_rt_tensor *self, int64_t dim, clika_rt_tensor *indices, clika_rt_tensor *src)

ClikaRT::ops::index_copy_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes indices (contract §6) consumes src (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3020

op_index_fill​

clika_rt_error*(* op_index_fill)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor *indices, clika_rt_scalar_or_tensor value, clika_rt_tensor **out)

ClikaRT::ops::index_fill <- ClikaRT/compute/ops.h consumes x (contract §6) consumes indices (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3029

op_index_fill_inplace​

clika_rt_error*(* op_index_fill_inplace)(clika_rt_tensor *self, int64_t dim, clika_rt_tensor *indices, clika_rt_scalar_or_tensor value)

ClikaRT::ops::index_fill_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes indices (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3040

op_index_put​

clika_rt_error*(* op_index_put)(clika_rt_tensor *x, const clika_rt_index_entry *indices, size_t indices_count, clika_rt_scalar_or_tensor value, uint8_t accumulate, clika_rt_tensor **out)

ClikaRT::ops::index_put <- ClikaRT/compute/ops.h consumes x (contract §6) index payload; embedded tensors BORROWED (contract §11) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): accumulate=false

Declared in clika_rt/clika_rt_core.h, line 5772

op_index_put_inplace​

clika_rt_error*(* op_index_put_inplace)(clika_rt_tensor *self, const clika_rt_index_entry *indices, size_t indices_count, clika_rt_scalar_or_tensor value, uint8_t accumulate)

ClikaRT::ops::index_put_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) index payload; embedded tensors BORROWED (contract §11) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): accumulate=false

Declared in clika_rt/clika_rt_core.h, line 5785

op_index_select​

clika_rt_error*(* op_index_select)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor *index, clika_rt_tensor **out)

ClikaRT::ops::index_select <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3048

op_inner​

clika_rt_error*(* op_inner)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::inner <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3276

op_instance_norm​

clika_rt_error*(* op_instance_norm)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, clika_rt_tensor *running_mean, clika_rt_tensor *running_var, uint8_t eps_has, double eps, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::instance_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) optional; NULL = absent; consumes running_mean when present (contract §6) optional; NULL = absent; consumes running_var when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, running_mean={}, running_var={}, eps=std::nullopt, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4204

op_interpolate​

clika_rt_error*(* op_interpolate)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, const clika_rt_scalar_or_tensor *scale_factors, size_t scale_factors_count, clika_rt_interp_mode mode, uint8_t align_corners_has, uint8_t align_corners, uint8_t recompute_scale_factor, uint8_t antialias, clika_rt_tensor **out)

ClikaRT::ops::interpolate <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) align_corners read only when align_corners_has is nonzero (contract §9) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, mode=InterpMode::Nearest, align_corners=std::nullopt, recompute_scale_factor=false, antialias=false

Declared in clika_rt/clika_rt_core.h, line 5797

op_isclose​

clika_rt_error*(* op_isclose)(clika_rt_tensor *a, clika_rt_tensor *b, double rtol, double atol, uint8_t equal_nan, clika_rt_tensor **out)

ClikaRT::ops::isclose <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): rtol=1e-5, atol=1e-8, equal_nan=false

Declared in clika_rt/clika_rt_core.h, line 2019

op_isfinite​

clika_rt_error*(* op_isfinite)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::isfinite <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2028

op_isinf​

clika_rt_error*(* op_isinf)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::isinf <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2033

op_isnan​

clika_rt_error*(* op_isnan)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::isnan <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2038

op_isneginf​

clika_rt_error*(* op_isneginf)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::isneginf <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2043

op_isposinf​

clika_rt_error*(* op_isposinf)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::isposinf <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2048

op_kl_div​

clika_rt_error*(* op_kl_div)(clika_rt_tensor *input, clika_rt_tensor *target, clika_rt_reduction reduction, uint8_t log_target, clika_rt_tensor **out)

ClikaRT::ops::kl_div <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean, log_target=false

Declared in clika_rt/clika_rt_core.h, line 3514

op_kron​

clika_rt_error*(* op_kron)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::kron <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3283

op_kthvalue​

clika_rt_error*(* op_kthvalue)(clika_rt_tensor *x, int64_t k, int64_t dim, uint8_t keepdim, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::kthvalue <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=-1, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 5151

op_l1_loss​

clika_rt_error*(* op_l1_loss)(clika_rt_tensor *input, clika_rt_tensor *target, clika_rt_reduction reduction, clika_rt_tensor **out)

ClikaRT::ops::l1_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean

Declared in clika_rt/clika_rt_core.h, line 3524

op_layer_norm​

clika_rt_error*(* op_layer_norm)(clika_rt_tensor *x, const int64_t *normalized_shape, size_t normalized_shape_count, clika_rt_tensor *weight, clika_rt_tensor *bias, uint8_t eps_has, double eps, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::layer_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, eps=std::nullopt, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4222

op_le​

clika_rt_error*(* op_le)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::le <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 2054

op_le_inplace​

clika_rt_error*(* op_le_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::le_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 2062

op_leaky_relu​

clika_rt_error*(* op_leaky_relu)(clika_rt_tensor *x, double negative_slope, clika_rt_tensor **out)

ClikaRT::ops::leaky_relu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): negative_slope=0.01

Declared in clika_rt/clika_rt_core.h, line 1001

op_leaky_relu_inplace​

clika_rt_error*(* op_leaky_relu_inplace)(clika_rt_tensor *self, double negative_slope)

ClikaRT::ops::leaky_relu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): negative_slope=0.01

Declared in clika_rt/clika_rt_core.h, line 1009

op_linear​

clika_rt_error*(* op_linear)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, double situ_beta, double situ_linear_beta, clika_rt_tensor **out)

ClikaRT::ops::linear <- ClikaRT/compute/ops.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, situ_beta=0.0, situ_linear_beta=0.0

Declared in clika_rt/clika_rt_core.h, line 3349

op_linspace​

clika_rt_error*(* op_linspace)(clika_rt_scalar_or_tensor start, clika_rt_scalar_or_tensor end, clika_rt_scalar_or_tensor steps, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::linspace <- ClikaRT/compute/ops.h start.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) end.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) steps.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Float32, s={}

Declared in clika_rt/clika_rt_core.h, line 2911

op_log​

clika_rt_error*(* op_log)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::log <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5472

op_log10​

clika_rt_error*(* op_log10)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::log10 <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5482

op_log10_inplace​

clika_rt_error*(* op_log10_inplace)(clika_rt_tensor *self)

ClikaRT::ops::log10_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5488

op_log1p​

clika_rt_error*(* op_log1p)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::log1p <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5492

op_log1p_inplace​

clika_rt_error*(* op_log1p_inplace)(clika_rt_tensor *self)

ClikaRT::ops::log1p_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5498

op_log2​

clika_rt_error*(* op_log2)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::log2 <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5502

op_log2_inplace​

clika_rt_error*(* op_log2_inplace)(clika_rt_tensor *self)

ClikaRT::ops::log2_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5508

op_log_inplace​

clika_rt_error*(* op_log_inplace)(clika_rt_tensor *self)

ClikaRT::ops::log_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5478

op_log_sigmoid​

clika_rt_error*(* op_log_sigmoid)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::log_sigmoid <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1014

op_log_sigmoid_inplace​

clika_rt_error*(* op_log_sigmoid_inplace)(clika_rt_tensor *self)

ClikaRT::ops::log_sigmoid_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1020

op_log_softmax​

clika_rt_error*(* op_log_softmax)(clika_rt_tensor *x, int64_t dim, clika_rt_data_type dtype, clika_rt_tensor **out)

ClikaRT::ops::log_softmax <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1, dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 1025

op_log_softmax_inplace​

clika_rt_error*(* op_log_softmax_inplace)(clika_rt_tensor *self, int64_t dim)

ClikaRT::ops::log_softmax_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dim=-1

Declared in clika_rt/clika_rt_core.h, line 1034

op_logaddexp​

clika_rt_error*(* op_logaddexp)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::logaddexp <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1683

op_logaddexp2​

clika_rt_error*(* op_logaddexp2)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::logaddexp2 <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1690

op_logical_and​

clika_rt_error*(* op_logical_and)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::logical_and <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2068

op_logical_and_inplace​

clika_rt_error*(* op_logical_and_inplace)(clika_rt_tensor *self, clika_rt_tensor *other)

ClikaRT::ops::logical_and_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2076

op_logical_not​

clika_rt_error*(* op_logical_not)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::logical_not <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2081

op_logical_not_inplace​

clika_rt_error*(* op_logical_not_inplace)(clika_rt_tensor *self)

ClikaRT::ops::logical_not_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 2087

op_logical_or​

clika_rt_error*(* op_logical_or)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::logical_or <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2092

op_logical_or_inplace​

clika_rt_error*(* op_logical_or_inplace)(clika_rt_tensor *self, clika_rt_tensor *other)

ClikaRT::ops::logical_or_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2100

op_logical_xor​

clika_rt_error*(* op_logical_xor)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::logical_xor <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2106

op_logical_xor_inplace​

clika_rt_error*(* op_logical_xor_inplace)(clika_rt_tensor *self, clika_rt_tensor *other)

ClikaRT::ops::logical_xor_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2114

op_logit​

clika_rt_error*(* op_logit)(clika_rt_tensor *x, uint8_t eps_has, double eps, clika_rt_tensor **out)

ClikaRT::ops::logit <- ClikaRT/compute/ops.h consumes x (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 5514

op_logit_inplace​

clika_rt_error*(* op_logit_inplace)(clika_rt_tensor *self, uint8_t eps_has, double eps)

ClikaRT::ops::logit_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 5524

op_logsumexp​

clika_rt_error*(* op_logsumexp)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::logsumexp <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4889

op_lt​

clika_rt_error*(* op_lt)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::lt <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 2120

op_lt_inplace​

clika_rt_error*(* op_lt_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::lt_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 2128

op_masked_fill​

clika_rt_error*(* op_masked_fill)(clika_rt_tensor *x, clika_rt_tensor *mask, clika_rt_scalar_or_tensor value, clika_rt_tensor **out)

ClikaRT::ops::masked_fill <- ClikaRT/compute/ops.h consumes x (contract §6) consumes mask (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3057

op_masked_fill_inplace​

clika_rt_error*(* op_masked_fill_inplace)(clika_rt_tensor *self, clika_rt_tensor *mask, clika_rt_scalar_or_tensor value)

ClikaRT::ops::masked_fill_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes mask (contract §6) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3067

op_masked_scatter​

clika_rt_error*(* op_masked_scatter)(clika_rt_tensor *x, clika_rt_tensor *mask, clika_rt_tensor *source, clika_rt_tensor **out)

ClikaRT::ops::masked_scatter <- ClikaRT/compute/ops.h consumes x (contract §6) consumes mask (contract §6) consumes source (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3075

op_masked_scatter_inplace​

clika_rt_error*(* op_masked_scatter_inplace)(clika_rt_tensor *self, clika_rt_tensor *mask, clika_rt_tensor *source)

ClikaRT::ops::masked_scatter_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes mask (contract §6) consumes source (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3085

op_masked_select​

clika_rt_error*(* op_masked_select)(clika_rt_tensor *x, clika_rt_tensor *mask, clika_rt_tensor **out)

ClikaRT::ops::masked_select <- ClikaRT/compute/ops.h consumes x (contract §6) consumes mask (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3092

op_matmul​

clika_rt_error*(* op_matmul)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, uint8_t transpose_a, uint8_t transpose_b, double situ_beta, double situ_linear_beta, clika_rt_tensor **out)

ClikaRT::ops::matmul <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false, situ_beta=0.0, situ_linear_beta=0.0

Declared in clika_rt/clika_rt_core.h, line 3293

op_max​

clika_rt_error*(* op_max)(clika_rt_tensor *x, int64_t dim, uint8_t keepdim, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::max <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4899

op_max_pool​

clika_rt_error*(* op_max_pool)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, uint8_t ceil_mode, clika_rt_tensor **out)

ClikaRT::ops::max_pool <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4543

op_max_pool1d​

clika_rt_error*(* op_max_pool1d)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, uint8_t ceil_mode, clika_rt_tensor **out)

ClikaRT::ops::max_pool1d <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): stride={}, padding={0}, dilation={1}, ceil_mode=false

Declared in clika_rt/clika_rt_core.h, line 4558

op_max_pool1d_with_indices​

clika_rt_error*(* op_max_pool1d_with_indices)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, uint8_t ceil_mode, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::max_pool1d_with_indices <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): stride={}, padding={0}, dilation={1}, ceil_mode=false

Declared in clika_rt/clika_rt_core.h, line 4620

op_max_pool2d​

clika_rt_error*(* op_max_pool2d)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, uint8_t ceil_mode, clika_rt_tensor **out)

ClikaRT::ops::max_pool2d <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): stride={}, padding={0, 0}, dilation={1, 1}, ceil_mode=false

Declared in clika_rt/clika_rt_core.h, line 4573

op_max_pool2d_with_indices​

clika_rt_error*(* op_max_pool2d_with_indices)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, uint8_t ceil_mode, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::max_pool2d_with_indices <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): stride={}, padding={0, 0}, dilation={1, 1}, ceil_mode=false

Declared in clika_rt/clika_rt_core.h, line 4637

op_max_pool3d​

clika_rt_error*(* op_max_pool3d)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, uint8_t ceil_mode, clika_rt_tensor **out)

ClikaRT::ops::max_pool3d <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): stride={}, padding={0, 0, 0}, dilation={1, 1, 1}, ceil_mode=false

Declared in clika_rt/clika_rt_core.h, line 4588

op_max_pool3d_with_indices​

clika_rt_error*(* op_max_pool3d_with_indices)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, uint8_t ceil_mode, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::max_pool3d_with_indices <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): stride={}, padding={0, 0, 0}, dilation={1, 1, 1}, ceil_mode=false

Declared in clika_rt/clika_rt_core.h, line 4654

op_max_pool_with_indices​

clika_rt_error*(* op_max_pool_with_indices)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, uint8_t ceil_mode, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::max_pool_with_indices <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10)

Declared in clika_rt/clika_rt_core.h, line 4603

op_maximum​

clika_rt_error*(* op_maximum)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::maximum <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1697

op_maximum_inplace​

clika_rt_error*(* op_maximum_inplace)(clika_rt_tensor *self, clika_rt_tensor *other)

ClikaRT::ops::maximum_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1705

op_mean​

clika_rt_error*(* op_mean)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_data_type dtype, clika_rt_tensor **out)

ClikaRT::ops::mean <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 4908

op_median​

clika_rt_error*(* op_median)(clika_rt_tensor *x, uint8_t dim_has, int64_t dim, uint8_t keepdim, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::median <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4920

op_meshgrid​

clika_rt_error*(* op_meshgrid)(clika_rt_tensor *const *tensors, size_t tensors_count, clika_rt_meshgrid_indexing indexing, clika_rt_tensor_list **out)

ClikaRT::ops::meshgrid <- ClikaRT/compute/ops.h elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): indexing=MeshgridIndexing::IJ

Declared in clika_rt/clika_rt_core.h, line 3937

op_min​

clika_rt_error*(* op_min)(clika_rt_tensor *x, int64_t dim, uint8_t keepdim, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::min <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4931

op_minimum​

clika_rt_error*(* op_minimum)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::minimum <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1711

op_minimum_inplace​

clika_rt_error*(* op_minimum_inplace)(clika_rt_tensor *self, clika_rt_tensor *other)

ClikaRT::ops::minimum_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes other (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1719

op_mish​

clika_rt_error*(* op_mish)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::mish <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1039

op_mish_inplace​

clika_rt_error*(* op_mish_inplace)(clika_rt_tensor *self)

ClikaRT::ops::mish_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1045

op_mla_attention​

clika_rt_error*(* op_mla_attention)(clika_rt_tensor *q_nope, clika_rt_tensor *q_pe, clika_rt_tensor *new_ckv, clika_rt_tensor *new_kpe, clika_rt_tensor *ckv_cache, clika_rt_tensor *kpe_cache, clika_rt_tensor *kvcache_start, clika_rt_tensor *cu_seqlens_q, double scale, clika_rt_tensor *slot_ids, clika_rt_tensor **out)

ClikaRT::ops::mla_attention <- ClikaRT/compute/ops.h consumes q_nope (contract §6) consumes q_pe (contract §6) consumes new_ckv (contract §6) consumes new_kpe (contract §6) consumes ckv_cache (contract §6) consumes kpe_cache (contract §6) consumes kvcache_start (contract §6) consumes cu_seqlens_q (contract §6) optional; NULL = absent; consumes slot_ids when present (contract §6) C++ defaults (dropped at this surface): slot_ids={}

Declared in clika_rt/clika_rt_core.h, line 4396

op_mm​

clika_rt_error*(* op_mm)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::mm <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3310

op_mod​

clika_rt_error*(* op_mod)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_mod_mode mode, clika_rt_tensor **out)

ClikaRT::ops::mod <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): mode=ModMode::Python

Declared in clika_rt/clika_rt_core.h, line 1726

op_mod_inplace​

clika_rt_error*(* op_mod_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other, clika_rt_mod_mode mode)

ClikaRT::ops::mod_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): mode=ModMode::Python

Declared in clika_rt/clika_rt_core.h, line 1736

op_moe​

clika_rt_error*(* op_moe)(clika_rt_tensor *input, clika_rt_tensor *router_logits, clika_rt_tensor *fc1_experts, clika_rt_tensor *fc2_experts, int64_t top_k, clika_rt_tensor *fc1_bias, clika_rt_tensor *fc2_bias, clika_rt_tensor *fc3_experts, clika_rt_tensor *fc3_bias, clika_rt_tensor *e_score_correction_bias, clika_rt_tensor *router_weights, uint8_t routing_mode_has, clika_rt_moe_routing routing_mode, uint8_t renormalize_has, uint8_t renormalize, uint8_t n_group_has, int64_t n_group, uint8_t topk_group_has, int64_t topk_group, uint8_t routed_scaling_factor_has, double routed_scaling_factor, uint8_t sparse_mixer_eps_has, double sparse_mixer_eps, uint8_t apply_router_weight_on_input_has, uint8_t apply_router_weight_on_input, uint8_t activation_has, clika_rt_activation activation, uint8_t swiglu_fusion_has, clika_rt_swiglu_fusion swiglu_fusion, uint8_t swiglu_alpha_has, double swiglu_alpha, uint8_t swiglu_beta_has, double swiglu_beta, uint8_t swiglu_limit_has, double swiglu_limit, uint8_t gelu_mode_has, clika_rt_gelu_mode gelu_mode, clika_rt_tensor *shared_output, clika_rt_tensor **out)

ClikaRT::ops::moe <- ClikaRT/compute/ops.h consumes input (contract §6) consumes router_logits (contract §6) consumes fc1_experts (contract §6) consumes fc2_experts (contract §6) optional; NULL = absent; consumes fc1_bias when present (contract §6) optional; NULL = absent; consumes fc2_bias when present (contract §6) optional; NULL = absent; consumes fc3_experts when present (contract §6) optional; NULL = absent; consumes fc3_bias when present (contract §6) optional; NULL = absent; consumes e_score_correction_bias when present (contract §6) optional; NULL = absent; consumes router_weights when present (contract §6) routing_mode read only when routing_mode_has is nonzero (contract §9) renormalize read only when renormalize_has is nonzero (contract §9) n_group read only when n_group_has is nonzero (contract §9) topk_group read only when topk_group_has is nonzero (contract §9) routed_scaling_factor read only when routed_scaling_factor_has is nonzero (contract §9) sparse_mixer_eps read only when sparse_mixer_eps_has is nonzero (contract §9) apply_router_weight_on_input read only when apply_router_weight_on_input_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) swiglu_fusion read only when swiglu_fusion_has is nonzero (contract §9) swiglu_alpha read only when swiglu_alpha_has is nonzero (contract §9) swiglu_beta read only when swiglu_beta_has is nonzero (contract §9) swiglu_limit read only when swiglu_limit_has is nonzero (contract §9) gelu_mode read only when gelu_mode_has is nonzero (contract §9) optional; NULL = absent; consumes shared_output when present (contract §6) C++ defaults (dropped at this surface): fc1_bias={}, fc2_bias={}, fc3_experts={}, fc3_bias={}, e_score_correction_bias={}, router_weights={}, routing_mode=std::nullopt, renormalize=std::nullopt, n_group=std::nullopt, topk_group=std::nullopt, routed_scaling_factor=std::nullopt, sparse_mixer_eps=std::nullopt, apply_router_weight_on_input=std::nullopt, activation=std::nullopt, swiglu_fusion=std::nullopt, swiglu_alpha=std::nullopt, swiglu_beta=std::nullopt, swiglu_limit=std::nullopt, gelu_mode=std::nullopt, shared_output={}

Declared in clika_rt/clika_rt_core.h, line 3384

op_mrope_rotary_embedding​

clika_rt_error*(* op_mrope_rotary_embedding)(clika_rt_tensor *x0, clika_rt_tensor *position_ids, const int64_t *mrope_sections, size_t mrope_sections_count, uint8_t interleaved_sections_has, uint8_t interleaved_sections, uint8_t theta_has, double theta, uint8_t scaling_has, clika_rt_rope_scaling scaling, uint8_t mode_has, clika_rt_rotary_mode mode, uint8_t rotary_dim_has, int64_t rotary_dim, uint8_t scale_has, double scale, clika_rt_tensor **out)

ClikaRT::ops::mrope_rotary_embedding <- ClikaRT/compute/ops.h consumes x0 (contract §6) consumes position_ids (contract §6) interleaved_sections read only when interleaved_sections_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) C++ defaults (dropped at this surface): interleaved_sections=std::nullopt, theta=std::nullopt, scaling=std::nullopt, mode=std::nullopt, rotary_dim=std::nullopt, scale=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 2705

op_mrope_rotary_embedding_qk_varlen​

clika_rt_error*(* op_mrope_rotary_embedding_qk_varlen)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *position_ids, const int64_t *mrope_sections, size_t mrope_sections_count, uint8_t interleaved_sections_has, uint8_t interleaved_sections, uint8_t theta_has, double theta, uint8_t scaling_has, clika_rt_rope_scaling scaling, uint8_t mode_has, clika_rt_rotary_mode mode, uint8_t rotary_dim_has, int64_t rotary_dim, uint8_t scale_has, double scale, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::mrope_rotary_embedding_qk_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes position_ids (contract §6) interleaved_sections read only when interleaved_sections_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): interleaved_sections=std::nullopt, theta=std::nullopt, scaling=std::nullopt, mode=std::nullopt, rotary_dim=std::nullopt, scale=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 2763

op_mrope_rotary_embedding_varlen​

clika_rt_error*(* op_mrope_rotary_embedding_varlen)(clika_rt_tensor *x0, clika_rt_tensor *position_ids, const int64_t *mrope_sections, size_t mrope_sections_count, uint8_t interleaved_sections_has, uint8_t interleaved_sections, uint8_t theta_has, double theta, uint8_t scaling_has, clika_rt_rope_scaling scaling, uint8_t mode_has, clika_rt_rotary_mode mode, uint8_t rotary_dim_has, int64_t rotary_dim, uint8_t scale_has, double scale, clika_rt_tensor **out)

ClikaRT::ops::mrope_rotary_embedding_varlen <- ClikaRT/compute/ops.h consumes x0 (contract §6) consumes position_ids (contract §6) interleaved_sections read only when interleaved_sections_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) C++ defaults (dropped at this surface): interleaved_sections=std::nullopt, theta=std::nullopt, scaling=std::nullopt, mode=std::nullopt, rotary_dim=std::nullopt, scale=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 2733

op_ms_deform_attention​

clika_rt_error*(* op_ms_deform_attention)(clika_rt_tensor *value, clika_rt_tensor *spatial_shapes, clika_rt_tensor *level_start_index, clika_rt_tensor *sampling_locations, clika_rt_tensor *attention_weights, clika_rt_tensor **out)

ClikaRT::ops::ms_deform_attention <- ClikaRT/compute/ops.h consumes value (contract §6) consumes spatial_shapes (contract §6) consumes level_start_index (contract §6) consumes sampling_locations (contract §6) consumes attention_weights (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4414

op_mse_loss​

clika_rt_error*(* op_mse_loss)(clika_rt_tensor *input, clika_rt_tensor *target, clika_rt_reduction reduction, clika_rt_tensor **out)

ClikaRT::ops::mse_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean

Declared in clika_rt/clika_rt_core.h, line 3533

op_mul_inplace​

clika_rt_error*(* op_mul_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other, clika_rt_activation activation)

ClikaRT::ops::mul_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1792

op_mul_scalar_lhs​

clika_rt_error*(* op_mul_scalar_lhs)(clika_rt_scalar a, clika_rt_tensor *b, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::mul <- ClikaRT/compute/ops.h one form of the overloaded C++ mul; the _scalar_lhs suffix names this form consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1782

op_mul_tensor​

clika_rt_error*(* op_mul_tensor)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::mul <- ClikaRT/compute/ops.h one form of the overloaded C++ mul; the _tensor suffix names this form consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1773

op_multinomial​

clika_rt_error*(* op_multinomial)(clika_rt_tensor *probabilities, int64_t num_samples, uint8_t replacement, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::multinomial <- ClikaRT/compute/ops.h consumes probabilities (contract §6) C++ defaults (dropped at this surface): replacement=false, s={}

Declared in clika_rt/clika_rt_core.h, line 4692

op_mv​

clika_rt_error*(* op_mv)(clika_rt_tensor *a, clika_rt_tensor *vec, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::mv <- ClikaRT/compute/ops.h consumes a (contract §6) consumes vec (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3336

op_nan_to_num​

clika_rt_error*(* op_nan_to_num)(clika_rt_tensor *x, uint8_t nan_has, double nan, uint8_t posinf_has, double posinf, uint8_t neginf_has, double neginf, clika_rt_tensor **out)

ClikaRT::ops::nan_to_num <- ClikaRT/compute/ops.h consumes x (contract §6) nan read only when nan_has is nonzero (contract §9) posinf read only when posinf_has is nonzero (contract §9) neginf read only when neginf_has is nonzero (contract §9) C++ defaults (dropped at this surface): nan=std::nullopt, posinf=std::nullopt, neginf=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 5534

op_nan_to_num_inplace​

clika_rt_error*(* op_nan_to_num_inplace)(clika_rt_tensor *self, uint8_t nan_has, double nan, uint8_t posinf_has, double posinf, uint8_t neginf_has, double neginf)

ClikaRT::ops::nan_to_num_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) nan read only when nan_has is nonzero (contract §9) posinf read only when posinf_has is nonzero (contract §9) neginf read only when neginf_has is nonzero (contract §9) C++ defaults (dropped at this surface): nan=std::nullopt, posinf=std::nullopt, neginf=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 5550

op_nanmean​

clika_rt_error*(* op_nanmean)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::nanmean <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4940

op_nanmedian​

clika_rt_error*(* op_nanmedian)(clika_rt_tensor *x, uint8_t dim_has, int64_t dim, uint8_t keepdim, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::nanmedian <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4951

op_nanquantile​

clika_rt_error*(* op_nanquantile)(clika_rt_tensor *x, clika_rt_scalar_or_tensor q, uint8_t dim_has, int64_t dim, uint8_t keepdim, clika_rt_quantile_interp interpolation, clika_rt_tensor **out)

ClikaRT::ops::nanquantile <- ClikaRT/compute/ops.h consumes x (contract §6) q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false, interpolation=QuantileInterp::Linear

Declared in clika_rt/clika_rt_core.h, line 5163

op_nansum​

clika_rt_error*(* op_nansum)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::nansum <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4961

op_narrow​

clika_rt_error*(* op_narrow)(clika_rt_tensor *x, int64_t dim, clika_rt_index_bound start, clika_rt_index_bound length, clika_rt_tensor **out)

ClikaRT::ops::narrow <- ClikaRT/compute/ops.h consumes x (contract §6) an embedded tensor is BORROWED (contract §11) an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3902

op_ndim​

clika_rt_error*(* op_ndim)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::ndim <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3564

op_ndim_host​

clika_rt_error*(* op_ndim_host)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::ndim_host <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5756

op_ne​

clika_rt_error*(* op_ne)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::ne <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 2134

op_ne_inplace​

clika_rt_error*(* op_ne_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::ne_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 2142

op_neg​

clika_rt_error*(* op_neg)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::neg <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5560

op_neg_inplace​

clika_rt_error*(* op_neg_inplace)(clika_rt_tensor *self)

ClikaRT::ops::neg_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5566

op_nll_loss​

clika_rt_error*(* op_nll_loss)(clika_rt_tensor *input, clika_rt_tensor *target, clika_rt_tensor *weight, uint8_t ignore_index_has, int64_t ignore_index, clika_rt_reduction reduction, clika_rt_tensor **out)

ClikaRT::ops::nll_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) optional; NULL = absent; consumes weight when present (contract §6) ignore_index read only when ignore_index_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, ignore_index=std::nullopt, reduction=Reduction::Mean

Declared in clika_rt/clika_rt_core.h, line 3544

op_nms​

clika_rt_error*(* op_nms)(clika_rt_tensor *boxes, clika_rt_tensor *scores, clika_rt_scalar_or_tensor max_output_boxes_per_class, clika_rt_scalar_or_tensor iou_threshold, clika_rt_scalar_or_tensor score_threshold, uint8_t center_point_box, clika_rt_tensor **out)

ClikaRT::ops::nms <- ClikaRT/compute/ops.h consumes boxes (contract §6) consumes scores (contract §6) max_output_boxes_per_class.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) iou_threshold.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) score_threshold.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): max_output_boxes_per_class=std::nullopt, iou_threshold=std::nullopt, score_threshold=std::nullopt, center_point_box=false

Declared in clika_rt/clika_rt_core.h, line 3218

op_nonzero​

clika_rt_error*(* op_nonzero)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::nonzero <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3098

op_norm​

clika_rt_error*(* op_norm)(clika_rt_tensor *x, clika_rt_scalar p, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::norm <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): p=2.0, dims={}, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 4970

op_normal​

clika_rt_error*(* op_normal)(clika_rt_scalar_or_tensor mean, clika_rt_scalar_or_tensor stddev, const clika_rt_scalar_or_tensor *shape, size_t shape_count, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::normal <- ClikaRT/compute/ops.h mean.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) stddev.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 4714

op_normal_inplace​

clika_rt_error*(* op_normal_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor mean, clika_rt_scalar_or_tensor stddev, clika_rt_stream_or_device s)

ClikaRT::ops::normal_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) mean.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) stddev.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): mean=0, stddev=1, s={}

Declared in clika_rt/clika_rt_core.h, line 4704

op_normalize​

clika_rt_error*(* op_normalize)(clika_rt_tensor *x, clika_rt_scalar p, int64_t dim, uint8_t eps_has, double eps, clika_rt_tensor **out)

ClikaRT::ops::normalize <- ClikaRT/compute/ops.h consumes x (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): p=2.0, dim=1, eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4237

op_normalize_inplace​

clika_rt_error*(* op_normalize_inplace)(clika_rt_tensor *self, clika_rt_scalar p, int64_t dim, uint8_t eps_has, double eps)

ClikaRT::ops::normalize_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): p=2.0, dim=1, eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4249

op_numel​

clika_rt_error*(* op_numel)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::numel <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3569

op_numel_host​

clika_rt_error*(* op_numel_host)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::numel_host <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5751

op_one_hot​

clika_rt_error*(* op_one_hot)(clika_rt_tensor *indices, int64_t num_classes, clika_rt_tensor **out)

ClikaRT::ops::one_hot <- ClikaRT/compute/ops.h consumes indices (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2494

op_ones​

clika_rt_error*(* op_ones)(const clika_rt_scalar_or_tensor *shape, size_t shape_count, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_stream_or_device pinned_for, clika_rt_tensor **out)

ClikaRT::ops::ones <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): s={}, pinned_for={}

Declared in clika_rt/clika_rt_core.h, line 2921

op_ones_like​

clika_rt_error*(* op_ones_like)(clika_rt_tensor *reference, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::ones_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 2931

op_outer​

clika_rt_error*(* op_outer)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_tensor **out)

ClikaRT::ops::outer <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3427

op_pad​

clika_rt_error*(* op_pad)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *pad, size_t pad_count, clika_rt_pad_mode mode, clika_rt_scalar_or_tensor value, clika_rt_tensor **out)

ClikaRT::ops::pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) value.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): mode=PadMode::Constant, value=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3704

op_pairwise_distance​

clika_rt_error*(* op_pairwise_distance)(clika_rt_tensor *a, clika_rt_tensor *b, clika_rt_scalar p, uint8_t eps_has, double eps, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::pairwise_distance <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): p=2.0, eps=std::nullopt, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 3436

op_pdist​

clika_rt_error*(* op_pdist)(clika_rt_tensor *a, clika_rt_scalar p, clika_rt_tensor **out)

ClikaRT::ops::pdist <- ClikaRT/compute/ops.h consumes a (contract §6) C++ defaults (dropped at this surface): p=2.0

Declared in clika_rt/clika_rt_core.h, line 3447

op_permute​

clika_rt_error*(* op_permute)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, clika_rt_tensor **out)

ClikaRT::ops::permute <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3790

op_pixel_shuffle​

clika_rt_error*(* op_pixel_shuffle)(clika_rt_tensor *x, int64_t upscale_factor, clika_rt_pixel_shuffle_mode mode, clika_rt_tensor **out)

ClikaRT::ops::pixel_shuffle <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): mode=PixelShuffleMode::CRD

Declared in clika_rt/clika_rt_core.h, line 5076

op_pixel_unshuffle​

clika_rt_error*(* op_pixel_unshuffle)(clika_rt_tensor *x, int64_t downscale_factor, clika_rt_pixel_shuffle_mode mode, clika_rt_tensor **out)

ClikaRT::ops::pixel_unshuffle <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): mode=PixelShuffleMode::CRD

Declared in clika_rt/clika_rt_core.h, line 5084

op_poisson​

clika_rt_error*(* op_poisson)(clika_rt_tensor *rates, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::poisson <- ClikaRT/compute/ops.h consumes rates (contract §6) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 4724

op_pow​

clika_rt_error*(* op_pow)(clika_rt_tensor *a, clika_rt_scalar_or_tensor exponent, clika_rt_tensor **out)

ClikaRT::ops::pow <- ClikaRT/compute/ops.h consumes a (contract §6) exponent.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1819

op_pow_inplace​

clika_rt_error*(* op_pow_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor exponent)

ClikaRT::ops::pow_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) exponent.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1827

op_prelu​

clika_rt_error*(* op_prelu)(clika_rt_tensor *x, clika_rt_tensor *weight, clika_rt_tensor **out)

ClikaRT::ops::prelu <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) C++ defaults (dropped at this surface): weight={}

Declared in clika_rt/clika_rt_core.h, line 1051

op_prelu_inplace​

clika_rt_error*(* op_prelu_inplace)(clika_rt_tensor *self, clika_rt_tensor *weight)

ClikaRT::ops::prelu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) optional; NULL = absent; consumes weight when present (contract §6) C++ defaults (dropped at this surface): weight={}

Declared in clika_rt/clika_rt_core.h, line 1060

op_prod​

clika_rt_error*(* op_prod)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_data_type dtype, clika_rt_tensor **out)

ClikaRT::ops::prod <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 5020

op_put​

clika_rt_error*(* op_put)(clika_rt_tensor *x, clika_rt_tensor *index, clika_rt_tensor *source, uint8_t accumulate, clika_rt_tensor **out)

ClikaRT::ops::put <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) consumes source (contract §6) C++ defaults (dropped at this surface): accumulate=false

Declared in clika_rt/clika_rt_core.h, line 3106

op_put_inplace​

clika_rt_error*(* op_put_inplace)(clika_rt_tensor *self, clika_rt_tensor *index, clika_rt_tensor *source, uint8_t accumulate)

ClikaRT::ops::put_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes index (contract §6) consumes source (contract §6) C++ defaults (dropped at this surface): accumulate=false

Declared in clika_rt/clika_rt_core.h, line 3118

op_q_embedding​

clika_rt_error*(* op_q_embedding)(clika_rt_tensor *indices, clika_rt_qtensor *weight, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, clika_rt_data_type out_dtype, clika_rt_tensor **out)

ClikaRT::ops::q_embedding <- ClikaRT/compute/q_tensor.h consumes indices (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7896

op_qadd_inplace_to_dense​

clika_rt_error*(* op_qadd_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_activation activation)

ClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qadd_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6172

op_qadd_inplace_to_dense_out_scale​

clika_rt_error*(* op_qadd_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_activation activation)

ClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qadd_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6186

op_qadd_inplace_to_quantized​

clika_rt_error*(* op_qadd_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_qtensor *out, clika_rt_activation activation)

ClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qadd_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6160

op_qadd_to_dense​

clika_rt_error*(* op_qadd_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qadd <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qadd; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6132

op_qadd_to_quantized​

clika_rt_error*(* op_qadd_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_activation activation, clika_rt_qtensor **out)

ClikaRT::ops::qadd <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qadd; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6144

op_qconcat_inplace_to_dense​

clika_rt_error*(* op_qconcat_inplace_to_dense)(clika_rt_qtensor *const *tensors, size_t tensors_count, int64_t dim, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_activation activation)

ClikaRT::ops::qconcat_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconcat_; the _to_dense suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6441

op_qconcat_inplace_to_quantized​

clika_rt_error*(* op_qconcat_inplace_to_quantized)(clika_rt_qtensor *const *tensors, size_t tensors_count, int64_t dim, clika_rt_qtensor *out, clika_rt_activation activation)

ClikaRT::ops::qconcat_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconcat_; the _to_quantized suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6427

op_qconcat_to_dense​

clika_rt_error*(* op_qconcat_to_dense)(clika_rt_qtensor *const *tensors, size_t tensors_count, int64_t dim, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconcat <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconcat; the _to_dense suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): dim=0, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6399

op_qconcat_to_quantized​

clika_rt_error*(* op_qconcat_to_quantized)(clika_rt_qtensor *const *tensors, size_t tensors_count, int64_t dim, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_activation activation, clika_rt_qtensor **out)

ClikaRT::ops::qconcat <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconcat; the _to_quantized suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6411

op_qconv1d_to_dense​

clika_rt_error*(* op_qconv1d_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv1d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv1d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, dilation={1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7182

op_qconv1d_to_quantized​

clika_rt_error*(* op_qconv1d_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qconv1d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv1d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7203

op_qconv1d_woq​

clika_rt_error*(* op_qconv1d_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv1d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, dilation={1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7416

op_qconv2d_to_dense​

clika_rt_error*(* op_qconv2d_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv2d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv2d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7226

op_qconv2d_to_quantized​

clika_rt_error*(* op_qconv2d_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qconv2d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv2d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7247

op_qconv2d_woq​

clika_rt_error*(* op_qconv2d_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv2d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7434

op_qconv3d_to_dense​

clika_rt_error*(* op_qconv3d_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv3d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv3d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7270

op_qconv3d_to_quantized​

clika_rt_error*(* op_qconv3d_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qconv3d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv3d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7291

op_qconv3d_woq​

clika_rt_error*(* op_qconv3d_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv3d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7452

op_qconv_inplace_to_dense​

clika_rt_error*(* op_qconv_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *out, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_pad_mode mode, uint8_t value_has, double value, clika_rt_activation activation)

ClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7342

op_qconv_inplace_to_dense_out_scale​

clika_rt_error*(* op_qconv_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_pad_mode mode, uint8_t value_has, double value, clika_rt_activation activation)

ClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): out_quant_axis=-1, bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7369

op_qconv_inplace_to_quantized​

clika_rt_error*(* op_qconv_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_qtensor *out, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_pad_mode mode, uint8_t value_has, double value, clika_rt_activation activation)

ClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7317

op_qconv_to_dense​

clika_rt_error*(* op_qconv_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_pad_mode mode, uint8_t value_has, double value, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7131

op_qconv_to_quantized​

clika_rt_error*(* op_qconv_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_pad_mode mode, uint8_t value_has, double value, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qconv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7156

op_qconv_transpose1d_to_dense​

clika_rt_error*(* op_qconv_transpose1d_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv_transpose1d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose1d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, output_padding={0}, dilation={1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7519

op_qconv_transpose1d_to_quantized​

clika_rt_error*(* op_qconv_transpose1d_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qconv_transpose1d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose1d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7542

op_qconv_transpose1d_woq​

clika_rt_error*(* op_qconv_transpose1d_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv_transpose1d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1}, padding={0}, output_padding={0}, dilation={1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7757

op_qconv_transpose2d_to_dense​

clika_rt_error*(* op_qconv_transpose2d_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv_transpose2d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose2d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, output_padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7567

op_qconv_transpose2d_to_quantized​

clika_rt_error*(* op_qconv_transpose2d_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qconv_transpose2d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose2d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7590

op_qconv_transpose2d_woq​

clika_rt_error*(* op_qconv_transpose2d_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv_transpose2d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1}, padding={0, 0}, output_padding={0, 0}, dilation={1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7777

op_qconv_transpose3d_to_dense​

clika_rt_error*(* op_qconv_transpose3d_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv_transpose3d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose3d; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, output_padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7615

op_qconv_transpose3d_to_quantized​

clika_rt_error*(* op_qconv_transpose3d_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qconv_transpose3d <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose3d; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7638

op_qconv_transpose3d_woq​

clika_rt_error*(* op_qconv_transpose3d_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv_transpose3d_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={1, 1, 1}, padding={0, 0, 0}, output_padding={0, 0, 0}, dilation={1, 1, 1}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7797

op_qconv_transpose_inplace_to_dense​

clika_rt_error*(* op_qconv_transpose_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *out, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation)

ClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_transpose_; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7688

op_qconv_transpose_inplace_to_dense_out_scale​

clika_rt_error*(* op_qconv_transpose_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation)

ClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_transpose_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): out_quant_axis=-1, bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7713

op_qconv_transpose_inplace_to_quantized​

clika_rt_error*(* op_qconv_transpose_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_qtensor *out, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation)

ClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qconv_transpose_; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7665

op_qconv_transpose_to_dense​

clika_rt_error*(* op_qconv_transpose_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qconv_transpose <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7471

op_qconv_transpose_to_quantized​

clika_rt_error*(* op_qconv_transpose_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qconv_transpose <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qconv_transpose; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7494

op_qconv_transpose_woq​

clika_rt_error*(* op_qconv_transpose_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *output_padding, size_t output_padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_activation activation, clika_rt_qcompute_mode compute_mode, clika_rt_tensor **out)

ClikaRT::ops::qconv_transpose_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, output_padding={}, dilation={}, groups=1, activation=Activation::Identity, compute_mode=QComputeMode::ExactFP

Declared in clika_rt/clika_rt_core.h, line 7736

op_qconv_woq​

clika_rt_error*(* op_qconv_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, clika_rt_pad_mode mode, uint8_t value_has, double value, clika_rt_activation activation, clika_rt_qcompute_mode compute_mode, clika_rt_tensor **out)

ClikaRT::ops::qconv_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, stride={}, padding={}, dilation={}, groups=1, mode=PadMode::Constant, value=std::nullopt, activation=Activation::Identity, compute_mode=QComputeMode::ExactFP

Declared in clika_rt/clika_rt_core.h, line 7394

op_qdeform_conv_to_dense​

clika_rt_error*(* op_qdeform_conv_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *offset, clika_rt_tensor *mask, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, int64_t offset_groups, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qdeform_conv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qdeform_conv; the _to_dense suffix names this form consumes a (contract §6) consumes weight (contract §6) consumes offset (contract §6) optional; NULL = absent; consumes mask when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): mask={}, bias={}, stride={}, padding={}, dilation={}, groups=1, offset_groups=1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 7820

op_qdeform_conv_to_quantized​

clika_rt_error*(* op_qdeform_conv_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *weight, clika_rt_tensor *offset, clika_rt_tensor *mask, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, int64_t offset_groups, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qdeform_conv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qdeform_conv; the _to_quantized suffix names this form consumes a (contract §6) consumes weight (contract §6) consumes offset (contract §6) optional; NULL = absent; consumes mask when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7846

op_qdeform_conv_woq​

clika_rt_error*(* op_qdeform_conv_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *offset, clika_rt_tensor *mask, clika_rt_tensor *bias, const int64_t *stride, size_t stride_count, const int64_t *padding, size_t padding_count, const int64_t *dilation, size_t dilation_count, int64_t groups, int64_t offset_groups, clika_rt_activation activation, clika_rt_qcompute_mode compute_mode, clika_rt_tensor **out)

ClikaRT::ops::qdeform_conv_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) consumes offset (contract §6) optional; NULL = absent; consumes mask when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) C++ defaults (dropped at this surface): mask={}, bias={}, stride={}, padding={}, dilation={}, groups=1, offset_groups=1, activation=Activation::Identity, compute_mode=QComputeMode::ExactFP

Declared in clika_rt/clika_rt_core.h, line 7873

op_qdiv_inplace_to_dense​

clika_rt_error*(* op_qdiv_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_activation activation)

ClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qdiv_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6373

op_qdiv_inplace_to_dense_out_scale​

clika_rt_error*(* op_qdiv_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_activation activation)

ClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qdiv_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6387

op_qdiv_inplace_to_quantized​

clika_rt_error*(* op_qdiv_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_qtensor *out, clika_rt_activation activation)

ClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qdiv_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6361

op_qdiv_to_dense​

clika_rt_error*(* op_qdiv_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qdiv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qdiv; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6333

op_qdiv_to_quantized​

clika_rt_error*(* op_qdiv_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_activation activation, clika_rt_qtensor **out)

ClikaRT::ops::qdiv <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qdiv; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6345

op_qfast_gelu_inplace_to_dense​

clika_rt_error*(* op_qfast_gelu_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_tensor *out)

ClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qfast_gelu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6629

op_qfast_gelu_inplace_to_dense_out_scale​

clika_rt_error*(* op_qfast_gelu_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qfast_gelu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 6640

op_qfast_gelu_inplace_to_quantized​

clika_rt_error*(* op_qfast_gelu_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *out)

ClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qfast_gelu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6621

op_qfast_gelu_to_dense​

clika_rt_error*(* op_qfast_gelu_to_dense)(clika_rt_qtensor *a, clika_rt_tensor **out)

ClikaRT::ops::qfast_gelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qfast_gelu; the _to_dense suffix names this form consumes a (contract §6)

Declared in clika_rt/clika_rt_core.h, line 6600

op_qfast_gelu_to_quantized​

clika_rt_error*(* op_qfast_gelu_to_quantized)(clika_rt_qtensor *a, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qfast_gelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qfast_gelu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6609

op_qgelu_inplace_to_dense​

clika_rt_error*(* op_qgelu_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_tensor *out)

ClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qgelu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6580

op_qgelu_inplace_to_dense_out_scale​

clika_rt_error*(* op_qgelu_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qgelu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 6591

op_qgelu_inplace_to_quantized​

clika_rt_error*(* op_qgelu_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *out)

ClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qgelu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6572

op_qgelu_to_dense​

clika_rt_error*(* op_qgelu_to_dense)(clika_rt_qtensor *a, clika_rt_tensor **out)

ClikaRT::ops::qgelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qgelu; the _to_dense suffix names this form consumes a (contract §6)

Declared in clika_rt/clika_rt_core.h, line 6551

op_qgelu_to_quantized​

clika_rt_error*(* op_qgelu_to_quantized)(clika_rt_qtensor *a, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qgelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qgelu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6560

op_qhardswish_inplace_to_dense​

clika_rt_error*(* op_qhardswish_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_tensor *out)

ClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qhardswish_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6825

op_qhardswish_inplace_to_dense_out_scale​

clika_rt_error*(* op_qhardswish_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qhardswish_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 6836

op_qhardswish_inplace_to_quantized​

clika_rt_error*(* op_qhardswish_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *out)

ClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qhardswish_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6817

op_qhardswish_to_dense​

clika_rt_error*(* op_qhardswish_to_dense)(clika_rt_qtensor *a, clika_rt_tensor **out)

ClikaRT::ops::qhardswish <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qhardswish; the _to_dense suffix names this form consumes a (contract §6)

Declared in clika_rt/clika_rt_core.h, line 6796

op_qhardswish_to_quantized​

clika_rt_error*(* op_qhardswish_to_quantized)(clika_rt_qtensor *a, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qhardswish <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qhardswish; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6805

op_qk_layer_norm​

clika_rt_error*(* op_qk_layer_norm)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *w_q, clika_rt_tensor *b_q, clika_rt_tensor *w_k, clika_rt_tensor *b_k, int64_t head_dim, uint8_t eps_has, double eps, clika_rt_tensor **out0, clika_rt_tensor **out1, clika_rt_tensor **out2)

ClikaRT::ops::qk_layer_norm <- ClikaRT/compute/ops.h consumes q (contract §6) optional; NULL = absent; consumes k when present (contract §6) optional; NULL = absent; consumes v when present (contract §6) optional; NULL = absent; consumes w_q when present (contract §6) optional; NULL = absent; consumes b_q when present (contract §6) optional; NULL = absent; consumes w_k when present (contract §6) optional; NULL = absent; consumes b_k when present (contract §6) eps read only when eps_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): k={}, v={}, w_q={}, b_q={}, w_k={}, b_k={}, head_dim=0, eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4118

op_qk_layer_norm_inplace​

clika_rt_error*(* op_qk_layer_norm_inplace)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *w_q, clika_rt_tensor *b_q, clika_rt_tensor *w_k, clika_rt_tensor *b_k, int64_t head_dim, uint8_t eps_has, double eps)

ClikaRT::ops::qk_layer_norm_ <- ClikaRT/compute/ops.h in-place op borrows q; written through (the in-place target) optional; NULL = absent; consumes k when present (contract §6) optional; NULL = absent; consumes v when present (contract §6) optional; NULL = absent; consumes w_q when present (contract §6) optional; NULL = absent; consumes b_q when present (contract §6) optional; NULL = absent; consumes w_k when present (contract §6) optional; NULL = absent; consumes b_k when present (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): k={}, v={}, w_q={}, b_q={}, w_k={}, b_k={}, head_dim=0, eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4143

op_qk_rms_norm​

clika_rt_error*(* op_qk_rms_norm)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *w_q, clika_rt_tensor *w_k, int64_t head_dim, uint8_t eps_has, double eps, clika_rt_tensor **out0, clika_rt_tensor **out1, clika_rt_tensor **out2)

ClikaRT::ops::qk_rms_norm <- ClikaRT/compute/ops.h consumes q (contract §6) optional; NULL = absent; consumes k when present (contract §6) optional; NULL = absent; consumes v when present (contract §6) optional; NULL = absent; consumes w_q when present (contract §6) optional; NULL = absent; consumes w_k when present (contract §6) eps read only when eps_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): k={}, v={}, w_q={}, w_k={}, head_dim=0, eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4077

op_qk_rms_norm_inplace​

clika_rt_error*(* op_qk_rms_norm_inplace)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *w_q, clika_rt_tensor *w_k, int64_t head_dim, uint8_t eps_has, double eps)

ClikaRT::ops::qk_rms_norm_ <- ClikaRT/compute/ops.h in-place op borrows q; written through (the in-place target) optional; NULL = absent; consumes k when present (contract §6) optional; NULL = absent; consumes v when present (contract §6) optional; NULL = absent; consumes w_q when present (contract §6) optional; NULL = absent; consumes w_k when present (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): k={}, v={}, w_q={}, w_k={}, head_dim=0, eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4098

op_qleaky_relu_inplace_to_dense​

clika_rt_error*(* op_qleaky_relu_inplace_to_dense)(clika_rt_qtensor *a, double negative_slope, clika_rt_tensor *out)

ClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qleaky_relu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6878

op_qleaky_relu_inplace_to_dense_out_scale​

clika_rt_error*(* op_qleaky_relu_inplace_to_dense_out_scale)(clika_rt_qtensor *a, double negative_slope, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qleaky_relu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 6890

op_qleaky_relu_inplace_to_quantized​

clika_rt_error*(* op_qleaky_relu_inplace_to_quantized)(clika_rt_qtensor *a, double negative_slope, clika_rt_qtensor *out)

ClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qleaky_relu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6869

op_qleaky_relu_to_dense​

clika_rt_error*(* op_qleaky_relu_to_dense)(clika_rt_qtensor *a, double negative_slope, clika_rt_tensor **out)

ClikaRT::ops::qleaky_relu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qleaky_relu; the _to_dense suffix names this form consumes a (contract §6) C++ defaults (dropped at this surface): negative_slope=0.01

Declared in clika_rt/clika_rt_core.h, line 6846

op_qleaky_relu_to_quantized​

clika_rt_error*(* op_qleaky_relu_to_quantized)(clika_rt_qtensor *a, double negative_slope, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qleaky_relu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qleaky_relu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6856

op_qlinear_inplace_to_dense​

clika_rt_error*(* op_qlinear_inplace_to_dense)(clika_rt_qtensor *x, clika_rt_qtensor *weight, clika_rt_tensor *out, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation)

ClikaRT::ops::qlinear_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qlinear_; the _to_dense suffix names this form consumes x (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 7053

op_qlinear_inplace_to_quantized​

clika_rt_error*(* op_qlinear_inplace_to_quantized)(clika_rt_qtensor *x, clika_rt_qtensor *weight, clika_rt_qtensor *out, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation)

ClikaRT::ops::qlinear_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qlinear_; the _to_quantized suffix names this form consumes x (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 7037

op_qlinear_to_dense​

clika_rt_error*(* op_qlinear_to_dense)(clika_rt_qtensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qlinear <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qlinear; the _to_dense suffix names this form consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 7001

op_qlinear_to_quantized​

clika_rt_error*(* op_qlinear_to_quantized)(clika_rt_qtensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qlinear <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qlinear; the _to_quantized suffix names this form consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 7017

op_qlinear_woq​

clika_rt_error*(* op_qlinear_woq)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, clika_rt_qcompute_mode compute_mode, clika_rt_tensor **out)

ClikaRT::ops::qlinear_woq <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes weight (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, compute_mode=QComputeMode::ExactFP

Declared in clika_rt/clika_rt_core.h, line 7082

op_qlinear_woq_inplace​

clika_rt_error*(* op_qlinear_woq_inplace)(clika_rt_tensor *x, clika_rt_qtensor *weight, clika_rt_tensor *out, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, clika_rt_qcompute_mode compute_mode)

ClikaRT::ops::qlinear_woq_ <- ClikaRT/compute/q_tensor.h in-place op consumes x (contract §6) consumes weight (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, compute_mode=QComputeMode::ExactFP

Declared in clika_rt/clika_rt_core.h, line 7116

op_qmatmul_inplace_to_dense​

clika_rt_error*(* op_qmatmul_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, uint8_t transpose_a, uint8_t transpose_b)

ClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmatmul_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false

Declared in clika_rt/clika_rt_core.h, line 6962

op_qmatmul_inplace_to_dense_out_scale​

clika_rt_error*(* op_qmatmul_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, uint8_t transpose_a, uint8_t transpose_b)

ClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmatmul_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): out_quant_axis=-1, bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false

Declared in clika_rt/clika_rt_core.h, line 6982

op_qmatmul_inplace_to_quantized​

clika_rt_error*(* op_qmatmul_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_qtensor *out, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, uint8_t transpose_a, uint8_t transpose_b)

ClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmatmul_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false

Declared in clika_rt/clika_rt_core.h, line 6944

op_qmatmul_to_dense​

clika_rt_error*(* op_qmatmul_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, uint8_t transpose_a, uint8_t transpose_b, clika_rt_tensor **out)

ClikaRT::ops::qmatmul <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmatmul; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false

Declared in clika_rt/clika_rt_core.h, line 6904

op_qmatmul_to_quantized​

clika_rt_error*(* op_qmatmul_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, uint8_t transpose_a, uint8_t transpose_b, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qmatmul <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmatmul; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6922

op_qmatmul_woq​

clika_rt_error*(* op_qmatmul_woq)(clika_rt_tensor *a, clika_rt_qtensor *b, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, uint8_t transpose_a, uint8_t transpose_b, clika_rt_qcompute_mode compute_mode, clika_rt_tensor **out)

ClikaRT::ops::qmatmul_woq <- ClikaRT/compute/q_tensor.h consumes a (contract §6) consumes b (contract §6) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false, compute_mode=QComputeMode::ExactFP

Declared in clika_rt/clika_rt_core.h, line 7066

op_qmatmul_woq_inplace​

clika_rt_error*(* op_qmatmul_woq_inplace)(clika_rt_tensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_tensor *bias, uint8_t activation_has, clika_rt_activation activation, uint8_t transpose_a, uint8_t transpose_b, clika_rt_qcompute_mode compute_mode)

ClikaRT::ops::qmatmul_woq_ <- ClikaRT/compute/q_tensor.h in-place op consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) optional; NULL = absent; consumes bias when present (contract §6) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): bias={}, activation=std::nullopt, transpose_a=false, transpose_b=false, compute_mode=QComputeMode::ExactFP

Declared in clika_rt/clika_rt_core.h, line 7098

op_qmoe_to_dense​

clika_rt_error*(* op_qmoe_to_dense)(clika_rt_qtensor *input, clika_rt_tensor *router_logits, clika_rt_qtensor *fc1_experts, clika_rt_qtensor *fc2_experts, int64_t top_k, clika_rt_tensor *fc1_bias, clika_rt_tensor *fc2_bias, clika_rt_qtensor *fc3_experts, clika_rt_tensor *fc3_bias, clika_rt_tensor *e_score_correction_bias, clika_rt_tensor *router_weights, uint8_t routing_mode_has, clika_rt_moe_routing routing_mode, uint8_t renormalize_has, uint8_t renormalize, uint8_t n_group_has, int64_t n_group, uint8_t topk_group_has, int64_t topk_group, uint8_t routed_scaling_factor_has, double routed_scaling_factor, uint8_t sparse_mixer_eps_has, double sparse_mixer_eps, uint8_t apply_router_weight_on_input_has, uint8_t apply_router_weight_on_input, uint8_t activation_has, clika_rt_activation activation, uint8_t swiglu_fusion_has, clika_rt_swiglu_fusion swiglu_fusion, uint8_t swiglu_alpha_has, double swiglu_alpha, uint8_t swiglu_beta_has, double swiglu_beta, uint8_t swiglu_limit_has, double swiglu_limit, uint8_t gelu_mode_has, clika_rt_gelu_mode gelu_mode, clika_rt_tensor *shared_output, clika_rt_tensor **out)

ClikaRT::ops::qmoe <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmoe; the _to_dense suffix names this form consumes input (contract §6) consumes router_logits (contract §6) consumes fc1_experts (contract §6) consumes fc2_experts (contract §6) optional; NULL = absent; consumes fc1_bias when present (contract §6) optional; NULL = absent; consumes fc2_bias when present (contract §6) consumes fc3_experts (contract §6) optional; NULL = absent; consumes fc3_bias when present (contract §6) optional; NULL = absent; consumes e_score_correction_bias when present (contract §6) optional; NULL = absent; consumes router_weights when present (contract §6) routing_mode read only when routing_mode_has is nonzero (contract §9) renormalize read only when renormalize_has is nonzero (contract §9) n_group read only when n_group_has is nonzero (contract §9) topk_group read only when topk_group_has is nonzero (contract §9) routed_scaling_factor read only when routed_scaling_factor_has is nonzero (contract §9) sparse_mixer_eps read only when sparse_mixer_eps_has is nonzero (contract §9) apply_router_weight_on_input read only when apply_router_weight_on_input_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) swiglu_fusion read only when swiglu_fusion_has is nonzero (contract §9) swiglu_alpha read only when swiglu_alpha_has is nonzero (contract §9) swiglu_beta read only when swiglu_beta_has is nonzero (contract §9) swiglu_limit read only when swiglu_limit_has is nonzero (contract §9) gelu_mode read only when gelu_mode_has is nonzero (contract §9) optional; NULL = absent; consumes shared_output when present (contract §6) C++ defaults (dropped at this surface): fc1_bias={}, fc2_bias={}, fc3_experts={}, fc3_bias={}, e_score_correction_bias={}, router_weights={}, routing_mode=std::nullopt, renormalize=std::nullopt, n_group=std::nullopt, topk_group=std::nullopt, routed_scaling_factor=std::nullopt, sparse_mixer_eps=std::nullopt, apply_router_weight_on_input=std::nullopt, activation=std::nullopt, swiglu_fusion=std::nullopt, swiglu_alpha=std::nullopt, swiglu_beta=std::nullopt, swiglu_limit=std::nullopt, gelu_mode=std::nullopt, shared_output={}

Declared in clika_rt/clika_rt_core.h, line 7931

op_qmoe_to_quantized​

clika_rt_error*(* op_qmoe_to_quantized)(clika_rt_qtensor *input, clika_rt_tensor *router_logits, clika_rt_qtensor *fc1_experts, clika_rt_qtensor *fc2_experts, int64_t top_k, clika_rt_tensor *fc1_bias, clika_rt_tensor *fc2_bias, clika_rt_qtensor *fc3_experts, clika_rt_tensor *fc3_bias, clika_rt_tensor *e_score_correction_bias, clika_rt_tensor *router_weights, uint8_t routing_mode_has, clika_rt_moe_routing routing_mode, uint8_t renormalize_has, uint8_t renormalize, uint8_t n_group_has, int64_t n_group, uint8_t topk_group_has, int64_t topk_group, uint8_t routed_scaling_factor_has, double routed_scaling_factor, uint8_t sparse_mixer_eps_has, double sparse_mixer_eps, uint8_t apply_router_weight_on_input_has, uint8_t apply_router_weight_on_input, uint8_t activation_has, clika_rt_activation activation, uint8_t swiglu_fusion_has, clika_rt_swiglu_fusion swiglu_fusion, uint8_t swiglu_alpha_has, double swiglu_alpha, uint8_t swiglu_beta_has, double swiglu_beta, uint8_t swiglu_limit_has, double swiglu_limit, uint8_t gelu_mode_has, clika_rt_gelu_mode gelu_mode, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_tensor *shared_output, clika_rt_qtensor **out)

ClikaRT::ops::qmoe <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmoe; the _to_quantized suffix names this form consumes input (contract §6) consumes router_logits (contract §6) consumes fc1_experts (contract §6) consumes fc2_experts (contract §6) optional; NULL = absent; consumes fc1_bias when present (contract §6) optional; NULL = absent; consumes fc2_bias when present (contract §6) consumes fc3_experts (contract §6) optional; NULL = absent; consumes fc3_bias when present (contract §6) optional; NULL = absent; consumes e_score_correction_bias when present (contract §6) optional; NULL = absent; consumes router_weights when present (contract §6) routing_mode read only when routing_mode_has is nonzero (contract §9) renormalize read only when renormalize_has is nonzero (contract §9) n_group read only when n_group_has is nonzero (contract §9) topk_group read only when topk_group_has is nonzero (contract §9) routed_scaling_factor read only when routed_scaling_factor_has is nonzero (contract §9) sparse_mixer_eps read only when sparse_mixer_eps_has is nonzero (contract §9) apply_router_weight_on_input read only when apply_router_weight_on_input_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) swiglu_fusion read only when swiglu_fusion_has is nonzero (contract §9) swiglu_alpha read only when swiglu_alpha_has is nonzero (contract §9) swiglu_beta read only when swiglu_beta_has is nonzero (contract §9) swiglu_limit read only when swiglu_limit_has is nonzero (contract §9) gelu_mode read only when gelu_mode_has is nonzero (contract §9) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) optional; NULL = absent; consumes shared_output when present (contract §6) C++ defaults (dropped at this surface): out_quant_axis=-1, out_dtype=DataType::Undefined, shared_output={}

Declared in clika_rt/clika_rt_core.h, line 8000

op_qmoe_woq​

clika_rt_error*(* op_qmoe_woq)(clika_rt_tensor *input, clika_rt_tensor *router_logits, clika_rt_qtensor *fc1_experts, clika_rt_qtensor *fc2_experts, int64_t top_k, clika_rt_tensor *fc1_bias, clika_rt_tensor *fc2_bias, clika_rt_qtensor *fc3_experts, clika_rt_tensor *fc3_bias, clika_rt_tensor *e_score_correction_bias, clika_rt_tensor *router_weights, uint8_t routing_mode_has, clika_rt_moe_routing routing_mode, uint8_t renormalize_has, uint8_t renormalize, uint8_t n_group_has, int64_t n_group, uint8_t topk_group_has, int64_t topk_group, uint8_t routed_scaling_factor_has, double routed_scaling_factor, uint8_t sparse_mixer_eps_has, double sparse_mixer_eps, uint8_t apply_router_weight_on_input_has, uint8_t apply_router_weight_on_input, uint8_t activation_has, clika_rt_activation activation, uint8_t swiglu_fusion_has, clika_rt_swiglu_fusion swiglu_fusion, uint8_t swiglu_alpha_has, double swiglu_alpha, uint8_t swiglu_beta_has, double swiglu_beta, uint8_t swiglu_limit_has, double swiglu_limit, uint8_t gelu_mode_has, clika_rt_gelu_mode gelu_mode, clika_rt_tensor *shared_output, clika_rt_tensor **out)

ClikaRT::ops::qmoe_woq <- ClikaRT/compute/q_tensor.h consumes input (contract §6) consumes router_logits (contract §6) consumes fc1_experts (contract §6) consumes fc2_experts (contract §6) optional; NULL = absent; consumes fc1_bias when present (contract §6) optional; NULL = absent; consumes fc2_bias when present (contract §6) consumes fc3_experts (contract §6) optional; NULL = absent; consumes fc3_bias when present (contract §6) optional; NULL = absent; consumes e_score_correction_bias when present (contract §6) optional; NULL = absent; consumes router_weights when present (contract §6) routing_mode read only when routing_mode_has is nonzero (contract §9) renormalize read only when renormalize_has is nonzero (contract §9) n_group read only when n_group_has is nonzero (contract §9) topk_group read only when topk_group_has is nonzero (contract §9) routed_scaling_factor read only when routed_scaling_factor_has is nonzero (contract §9) sparse_mixer_eps read only when sparse_mixer_eps_has is nonzero (contract §9) apply_router_weight_on_input read only when apply_router_weight_on_input_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) swiglu_fusion read only when swiglu_fusion_has is nonzero (contract §9) swiglu_alpha read only when swiglu_alpha_has is nonzero (contract §9) swiglu_beta read only when swiglu_beta_has is nonzero (contract §9) swiglu_limit read only when swiglu_limit_has is nonzero (contract §9) gelu_mode read only when gelu_mode_has is nonzero (contract §9) optional; NULL = absent; consumes shared_output when present (contract §6) C++ defaults (dropped at this surface): fc1_bias={}, fc2_bias={}, fc3_experts={}, fc3_bias={}, e_score_correction_bias={}, router_weights={}, routing_mode=std::nullopt, renormalize=std::nullopt, n_group=std::nullopt, topk_group=std::nullopt, routed_scaling_factor=std::nullopt, sparse_mixer_eps=std::nullopt, apply_router_weight_on_input=std::nullopt, activation=std::nullopt, swiglu_fusion=std::nullopt, swiglu_alpha=std::nullopt, swiglu_beta=std::nullopt, swiglu_limit=std::nullopt, gelu_mode=std::nullopt, shared_output={}

Declared in clika_rt/clika_rt_core.h, line 8070

op_qmul_inplace_to_dense​

clika_rt_error*(* op_qmul_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_activation activation)

ClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmul_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6306

op_qmul_inplace_to_dense_out_scale​

clika_rt_error*(* op_qmul_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_activation activation)

ClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmul_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6320

op_qmul_inplace_to_quantized​

clika_rt_error*(* op_qmul_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_qtensor *out, clika_rt_activation activation)

ClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qmul_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6294

op_qmul_to_dense​

clika_rt_error*(* op_qmul_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qmul <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmul; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6266

op_qmul_to_quantized​

clika_rt_error*(* op_qmul_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_activation activation, clika_rt_qtensor **out)

ClikaRT::ops::qmul <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qmul; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6278

op_qquick_gelu_inplace_to_dense​

clika_rt_error*(* op_qquick_gelu_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_tensor *out)

ClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qquick_gelu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6678

op_qquick_gelu_inplace_to_dense_out_scale​

clika_rt_error*(* op_qquick_gelu_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qquick_gelu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 6689

op_qquick_gelu_inplace_to_quantized​

clika_rt_error*(* op_qquick_gelu_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *out)

ClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qquick_gelu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6670

op_qquick_gelu_to_dense​

clika_rt_error*(* op_qquick_gelu_to_dense)(clika_rt_qtensor *a, clika_rt_tensor **out)

ClikaRT::ops::qquick_gelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qquick_gelu; the _to_dense suffix names this form consumes a (contract §6)

Declared in clika_rt/clika_rt_core.h, line 6649

op_qquick_gelu_to_quantized​

clika_rt_error*(* op_qquick_gelu_to_quantized)(clika_rt_qtensor *a, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qquick_gelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qquick_gelu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6658

op_qrelu_inplace_to_dense​

clika_rt_error*(* op_qrelu_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_tensor *out)

ClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qrelu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6482

op_qrelu_inplace_to_dense_out_scale​

clika_rt_error*(* op_qrelu_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qrelu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 6493

op_qrelu_inplace_to_quantized​

clika_rt_error*(* op_qrelu_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *out)

ClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qrelu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6474

op_qrelu_to_dense​

clika_rt_error*(* op_qrelu_to_dense)(clika_rt_qtensor *a, clika_rt_tensor **out)

ClikaRT::ops::qrelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qrelu; the _to_dense suffix names this form consumes a (contract §6)

Declared in clika_rt/clika_rt_core.h, line 6453

op_qrelu_to_quantized​

clika_rt_error*(* op_qrelu_to_quantized)(clika_rt_qtensor *a, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qrelu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qrelu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6462

op_qsigmoid_inplace_to_dense​

clika_rt_error*(* op_qsigmoid_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_tensor *out)

ClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsigmoid_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6727

op_qsigmoid_inplace_to_dense_out_scale​

clika_rt_error*(* op_qsigmoid_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsigmoid_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 6738

op_qsigmoid_inplace_to_quantized​

clika_rt_error*(* op_qsigmoid_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *out)

ClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsigmoid_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6719

op_qsigmoid_to_dense​

clika_rt_error*(* op_qsigmoid_to_dense)(clika_rt_qtensor *a, clika_rt_tensor **out)

ClikaRT::ops::qsigmoid <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsigmoid; the _to_dense suffix names this form consumes a (contract §6)

Declared in clika_rt/clika_rt_core.h, line 6698

op_qsigmoid_to_quantized​

clika_rt_error*(* op_qsigmoid_to_quantized)(clika_rt_qtensor *a, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qsigmoid <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsigmoid; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6707

op_qsilu_inplace_to_dense​

clika_rt_error*(* op_qsilu_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_tensor *out)

ClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsilu_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6531

op_qsilu_inplace_to_dense_out_scale​

clika_rt_error*(* op_qsilu_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsilu_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 6542

op_qsilu_inplace_to_quantized​

clika_rt_error*(* op_qsilu_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *out)

ClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsilu_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6523

op_qsilu_to_dense​

clika_rt_error*(* op_qsilu_to_dense)(clika_rt_qtensor *a, clika_rt_tensor **out)

ClikaRT::ops::qsilu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsilu; the _to_dense suffix names this form consumes a (contract §6)

Declared in clika_rt/clika_rt_core.h, line 6502

op_qsilu_to_quantized​

clika_rt_error*(* op_qsilu_to_quantized)(clika_rt_qtensor *a, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qsilu <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsilu; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6511

op_qsub_inplace_to_dense​

clika_rt_error*(* op_qsub_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_activation activation)

ClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsub_; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6239

op_qsub_inplace_to_dense_out_scale​

clika_rt_error*(* op_qsub_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_activation activation)

ClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsub_; the _to_dense_out_scale suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6253

op_qsub_inplace_to_quantized​

clika_rt_error*(* op_qsub_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_qtensor *out, clika_rt_activation activation)

ClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qsub_; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) borrows out; written through (the in-place target) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6227

op_qsub_to_dense​

clika_rt_error*(* op_qsub_to_dense)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::qsub <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsub; the _to_dense suffix names this form consumes a (contract §6) consumes b (contract §6) C++ defaults (dropped at this surface): activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6199

op_qsub_to_quantized​

clika_rt_error*(* op_qsub_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *b, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_activation activation, clika_rt_qtensor **out)

ClikaRT::ops::qsub <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qsub; the _to_quantized suffix names this form consumes a (contract §6) consumes b (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 6211

op_qtanh_inplace_to_dense​

clika_rt_error*(* op_qtanh_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_tensor *out)

ClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qtanh_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6776

op_qtanh_inplace_to_dense_out_scale​

clika_rt_error*(* op_qtanh_inplace_to_dense_out_scale)(clika_rt_qtensor *a, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qtanh_; the _to_dense_out_scale suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 6787

op_qtanh_inplace_to_quantized​

clika_rt_error*(* op_qtanh_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *out)

ClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ qtanh_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6768

op_qtanh_to_dense​

clika_rt_error*(* op_qtanh_to_dense)(clika_rt_qtensor *a, clika_rt_tensor **out)

ClikaRT::ops::qtanh <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qtanh; the _to_dense suffix names this form consumes a (contract §6)

Declared in clika_rt/clika_rt_core.h, line 6747

op_qtanh_to_quantized​

clika_rt_error*(* op_qtanh_to_quantized)(clika_rt_qtensor *a, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::qtanh <- ClikaRT/compute/q_tensor.h one form of the overloaded C++ qtanh; the _to_quantized suffix names this form consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 6756

op_quantile​

clika_rt_error*(* op_quantile)(clika_rt_tensor *x, clika_rt_scalar_or_tensor q, uint8_t dim_has, int64_t dim, uint8_t keepdim, clika_rt_quantile_interp interpolation, clika_rt_tensor **out)

ClikaRT::ops::quantile <- ClikaRT/compute/ops.h consumes x (contract §6) q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt, keepdim=false, interpolation=QuantileInterp::Linear

Declared in clika_rt/clika_rt_core.h, line 5176

op_quantize​

clika_rt_error*(* op_quantize)(clika_rt_tensor *x, clika_rt_tensor *scale, clika_rt_tensor *zero_point, int64_t quant_axis, clika_rt_data_type out_dtype, int64_t block_size, clika_rt_qtensor **out)

ClikaRT::ops::quantize <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes scale (contract §6) optional; NULL = absent; consumes zero_point when present (contract §6) C++ defaults (dropped at this surface): zero_point={}, quant_axis=-1, out_dtype=DataType::Undefined, block_size=0

Declared in clika_rt/clika_rt_core.h, line 6072

op_quantize_dequantize​

clika_rt_error*(* op_quantize_dequantize)(clika_rt_tensor *x, clika_rt_tensor *scale, clika_rt_tensor *zero_point, int64_t quant_axis, clika_rt_data_type code_dtype, clika_rt_data_type out_dtype, int64_t block_size, clika_rt_tensor **out)

ClikaRT::ops::quantize_dequantize <- ClikaRT/compute/q_tensor.h consumes x (contract §6) consumes scale (contract §6) optional; NULL = absent; consumes zero_point when present (contract §6) C++ defaults (dropped at this surface): zero_point={}, quant_axis=-1, code_dtype=DataType::Undefined, out_dtype=DataType::Undefined, block_size=0

Declared in clika_rt/clika_rt_core.h, line 8157

op_quantize_inplace_to_dense​

clika_rt_error*(* op_quantize_inplace_to_dense)(clika_rt_tensor *x, clika_rt_tensor *out, clika_rt_tensor *scale, clika_rt_tensor *zero_point, int64_t quant_axis, int64_t block_size)

ClikaRT::ops::quantize_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ quantize_; the _to_dense suffix names this form consumes x (contract §6) borrows out; written through (the in-place target) consumes scale (contract §6) optional; NULL = absent; consumes zero_point when present (contract §6) C++ defaults (dropped at this surface): zero_point={}, quant_axis=-1, block_size=0

Declared in clika_rt/clika_rt_core.h, line 6096

op_quantize_inplace_to_quantized​

clika_rt_error*(* op_quantize_inplace_to_quantized)(clika_rt_tensor *x, clika_rt_qtensor *out)

ClikaRT::ops::quantize_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ quantize_; the _to_quantized suffix names this form consumes x (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 6085

op_quantize_to_scheme​

clika_rt_error*(* op_quantize_to_scheme)(clika_rt_tensor *x, const char *scheme, size_t scheme_len, clika_rt_tensor *scale, clika_rt_qtensor **out)

ClikaRT::ops::quantize_to_scheme <- ClikaRT/compute/q_tensor.h consumes x (contract §6) optional; NULL = absent; consumes scale when present (contract §6) C++ defaults (dropped at this surface): scale={}

Declared in clika_rt/clika_rt_core.h, line 6121

op_quick_gelu​

clika_rt_error*(* op_quick_gelu)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::quick_gelu <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 933

op_rad2deg​

clika_rt_error*(* op_rad2deg)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::rad2deg <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1808

op_rad2deg_inplace​

clika_rt_error*(* op_rad2deg_inplace)(clika_rt_tensor *self)

ClikaRT::ops::rad2deg_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1814

op_rand​

clika_rt_error*(* op_rand)(const clika_rt_scalar_or_tensor *shape, size_t shape_count, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::rand <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Float32, s={}

Declared in clika_rt/clika_rt_core.h, line 4731

op_rand_like​

clika_rt_error*(* op_rand_like)(clika_rt_tensor *reference, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::rand_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 4740

op_randint​

clika_rt_error*(* op_randint)(int64_t low, int64_t high, const clika_rt_scalar_or_tensor *shape, size_t shape_count, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::randint <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Int64, s={}

Declared in clika_rt/clika_rt_core.h, line 4747

op_randint_like​

clika_rt_error*(* op_randint_like)(clika_rt_tensor *reference, int64_t low, int64_t high, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::randint_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 4758

op_randn​

clika_rt_error*(* op_randn)(const clika_rt_scalar_or_tensor *shape, size_t shape_count, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::randn <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Float32, s={}

Declared in clika_rt/clika_rt_core.h, line 4767

op_randn_like​

clika_rt_error*(* op_randn_like)(clika_rt_tensor *reference, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::randn_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 4776

op_random_inplace​

clika_rt_error*(* op_random_inplace)(clika_rt_tensor *self, uint8_t low_has, int64_t low, uint8_t high_has, int64_t high, clika_rt_stream_or_device s)

ClikaRT::ops::random_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) low read only when low_has is nonzero (contract §9) high read only when high_has is nonzero (contract §9) C++ defaults (dropped at this surface): low=std::nullopt, high=std::nullopt, s={}

Declared in clika_rt/clika_rt_core.h, line 4803

op_randperm​

clika_rt_error*(* op_randperm)(clika_rt_scalar_or_tensor n, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::randperm <- ClikaRT/compute/ops.h n.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): dtype=DataType::Int64, s={}

Declared in clika_rt/clika_rt_core.h, line 4783

op_reciprocal​

clika_rt_error*(* op_reciprocal)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::reciprocal <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5570

op_reciprocal_inplace​

clika_rt_error*(* op_reciprocal_inplace)(clika_rt_tensor *self)

ClikaRT::ops::reciprocal_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5576

op_reflect_pad​

clika_rt_error*(* op_reflect_pad)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *pad, size_t pad_count, clika_rt_tensor **out)

ClikaRT::ops::reflect_pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3767

op_reglu​

clika_rt_error*(* op_reglu)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::reglu <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 914

op_relu​

clika_rt_error*(* op_relu)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::relu <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1065

op_relu6​

clika_rt_error*(* op_relu6)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::relu6 <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1075

op_relu6_inplace​

clika_rt_error*(* op_relu6_inplace)(clika_rt_tensor *self)

ClikaRT::ops::relu6_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1081

op_relu_inplace​

clika_rt_error*(* op_relu_inplace)(clika_rt_tensor *self)

ClikaRT::ops::relu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1071

op_remainder​

clika_rt_error*(* op_remainder)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::remainder <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1743

op_remainder_inplace​

clika_rt_error*(* op_remainder_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::remainder_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1751

op_renorm​

clika_rt_error*(* op_renorm)(clika_rt_tensor *x, clika_rt_scalar p, int64_t dim, clika_rt_scalar maxnorm, uint8_t eps_has, double eps, clika_rt_tensor **out)

ClikaRT::ops::renorm <- ClikaRT/compute/ops.h consumes x (contract §6) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4259

op_renorm_inplace​

clika_rt_error*(* op_renorm_inplace)(clika_rt_tensor *self, clika_rt_scalar p, int64_t dim, clika_rt_scalar maxnorm, uint8_t eps_has, double eps)

ClikaRT::ops::renorm_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) eps read only when eps_has is nonzero (contract §9) C++ defaults (dropped at this surface): eps=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4272

op_repeat​

clika_rt_error*(* op_repeat)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, clika_rt_tensor **out)

ClikaRT::ops::repeat <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3805

op_repeat_interleave​

clika_rt_error*(* op_repeat_interleave)(clika_rt_tensor *x, clika_rt_scalar_or_tensor repeats, uint8_t dim_has, int64_t dim, uint8_t output_size_has, int64_t output_size, clika_rt_tensor **out)

ClikaRT::ops::repeat_interleave <- ClikaRT/compute/ops.h consumes x (contract §6) repeats.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) dim read only when dim_has is nonzero (contract §9) output_size read only when output_size_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt, output_size=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3824

op_replicate_pad​

clika_rt_error*(* op_replicate_pad)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *pad, size_t pad_count, clika_rt_tensor **out)

ClikaRT::ops::replicate_pad <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3775

op_requantize​

clika_rt_error*(* op_requantize)(clika_rt_qtensor *a, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis, clika_rt_data_type out_dtype, clika_rt_qtensor **out)

ClikaRT::ops::requantize <- ClikaRT/compute/q_tensor.h consumes a (contract §6) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1, out_dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 8115

op_requantize_inplace_to_dense​

clika_rt_error*(* op_requantize_inplace_to_dense)(clika_rt_qtensor *a, clika_rt_tensor *out, clika_rt_tensor *out_scale, clika_rt_tensor *out_zero_point, int64_t out_quant_axis)

ClikaRT::ops::requantize_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ requantize_; the _to_dense suffix names this form consumes a (contract §6) borrows out; written through (the in-place target) consumes out_scale (contract §6) optional; NULL = absent; consumes out_zero_point when present (contract §6) C++ defaults (dropped at this surface): out_zero_point={}, out_quant_axis=-1

Declared in clika_rt/clika_rt_core.h, line 8138

op_requantize_inplace_to_quantized​

clika_rt_error*(* op_requantize_inplace_to_quantized)(clika_rt_qtensor *a, clika_rt_qtensor *out)

ClikaRT::ops::requantize_ <- ClikaRT/compute/q_tensor.h in-place op one form of the overloaded C++ requantize_; the _to_quantized suffix names this form consumes a (contract §6) borrows out; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 8127

op_resample​

clika_rt_error*(* op_resample)(clika_rt_tensor *x, int64_t orig_freq, int64_t new_freq, int64_t lowpass_filter_width, double rolloff, uint8_t beta_has, double beta, clika_rt_tensor **out)

ClikaRT::ops::resample <- ClikaRT/compute/ops.h consumes x (contract §6) beta read only when beta_has is nonzero (contract §9) C++ defaults (dropped at this surface): lowpass_filter_width=16, rolloff=0.945, beta=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3744

op_reshape​

clika_rt_error*(* op_reshape)(clika_rt_tensor *x, const clika_rt_index_bound *shape, size_t shape_count, clika_rt_tensor **out)

ClikaRT::ops::reshape <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 5719

op_reshape_as​

clika_rt_error*(* op_reshape_as)(clika_rt_tensor *x, clika_rt_tensor *other, clika_rt_tensor **out)

ClikaRT::ops::reshape_as <- ClikaRT/compute/ops.h consumes x (contract §6) consumes other (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3835

op_rfft​

clika_rt_error*(* op_rfft)(clika_rt_tensor *x, uint8_t n_fft_has, int64_t n_fft, uint8_t normalized, clika_rt_tensor **out)

ClikaRT::ops::rfft <- ClikaRT/compute/ops.h consumes x (contract §6) n_fft read only when n_fft_has is nonzero (contract §9) C++ defaults (dropped at this surface): n_fft=std::nullopt, normalized=false

Declared in clika_rt/clika_rt_core.h, line 3715

op_rms_norm​

clika_rt_error*(* op_rms_norm)(clika_rt_tensor *x, const int64_t *normalized_shape, size_t normalized_shape_count, clika_rt_tensor *weight, clika_rt_tensor *bias, uint8_t eps_has, double eps, uint8_t activation_has, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::rms_norm <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes weight when present (contract §6) optional; NULL = absent; consumes bias when present (contract §6) eps read only when eps_has is nonzero (contract §9) activation read only when activation_has is nonzero (contract §9) C++ defaults (dropped at this surface): weight={}, bias={}, eps=std::nullopt, activation=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 4286

op_roll​

clika_rt_error*(* op_roll)(clika_rt_tensor *x, const int64_t *shifts, size_t shifts_count, const int64_t *dims, size_t dims_count, clika_rt_tensor **out)

ClikaRT::ops::roll <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}

Declared in clika_rt/clika_rt_core.h, line 3842

op_rot90​

clika_rt_error*(* op_rot90)(clika_rt_tensor *x, int64_t k, const int64_t *dims, size_t dims_count, clika_rt_tensor **out)

ClikaRT::ops::rot90 <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): k=1, dims={0, 1}

Declared in clika_rt/clika_rt_core.h, line 3852

op_rotary_embedding​

clika_rt_error*(* op_rotary_embedding)(clika_rt_tensor *x0, clika_rt_tensor *position_ids, clika_rt_tensor *cos, clika_rt_tensor *sin, uint8_t mode_has, clika_rt_rotary_mode mode, uint8_t rotary_dim_has, int64_t rotary_dim, uint8_t theta_has, double theta, uint8_t scaling_has, clika_rt_rope_scaling scaling, uint8_t scale_has, double scale, uint8_t low_freq_factor_has, double low_freq_factor, uint8_t high_freq_factor_has, double high_freq_factor, uint8_t original_max_pos_has, int64_t original_max_pos, uint8_t beta_fast_has, double beta_fast, uint8_t beta_slow_has, double beta_slow, clika_rt_tensor *freq_factors, clika_rt_tensor **out)

ClikaRT::ops::rotary_embedding <- ClikaRT/compute/ops.h consumes x0 (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes cos when present (contract §6) optional; NULL = absent; consumes sin when present (contract §6) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) C++ defaults (dropped at this surface): position_ids={}, cos={}, sin={}, mode=std::nullopt, rotary_dim=std::nullopt, theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}

Declared in clika_rt/clika_rt_core.h, line 2520

op_rotary_embedding_qk​

clika_rt_error*(* op_rotary_embedding_qk)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *position_ids, clika_rt_tensor *cos, clika_rt_tensor *sin, uint8_t mode_has, clika_rt_rotary_mode mode, uint8_t rotary_dim_has, int64_t rotary_dim, uint8_t theta_has, double theta, uint8_t scaling_has, clika_rt_rope_scaling scaling, uint8_t scale_has, double scale, uint8_t low_freq_factor_has, double low_freq_factor, uint8_t high_freq_factor_has, double high_freq_factor, uint8_t original_max_pos_has, int64_t original_max_pos, uint8_t beta_fast_has, double beta_fast, uint8_t beta_slow_has, double beta_slow, clika_rt_tensor *freq_factors, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::rotary_embedding_qk <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes cos when present (contract §6) optional; NULL = absent; consumes sin when present (contract §6) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): position_ids={}, cos={}, sin={}, mode=std::nullopt, rotary_dim=std::nullopt, theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}

Declared in clika_rt/clika_rt_core.h, line 2566

op_rotary_embedding_qk_varlen​

clika_rt_error*(* op_rotary_embedding_qk_varlen)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *cu_seqlens, clika_rt_tensor *seqlens, clika_rt_tensor *position_ids, clika_rt_tensor *cos, clika_rt_tensor *sin, uint8_t mode_has, clika_rt_rotary_mode mode, uint8_t rotary_dim_has, int64_t rotary_dim, uint8_t theta_has, double theta, uint8_t scaling_has, clika_rt_rope_scaling scaling, uint8_t scale_has, double scale, uint8_t low_freq_factor_has, double low_freq_factor, uint8_t high_freq_factor_has, double high_freq_factor, uint8_t original_max_pos_has, int64_t original_max_pos, uint8_t beta_fast_has, double beta_fast, uint8_t beta_slow_has, double beta_slow, clika_rt_tensor *freq_factors, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::rotary_embedding_qk_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes cu_seqlens (contract §6) optional; NULL = absent; consumes seqlens when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes cos when present (contract §6) optional; NULL = absent; consumes sin when present (contract §6) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): seqlens={}, position_ids={}, cos={}, sin={}, mode=std::nullopt, rotary_dim=std::nullopt, theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}

Declared in clika_rt/clika_rt_core.h, line 2664

op_rotary_embedding_varlen​

clika_rt_error*(* op_rotary_embedding_varlen)(clika_rt_tensor *x0, clika_rt_tensor *cu_seqlens, clika_rt_tensor *seqlens, clika_rt_tensor *position_ids, clika_rt_tensor *cos, clika_rt_tensor *sin, uint8_t mode_has, clika_rt_rotary_mode mode, uint8_t rotary_dim_has, int64_t rotary_dim, uint8_t theta_has, double theta, uint8_t scaling_has, clika_rt_rope_scaling scaling, uint8_t scale_has, double scale, uint8_t low_freq_factor_has, double low_freq_factor, uint8_t high_freq_factor_has, double high_freq_factor, uint8_t original_max_pos_has, int64_t original_max_pos, uint8_t beta_fast_has, double beta_fast, uint8_t beta_slow_has, double beta_slow, clika_rt_tensor *freq_factors, clika_rt_tensor **out)

ClikaRT::ops::rotary_embedding_varlen <- ClikaRT/compute/ops.h consumes x0 (contract §6) consumes cu_seqlens (contract §6) optional; NULL = absent; consumes seqlens when present (contract §6) optional; NULL = absent; consumes position_ids when present (contract §6) optional; NULL = absent; consumes cos when present (contract §6) optional; NULL = absent; consumes sin when present (contract §6) mode read only when mode_has is nonzero (contract §9) rotary_dim read only when rotary_dim_has is nonzero (contract §9) theta read only when theta_has is nonzero (contract §9) scaling read only when scaling_has is nonzero (contract §9) scale read only when scale_has is nonzero (contract §9) low_freq_factor read only when low_freq_factor_has is nonzero (contract §9) high_freq_factor read only when high_freq_factor_has is nonzero (contract §9) original_max_pos read only when original_max_pos_has is nonzero (contract §9) beta_fast read only when beta_fast_has is nonzero (contract §9) beta_slow read only when beta_slow_has is nonzero (contract §9) optional; NULL = absent; consumes freq_factors when present (contract §6) C++ defaults (dropped at this surface): seqlens={}, position_ids={}, cos={}, sin={}, mode=std::nullopt, rotary_dim=std::nullopt, theta=std::nullopt, scaling=std::nullopt, scale=std::nullopt, low_freq_factor=std::nullopt, high_freq_factor=std::nullopt, original_max_pos=std::nullopt, beta_fast=std::nullopt, beta_slow=std::nullopt, freq_factors={}

Declared in clika_rt/clika_rt_core.h, line 2614

op_round​

clika_rt_error*(* op_round)(clika_rt_tensor *x, int64_t decimals, clika_rt_tensor **out)

ClikaRT::ops::round <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): decimals=0

Declared in clika_rt/clika_rt_core.h, line 5581

op_round_inplace​

clika_rt_error*(* op_round_inplace)(clika_rt_tensor *self, int64_t decimals)

ClikaRT::ops::round_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): decimals=0

Declared in clika_rt/clika_rt_core.h, line 5589

op_rsqrt​

clika_rt_error*(* op_rsqrt)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::rsqrt <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5594

op_rsqrt_inplace​

clika_rt_error*(* op_rsqrt_inplace)(clika_rt_tensor *self)

ClikaRT::ops::rsqrt_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5600

op_scaled_dot_product_attention​

clika_rt_error*(* op_scaled_dot_product_attention)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *attn_mask, uint8_t is_causal, clika_rt_scalar_or_tensor q_scale, clika_rt_scalar_or_tensor k_scale, clika_rt_scalar_or_tensor v_scale, clika_rt_tensor **out)

ClikaRT::ops::scaled_dot_product_attention <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) optional; NULL = absent; consumes attn_mask when present (contract §6) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): attn_mask={}, is_causal=false, q_scale={}, k_scale={}, v_scale={}

Declared in clika_rt/clika_rt_core.h, line 1227

op_scaled_dot_product_attention_varlen​

clika_rt_error*(* op_scaled_dot_product_attention_varlen)(clika_rt_tensor *q, clika_rt_tensor *k, clika_rt_tensor *v, clika_rt_tensor *cu_seqlens_q, clika_rt_tensor *cu_seqlens_k, clika_rt_scalar_or_tensor max_seqlen_q, clika_rt_scalar_or_tensor max_seqlen_k, clika_rt_tensor *attn_mask, uint8_t is_causal, clika_rt_scalar_or_tensor q_scale, clika_rt_scalar_or_tensor k_scale, clika_rt_scalar_or_tensor v_scale, clika_rt_tensor **out)

ClikaRT::ops::scaled_dot_product_attention_varlen <- ClikaRT/compute/ops.h consumes q (contract §6) consumes k (contract §6) consumes v (contract §6) consumes cu_seqlens_q (contract §6) consumes cu_seqlens_k (contract §6) max_seqlen_q.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) max_seqlen_k.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) optional; NULL = absent; consumes attn_mask when present (contract §6) q_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) k_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) v_scale.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): max_seqlen_q={}, max_seqlen_k={}, attn_mask={}, is_causal=false, q_scale={}, k_scale={}, v_scale={}

Declared in clika_rt/clika_rt_core.h, line 1250

op_scatter​

clika_rt_error*(* op_scatter)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor *index, clika_rt_scalar_or_tensor src, clika_rt_tensor **out)

ClikaRT::ops::scatter <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) src.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3127

op_scatter_add​

clika_rt_error*(* op_scatter_add)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor *index, clika_rt_tensor *src, uint8_t deterministic, clika_rt_tensor **out)

ClikaRT::ops::scatter_add <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) consumes src (contract §6) C++ defaults (dropped at this surface): deterministic=false

Declared in clika_rt/clika_rt_core.h, line 3148

op_scatter_add_inplace​

clika_rt_error*(* op_scatter_add_inplace)(clika_rt_tensor *self, int64_t dim, clika_rt_tensor *index, clika_rt_tensor *src, uint8_t deterministic)

ClikaRT::ops::scatter_add_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes index (contract §6) consumes src (contract §6) C++ defaults (dropped at this surface): deterministic=false

Declared in clika_rt/clika_rt_core.h, line 3161

op_scatter_inplace​

clika_rt_error*(* op_scatter_inplace)(clika_rt_tensor *self, int64_t dim, clika_rt_tensor *index, clika_rt_scalar_or_tensor src)

ClikaRT::ops::scatter_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes index (contract §6) src.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3138

op_scatter_reduce​

clika_rt_error*(* op_scatter_reduce)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor *index, clika_rt_tensor *src, clika_rt_scatter_reduce_mode reduce, uint8_t include_self, uint8_t deterministic, clika_rt_tensor **out)

ClikaRT::ops::scatter_reduce <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) consumes src (contract §6) C++ defaults (dropped at this surface): include_self=true, deterministic=false

Declared in clika_rt/clika_rt_core.h, line 3172

op_scatter_reduce_inplace​

clika_rt_error*(* op_scatter_reduce_inplace)(clika_rt_tensor *self, int64_t dim, clika_rt_tensor *index, clika_rt_tensor *src, clika_rt_scatter_reduce_mode reduce, uint8_t include_self, uint8_t deterministic)

ClikaRT::ops::scatter_reduce_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) consumes index (contract §6) consumes src (contract §6) C++ defaults (dropped at this surface): include_self=true, deterministic=false

Declared in clika_rt/clika_rt_core.h, line 3187

op_searchsorted​

clika_rt_error*(* op_searchsorted)(clika_rt_tensor *sorted_sequence, clika_rt_tensor *values, uint8_t out_int32, uint8_t right, uint8_t side_has, uint8_t side, clika_rt_tensor *sorter, clika_rt_tensor **out)

ClikaRT::ops::searchsorted <- ClikaRT/compute/ops.h consumes sorted_sequence (contract §6) consumes values (contract §6) side read only when side_has is nonzero (contract §9) optional; NULL = absent; consumes sorter when present (contract §6) C++ defaults (dropped at this surface): out_int32=false, right=false, side=std::nullopt, sorter={}

Declared in clika_rt/clika_rt_core.h, line 5190

op_select​

clika_rt_error*(* op_select)(clika_rt_tensor *x, int64_t dim, clika_rt_index_bound index, clika_rt_tensor **out)

ClikaRT::ops::select <- ClikaRT/compute/ops.h consumes x (contract §6) an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3861

op_selu​

clika_rt_error*(* op_selu)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::selu <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 883

op_selu_inplace​

clika_rt_error*(* op_selu_inplace)(clika_rt_tensor *self)

ClikaRT::ops::selu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 889

op_sgn​

clika_rt_error*(* op_sgn)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::sgn <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5604

op_sgn_inplace​

clika_rt_error*(* op_sgn_inplace)(clika_rt_tensor *self)

ClikaRT::ops::sgn_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5610

op_shape_dim​

clika_rt_error*(* op_shape_dim)(clika_rt_tensor *x, uint8_t dim_has, int64_t dim, clika_rt_tensor **out)

ClikaRT::ops::shape <- ClikaRT/compute/ops.h one form of the overloaded C++ shape; the _dim suffix names this form consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 3577

op_shape_host_all​

clika_rt_error*(* op_shape_host_all)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::shape_host <- ClikaRT/compute/ops.h one form of the overloaded C++ shape_host; the _all suffix names this form consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5727

op_shape_host_dim​

clika_rt_error*(* op_shape_host_dim)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor **out)

ClikaRT::ops::shape_host <- ClikaRT/compute/ops.h one form of the overloaded C++ shape_host; the _dim suffix names this form consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5733

op_shape_host_range​

clika_rt_error*(* op_shape_host_range)(clika_rt_tensor *x, uint8_t start_has, int64_t start, uint8_t end_has, int64_t end, clika_rt_tensor **out)

ClikaRT::ops::shape_host <- ClikaRT/compute/ops.h one form of the overloaded C++ shape_host; the _range suffix names this form consumes x (contract §6) start read only when start_has is nonzero (contract §9) end read only when end_has is nonzero (contract §9)

Declared in clika_rt/clika_rt_core.h, line 5742

op_shape_range​

clika_rt_error*(* op_shape_range)(clika_rt_tensor *x, uint8_t start_has, int64_t start, uint8_t end_has, int64_t end, clika_rt_tensor **out)

ClikaRT::ops::shape <- ClikaRT/compute/ops.h one form of the overloaded C++ shape; the _range suffix names this form consumes x (contract §6) start read only when start_has is nonzero (contract §9) end read only when end_has is nonzero (contract §9)

Declared in clika_rt/clika_rt_core.h, line 3587

op_sigmoid​

clika_rt_error*(* op_sigmoid)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::sigmoid <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1085

op_sigmoid_inplace​

clika_rt_error*(* op_sigmoid_inplace)(clika_rt_tensor *self)

ClikaRT::ops::sigmoid_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1091

op_sign​

clika_rt_error*(* op_sign)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::sign <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5614

op_sign_inplace​

clika_rt_error*(* op_sign_inplace)(clika_rt_tensor *self)

ClikaRT::ops::sign_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5620

op_silu​

clika_rt_error*(* op_silu)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::silu <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1095

op_silu_inplace​

clika_rt_error*(* op_silu_inplace)(clika_rt_tensor *self)

ClikaRT::ops::silu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1101

op_sin​

clika_rt_error*(* op_sin)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::sin <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5624

op_sin_inplace​

clika_rt_error*(* op_sin_inplace)(clika_rt_tensor *self)

ClikaRT::ops::sin_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5630

op_sinc​

clika_rt_error*(* op_sinc)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::sinc <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5634

op_sinc_inplace​

clika_rt_error*(* op_sinc_inplace)(clika_rt_tensor *self)

ClikaRT::ops::sinc_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5640

op_sinh​

clika_rt_error*(* op_sinh)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::sinh <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5644

op_sinh_inplace​

clika_rt_error*(* op_sinh_inplace)(clika_rt_tensor *self)

ClikaRT::ops::sinh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5650

op_slice_dim​

clika_rt_error*(* op_slice_dim)(clika_rt_tensor *x, int64_t dim, clika_rt_index_bound start, clika_rt_index_bound end, clika_rt_index_bound step, clika_rt_tensor **out)

ClikaRT::ops::slice <- ClikaRT/compute/ops.h one form of the overloaded C++ slice; the _dim suffix names this form consumes x (contract §6) an embedded tensor is BORROWED (contract §11) an embedded tensor is BORROWED (contract §11) an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): start={}, end={}, step=1

Declared in clika_rt/clika_rt_core.h, line 3873

op_slice_dims​

clika_rt_error*(* op_slice_dims)(clika_rt_tensor *x, const int64_t *dim, size_t dim_count, const clika_rt_index_bound *start, size_t start_count, const clika_rt_index_bound *end, size_t end_count, const clika_rt_index_bound *step, size_t step_count, clika_rt_tensor **out)

ClikaRT::ops::slice <- ClikaRT/compute/ops.h one form of the overloaded C++ slice; the _dims suffix names this form consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): start={}, end={}, step={}

Declared in clika_rt/clika_rt_core.h, line 3887

op_smooth_l1_loss​

clika_rt_error*(* op_smooth_l1_loss)(clika_rt_tensor *input, clika_rt_tensor *target, clika_rt_reduction reduction, double beta, clika_rt_tensor **out)

ClikaRT::ops::smooth_l1_loss <- ClikaRT/compute/ops.h consumes input (contract §6) consumes target (contract §6) C++ defaults (dropped at this surface): reduction=Reduction::Mean, beta=1.0

Declared in clika_rt/clika_rt_core.h, line 3556

op_snake​

clika_rt_error*(* op_snake)(clika_rt_tensor *x, clika_rt_tensor *alpha, clika_rt_tensor *beta, double eps, clika_rt_tensor **out)

ClikaRT::ops::snake <- ClikaRT/compute/ops.h consumes x (contract §6) optional; NULL = absent; consumes alpha when present (contract §6) optional; NULL = absent; consumes beta when present (contract §6) C++ defaults (dropped at this surface): alpha={}, beta={}, eps=1e-9

Declared in clika_rt/clika_rt_core.h, line 1108

op_snake_inplace​

clika_rt_error*(* op_snake_inplace)(clika_rt_tensor *self, clika_rt_tensor *alpha, clika_rt_tensor *beta, double eps)

ClikaRT::ops::snake_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) optional; NULL = absent; consumes alpha when present (contract §6) optional; NULL = absent; consumes beta when present (contract §6) C++ defaults (dropped at this surface): alpha={}, beta={}, eps=1e-9

Declared in clika_rt/clika_rt_core.h, line 1120

op_softcap_logits​

clika_rt_error*(* op_softcap_logits)(clika_rt_tensor *x, clika_rt_scalar_or_tensor cap, clika_rt_tensor **out)

ClikaRT::ops::softcap_logits <- ClikaRT/compute/ops.h consumes x (contract §6) cap.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 5695

op_softcap_logits_inplace​

clika_rt_error*(* op_softcap_logits_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor cap)

ClikaRT::ops::softcap_logits_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) cap.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 5703

op_softmax​

clika_rt_error*(* op_softmax)(clika_rt_tensor *x, int64_t dim, clika_rt_data_type dtype, clika_rt_tensor **out)

ClikaRT::ops::softmax <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1, dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 1128

op_softmax_inplace​

clika_rt_error*(* op_softmax_inplace)(clika_rt_tensor *self, int64_t dim)

ClikaRT::ops::softmax_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dim=-1

Declared in clika_rt/clika_rt_core.h, line 1137

op_softmin​

clika_rt_error*(* op_softmin)(clika_rt_tensor *x, int64_t dim, clika_rt_data_type dtype, clika_rt_tensor **out)

ClikaRT::ops::softmin <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=-1, dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 1143

op_softmin_inplace​

clika_rt_error*(* op_softmin_inplace)(clika_rt_tensor *self, int64_t dim)

ClikaRT::ops::softmin_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dim=-1

Declared in clika_rt/clika_rt_core.h, line 1152

op_softplus​

clika_rt_error*(* op_softplus)(clika_rt_tensor *x, double beta, double threshold, clika_rt_tensor **out)

ClikaRT::ops::softplus <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): beta=1.0, threshold=20.0

Declared in clika_rt/clika_rt_core.h, line 1158

op_softplus_inplace​

clika_rt_error*(* op_softplus_inplace)(clika_rt_tensor *self, double beta, double threshold)

ClikaRT::ops::softplus_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): beta=1.0, threshold=20.0

Declared in clika_rt/clika_rt_core.h, line 1167

op_softshrink​

clika_rt_error*(* op_softshrink)(clika_rt_tensor *x, double lambd, clika_rt_tensor **out)

ClikaRT::ops::softshrink <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): lambd=0.5

Declared in clika_rt/clika_rt_core.h, line 1174

op_softshrink_inplace​

clika_rt_error*(* op_softshrink_inplace)(clika_rt_tensor *self, double lambd)

ClikaRT::ops::softshrink_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): lambd=0.5

Declared in clika_rt/clika_rt_core.h, line 1182

op_softsign​

clika_rt_error*(* op_softsign)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::softsign <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1187

op_softsign_inplace​

clika_rt_error*(* op_softsign_inplace)(clika_rt_tensor *self)

ClikaRT::ops::softsign_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1193

op_sort​

clika_rt_error*(* op_sort)(clika_rt_tensor *x, int64_t dim, uint8_t descending, uint8_t stable, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::sort <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=-1, descending=false, stable=false

Declared in clika_rt/clika_rt_core.h, line 5910

op_split_by_size​

clika_rt_error*(* op_split_by_size)(clika_rt_tensor *x, int64_t chunk_size, int64_t dim, clika_rt_tensor_list **out)

ClikaRT::ops::split_by_size <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim=0

Declared in clika_rt/clika_rt_core.h, line 3929

op_split_with_sizes​

clika_rt_error*(* op_split_with_sizes)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, int64_t dim, clika_rt_tensor_list **out)

ClikaRT::ops::split_with_sizes <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): dim=0

Declared in clika_rt/clika_rt_core.h, line 3912

op_sqrt​

clika_rt_error*(* op_sqrt)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::sqrt <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5654

op_sqrt_inplace​

clika_rt_error*(* op_sqrt_inplace)(clika_rt_tensor *self)

ClikaRT::ops::sqrt_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5660

op_square​

clika_rt_error*(* op_square)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::square <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5664

op_square_inplace​

clika_rt_error*(* op_square_inplace)(clika_rt_tensor *self)

ClikaRT::ops::square_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5670

op_squeeze​

clika_rt_error*(* op_squeeze)(clika_rt_tensor *x, const int64_t *dim, size_t dim_count, clika_rt_tensor **out)

ClikaRT::ops::squeeze <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dim={}

Declared in clika_rt/clika_rt_core.h, line 3945

op_squeeze_inplace​

clika_rt_error*(* op_squeeze_inplace)(clika_rt_tensor *self, const int64_t *dim, size_t dim_count)

ClikaRT::ops::squeeze_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): dim={}

Declared in clika_rt/clika_rt_core.h, line 3954

op_ssd_update​

clika_rt_error*(* op_ssd_update)(clika_rt_tensor *x, clika_rt_tensor *dt, clika_rt_tensor *a_rate, clika_rt_tensor *b_mat, clika_rt_tensor *c_mat, clika_rt_tensor *d_skip, clika_rt_tensor *dt_bias, clika_rt_tensor *z, clika_rt_tensor *state, clika_rt_tensor *seq_lens, clika_rt_tensor *slot_ids, uint8_t dt_softplus, clika_rt_tensor **out)

ClikaRT::ops::ssd_update <- ClikaRT/compute/ops.h consumes x (contract §6) consumes dt (contract §6) consumes a_rate (contract §6) consumes b_mat (contract §6) consumes c_mat (contract §6) optional; NULL = absent; consumes d_skip when present (contract §6) optional; NULL = absent; consumes dt_bias when present (contract §6) optional; NULL = absent; consumes z when present (contract §6) consumes state (contract §6) optional; NULL = absent; consumes seq_lens when present (contract §6) optional; NULL = absent; consumes slot_ids when present (contract §6) C++ defaults (dropped at this surface): seq_lens={}, slot_ids={}, dt_softplus=false

Declared in clika_rt/clika_rt_core.h, line 4371

op_stack​

clika_rt_error*(* op_stack)(clika_rt_tensor *const *tensors, size_t tensors_count, int64_t dim, clika_rt_tensor **out)

ClikaRT::ops::stack <- ClikaRT/compute/ops.h elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): dim=0

Declared in clika_rt/clika_rt_core.h, line 3961

op_std​

clika_rt_error*(* op_std)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, int64_t correction, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::std <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, correction=1, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 5030

op_stft​

clika_rt_error*(* op_stft)(clika_rt_tensor *x, int64_t n_fft, uint8_t hop_length_has, int64_t hop_length, uint8_t win_length_has, int64_t win_length, clika_rt_tensor *window, uint8_t center, clika_rt_pad_mode pad_mode, uint8_t normalized, uint8_t onesided, clika_rt_tensor **out)

ClikaRT::ops::stft <- ClikaRT/compute/ops.h consumes x (contract §6) hop_length read only when hop_length_has is nonzero (contract §9) win_length read only when win_length_has is nonzero (contract §9) optional; NULL = absent; consumes window when present (contract §6) C++ defaults (dropped at this surface): hop_length=std::nullopt, win_length=std::nullopt, window={}, center=true, pad_mode=PadMode::Reflect, normalized=false, onesided=true

Declared in clika_rt/clika_rt_core.h, line 3727

op_sub_inplace​

clika_rt_error*(* op_sub_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other, double alpha, clika_rt_activation activation)

ClikaRT::ops::sub_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1856

op_sub_scalar_lhs​

clika_rt_error*(* op_sub_scalar_lhs)(clika_rt_scalar a, clika_rt_tensor *b, double alpha, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::sub <- ClikaRT/compute/ops.h one form of the overloaded C++ sub; the _scalar_lhs suffix names this form consumes b (contract §6) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1845

op_sub_tensor​

clika_rt_error*(* op_sub_tensor)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, double alpha, clika_rt_activation activation, clika_rt_tensor **out)

ClikaRT::ops::sub <- ClikaRT/compute/ops.h one form of the overloaded C++ sub; the _tensor suffix names this form consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11) C++ defaults (dropped at this surface): alpha=1.0, activation=Activation::Identity

Declared in clika_rt/clika_rt_core.h, line 1835

op_sum​

clika_rt_error*(* op_sum)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, uint8_t keepdim, clika_rt_data_type dtype, clika_rt_tensor **out)

ClikaRT::ops::sum <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, keepdim=false, dtype=DataType::Undefined

Declared in clika_rt/clika_rt_core.h, line 5040

op_swiglu​

clika_rt_error*(* op_swiglu)(clika_rt_tensor *x, double alpha, double beta, double limit, clika_rt_tensor **out)

ClikaRT::ops::swiglu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): alpha=1.0, beta=0.0, limit=std::numeric_limits<double>::infinity()

Declared in clika_rt/clika_rt_core.h, line 1198

op_synchronize_all​

clika_rt_error*(* op_synchronize_all)(void)

ClikaRT::ops::synchronize_all <- ClikaRT/compute/ops.h the underlying call is infallible plain void

Declared in clika_rt/clika_rt_core.h, line 861

op_take​

clika_rt_error*(* op_take)(clika_rt_tensor *self, clika_rt_tensor *index, clika_rt_tensor **out)

ClikaRT::ops::take <- ClikaRT/compute/ops.h consumes self (contract §6) consumes index (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2981

op_take_along_dim​

clika_rt_error*(* op_take_along_dim)(clika_rt_tensor *x, clika_rt_tensor *index, uint8_t dim_has, int64_t dim, clika_rt_tensor **out)

ClikaRT::ops::take_along_dim <- ClikaRT/compute/ops.h consumes x (contract §6) consumes index (contract §6) dim read only when dim_has is nonzero (contract §9) C++ defaults (dropped at this surface): dim=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 2972

op_tan​

clika_rt_error*(* op_tan)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::tan <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5674

op_tan_inplace​

clika_rt_error*(* op_tan_inplace)(clika_rt_tensor *self)

ClikaRT::ops::tan_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5680

op_tanh​

clika_rt_error*(* op_tanh)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::tanh <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5684

op_tanh_inplace​

clika_rt_error*(* op_tanh_inplace)(clika_rt_tensor *self)

ClikaRT::ops::tanh_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5690

op_tensordot​

clika_rt_error*(* op_tensordot)(clika_rt_tensor *a, clika_rt_tensor *b, const int64_t *dims_a, size_t dims_a_count, const int64_t *dims_b, size_t dims_b_count, clika_rt_tensor **out)

ClikaRT::ops::tensordot <- ClikaRT/compute/ops.h consumes a (contract §6) consumes b (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3454

op_threshold​

clika_rt_error*(* op_threshold)(clika_rt_tensor *x, double threshold, double value, clika_rt_tensor **out)

ClikaRT::ops::threshold <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 1206

op_threshold_inplace​

clika_rt_error*(* op_threshold_inplace)(clika_rt_tensor *self, double threshold, double value)

ClikaRT::ops::threshold_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 1214

op_tile​

clika_rt_error*(* op_tile)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *dims, size_t dims_count, clika_rt_tensor **out)

ClikaRT::ops::tile <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 3813

op_to_device_str​

clika_rt_error*(* op_to_device_str)(clika_rt_tensor *src, const char *device_str, size_t device_str_len, clika_rt_tensor **out)

ClikaRT::ops::to <- ClikaRT/compute/ops.h one form of the overloaded C++ to; the _device_str suffix names this form consumes src (contract §6)

Declared in clika_rt/clika_rt_core.h, line 2434

op_to_many​

clika_rt_error*(* op_to_many)(clika_rt_tensor *const *tensors, size_t tensors_count, clika_rt_stream_or_device target, clika_rt_tensor_list **out)

ClikaRT::ops::to <- ClikaRT/compute/ops.h one form of the overloaded C++ to; the _many suffix names this form elements of tensors BORROWED; whether §6 reaches through spans needs a ruling (draft) C++ defaults (dropped at this surface): target={}

Declared in clika_rt/clika_rt_core.h, line 2426

op_to_tensor​

clika_rt_error*(* op_to_tensor)(clika_rt_tensor *src, clika_rt_stream_or_device target, clika_rt_tensor **out)

ClikaRT::ops::to <- ClikaRT/compute/ops.h one form of the overloaded C++ to; the _tensor suffix names this form consumes src (contract §6) C++ defaults (dropped at this surface): target={}

Declared in clika_rt/clika_rt_core.h, line 2418

op_topk​

clika_rt_error*(* op_topk)(clika_rt_tensor *x, int64_t k, int64_t dim, uint8_t largest, uint8_t sorted, clika_rt_tensor **out0, clika_rt_tensor **out1)

ClikaRT::ops::topk <- ClikaRT/compute/ops.h consumes x (contract §6) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): dim=-1, largest=true, sorted=true

Declared in clika_rt/clika_rt_core.h, line 5203

op_trace​

clika_rt_error*(* op_trace)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::trace <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5049

op_transpose​

clika_rt_error*(* op_transpose)(clika_rt_tensor *x, int64_t dim0, int64_t dim1, clika_rt_tensor **out)

ClikaRT::ops::transpose <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3797

op_tril​

clika_rt_error*(* op_tril)(clika_rt_tensor *x, int64_t diagonal, clika_rt_tensor **out)

ClikaRT::ops::tril <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): diagonal=0

Declared in clika_rt/clika_rt_core.h, line 3969

op_tril_inplace​

clika_rt_error*(* op_tril_inplace)(clika_rt_tensor *self, int64_t diagonal)

ClikaRT::ops::tril_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): diagonal=0

Declared in clika_rt/clika_rt_core.h, line 3977

op_triu​

clika_rt_error*(* op_triu)(clika_rt_tensor *x, int64_t diagonal, clika_rt_tensor **out)

ClikaRT::ops::triu <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): diagonal=0

Declared in clika_rt/clika_rt_core.h, line 3983

op_triu_inplace​

clika_rt_error*(* op_triu_inplace)(clika_rt_tensor *self, int64_t diagonal)

ClikaRT::ops::triu_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): diagonal=0

Declared in clika_rt/clika_rt_core.h, line 3991

op_trunc​

clika_rt_error*(* op_trunc)(clika_rt_tensor *x, clika_rt_tensor **out)

ClikaRT::ops::trunc <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 5708

op_trunc_inplace​

clika_rt_error*(* op_trunc_inplace)(clika_rt_tensor *self)

ClikaRT::ops::trunc_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 5714

op_unflatten​

clika_rt_error*(* op_unflatten)(clika_rt_tensor *x, int64_t dim, const int64_t *sizes, size_t sizes_count, clika_rt_tensor **out)

ClikaRT::ops::unflatten <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3996

op_unfold​

clika_rt_error*(* op_unfold)(clika_rt_tensor *x, const int64_t *kernel_size, size_t kernel_size_count, const int64_t *dilation, size_t dilation_count, const int64_t *padding, size_t padding_count, const int64_t *stride, size_t stride_count, clika_rt_pad_mode mode, uint8_t value_has, double value, clika_rt_tensor **out)

ClikaRT::ops::unfold <- ClikaRT/compute/ops.h consumes x (contract §6) value read only when value_has is nonzero (contract §9) C++ defaults (dropped at this surface): mode=PadMode::Constant, value=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 2348

op_uniform_inplace​

clika_rt_error*(* op_uniform_inplace)(clika_rt_tensor *self, double low, double high, clika_rt_stream_or_device s)

ClikaRT::ops::uniform_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): low=0.0, high=1.0, s={}

Declared in clika_rt/clika_rt_core.h, line 4792

op_unique​

clika_rt_error*(* op_unique)(clika_rt_tensor *x, uint8_t sorted, uint8_t return_inverse, uint8_t return_counts, uint8_t dim_has, int64_t dim, clika_rt_tensor **out0, clika_rt_tensor **out1, clika_rt_tensor **out2)

ClikaRT::ops::unique <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): sorted=true, return_inverse=false, return_counts=false, dim=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 5239

op_unique_consecutive​

clika_rt_error*(* op_unique_consecutive)(clika_rt_tensor *x, uint8_t return_inverse, uint8_t return_counts, uint8_t dim_has, int64_t dim, clika_rt_tensor **out0, clika_rt_tensor **out1, clika_rt_tensor **out2)

ClikaRT::ops::unique_consecutive <- ClikaRT/compute/ops.h consumes x (contract §6) dim read only when dim_has is nonzero (contract §9) all-or-nothing: every out set, or every out NULL on failure (contract §10) C++ defaults (dropped at this surface): return_inverse=false, return_counts=false, dim=std::nullopt

Declared in clika_rt/clika_rt_core.h, line 5254

op_unsqueeze​

clika_rt_error*(* op_unsqueeze)(clika_rt_tensor *x, int64_t dim, clika_rt_tensor **out)

ClikaRT::ops::unsqueeze <- ClikaRT/compute/ops.h consumes x (contract §6)

Declared in clika_rt/clika_rt_core.h, line 4004

op_unsqueeze_inplace​

clika_rt_error*(* op_unsqueeze_inplace)(clika_rt_tensor *self, int64_t dim)

ClikaRT::ops::unsqueeze_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target)

Declared in clika_rt/clika_rt_core.h, line 4011

op_upsample_bicubic2d​

clika_rt_error*(* op_upsample_bicubic2d)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, const clika_rt_scalar_or_tensor *scale_factors, size_t scale_factors_count, uint8_t align_corners, clika_rt_tensor **out)

ClikaRT::ops::upsample_bicubic2d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, align_corners=false

Declared in clika_rt/clika_rt_core.h, line 5889

op_upsample_bilinear2d​

clika_rt_error*(* op_upsample_bilinear2d)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, const clika_rt_scalar_or_tensor *scale_factors, size_t scale_factors_count, uint8_t align_corners, clika_rt_tensor **out)

ClikaRT::ops::upsample_bilinear2d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, align_corners=false

Declared in clika_rt/clika_rt_core.h, line 5863

op_upsample_linear1d​

clika_rt_error*(* op_upsample_linear1d)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, const clika_rt_scalar_or_tensor *scale_factors, size_t scale_factors_count, uint8_t align_corners, clika_rt_tensor **out)

ClikaRT::ops::upsample_linear1d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, align_corners=false

Declared in clika_rt/clika_rt_core.h, line 5850

op_upsample_nearest1d​

clika_rt_error*(* op_upsample_nearest1d)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, const clika_rt_scalar_or_tensor *scale_factors, size_t scale_factors_count, clika_rt_tensor **out)

ClikaRT::ops::upsample_nearest1d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}

Declared in clika_rt/clika_rt_core.h, line 5814

op_upsample_nearest2d​

clika_rt_error*(* op_upsample_nearest2d)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, const clika_rt_scalar_or_tensor *scale_factors, size_t scale_factors_count, clika_rt_tensor **out)

ClikaRT::ops::upsample_nearest2d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}

Declared in clika_rt/clika_rt_core.h, line 5826

op_upsample_nearest3d​

clika_rt_error*(* op_upsample_nearest3d)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, const clika_rt_scalar_or_tensor *scale_factors, size_t scale_factors_count, clika_rt_tensor **out)

ClikaRT::ops::upsample_nearest3d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}

Declared in clika_rt/clika_rt_core.h, line 5838

op_upsample_trilinear3d​

clika_rt_error*(* op_upsample_trilinear3d)(clika_rt_tensor *x, const clika_rt_scalar_or_tensor *sizes, size_t sizes_count, const clika_rt_scalar_or_tensor *scale_factors, size_t scale_factors_count, uint8_t align_corners, clika_rt_tensor **out)

ClikaRT::ops::upsample_trilinear3d <- ClikaRT/compute/ops.h consumes x (contract §6) embedded tensors BORROWED (contract §11) embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): sizes={}, scale_factors={}, align_corners=false

Declared in clika_rt/clika_rt_core.h, line 5876

op_validate_rotary_dim​

clika_rt_error*(* op_validate_rotary_dim)(int64_t rotary_dim, int64_t head_dim)

ClikaRT::ops::validate_rotary_dim <- ClikaRT/compute/ops.h C++ defaults (dropped at this surface): head_dim=-1

Declared in clika_rt/clika_rt_core.h, line 2500

op_var​

clika_rt_error*(* op_var)(clika_rt_tensor *x, const int64_t *dims, size_t dims_count, int64_t correction, uint8_t keepdim, clika_rt_tensor **out)

ClikaRT::ops::var <- ClikaRT/compute/ops.h consumes x (contract §6) C++ defaults (dropped at this surface): dims={}, correction=1, keepdim=false

Declared in clika_rt/clika_rt_core.h, line 5055

op_where_nonzero​

clika_rt_error*(* op_where_nonzero)(clika_rt_tensor *condition, clika_rt_tensor **out)

ClikaRT::ops::where <- ClikaRT/compute/ops.h one form of the overloaded C++ where; the _nonzero suffix names this form consumes condition (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3208

op_where_select​

clika_rt_error*(* op_where_select)(clika_rt_tensor *condition, clika_rt_tensor *x, clika_rt_tensor *y, clika_rt_tensor **out)

ClikaRT::ops::where <- ClikaRT/compute/ops.h one form of the overloaded C++ where; the _select suffix names this form consumes condition (contract §6) consumes x (contract §6) consumes y (contract §6)

Declared in clika_rt/clika_rt_core.h, line 3200

op_xlog1py​

clika_rt_error*(* op_xlog1py)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::xlog1py <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1864

op_xlogy​

clika_rt_error*(* op_xlogy)(clika_rt_tensor *a, clika_rt_scalar_or_tensor other, clika_rt_tensor **out)

ClikaRT::ops::xlogy <- ClikaRT/compute/ops.h consumes a (contract §6) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1871

op_xlogy_inplace​

clika_rt_error*(* op_xlogy_inplace)(clika_rt_tensor *self, clika_rt_scalar_or_tensor other)

ClikaRT::ops::xlogy_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) other.kind == CLIKA_RT_SCALAR_OR_TENSOR_ABSENT = not provided; an embedded tensor is BORROWED (contract §11)

Declared in clika_rt/clika_rt_core.h, line 1879

op_zero_inplace​

clika_rt_error*(* op_zero_inplace)(clika_rt_tensor *self, clika_rt_stream_or_device s)

ClikaRT::ops::zero_ <- ClikaRT/compute/ops.h in-place op borrows self; written through (the in-place target) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 2949

op_zeros​

clika_rt_error*(* op_zeros)(const clika_rt_scalar_or_tensor *shape, size_t shape_count, clika_rt_data_type dtype, clika_rt_stream_or_device s, clika_rt_stream_or_device pinned_for, clika_rt_tensor **out)

ClikaRT::ops::zeros <- ClikaRT/compute/ops.h embedded tensors BORROWED (contract §11) C++ defaults (dropped at this surface): s={}, pinned_for={}

Declared in clika_rt/clika_rt_core.h, line 2938

op_zeros_like​

clika_rt_error*(* op_zeros_like)(clika_rt_tensor *reference, clika_rt_stream_or_device s, clika_rt_tensor **out)

ClikaRT::ops::zeros_like <- ClikaRT/compute/ops.h consumes reference (contract §6) C++ defaults (dropped at this surface): s={}

Declared in clika_rt/clika_rt_core.h, line 2955